@gylautorun/dev-proxy-cookie 1.0.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,801 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/proxy/core.ts
+import * as http from "http";
+import * as fs2 from "fs";
+import * as path3 from "path";
+import httpProxy from "http-proxy";
+
+// src/utils/cookie-reader.ts
+import * as fs from "fs";
+import * as path from "path";
+var CookieReader = class {
+  constructor(options) {
+    this.options = {
+      encoding: "utf-8",
+      ...options
+    };
+  }
+  readCookie() {
+    try {
+      const filePath = path.resolve(this.options.cookieFile);
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, this.options.encoding || "utf-8");
+        const lines = content.split("\n");
+        const cookieLines = lines.map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+        return cookieLines.join("; ");
+      }
+      return "";
+    } catch {
+      return "";
+    }
+  }
+  ensureCookieFile() {
+    const filePath = path.resolve(this.options.cookieFile);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, "");
+    }
+  }
+};
+function createCookieGetter(cookieFile) {
+  const reader = new CookieReader({ cookieFile });
+  return () => reader.readCookie();
+}
+
+// src/utils/cookie-watcher.ts
+import * as path2 from "path";
+import chokidar from "chokidar";
+var CookieWatcher = class {
+  constructor(options) {
+    this.watcher = null;
+    this.lastContent = "";
+    this.handleChange = () => {
+      const newContent = this.cookieReader.readCookie();
+      if (newContent !== this.lastContent) {
+        this.lastContent = newContent;
+        this.options.onCookieChange(newContent);
+        console.log(`[CookieWatcher] Cookie updated from file: ${this.options.cookieFile}`);
+      }
+    };
+    this.options = {
+      autoCreateFile: true,
+      ...options
+    };
+    this.cookieReader = new CookieReader({ cookieFile: options.cookieFile });
+  }
+  start() {
+    if (this.options.autoCreateFile) {
+      this.cookieReader.ensureCookieFile();
+    }
+    const watchPath = path2.resolve(this.options.cookieFile);
+    this.lastContent = this.cookieReader.readCookie();
+    console.log(`[CookieWatcher] Started watching: ${watchPath}`);
+    try {
+      this.watcher = chokidar.watch(watchPath, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 100,
+          pollInterval: 50
+        }
+      });
+      this.watcher.on("change", this.handleChange);
+      this.watcher.on("add", this.handleChange);
+      this.watcher.on("error", (error) => {
+        this.options.onError?.(error);
+      });
+    } catch (error) {
+      this.options.onError?.(error);
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+      console.log(`[CookieWatcher] Stopped watching: ${this.options.cookieFile}`);
+    }
+  }
+  getCurrentCookie() {
+    return this.lastContent;
+  }
+};
+function watchCookieFile(cookieFile, onCookieChange, onError) {
+  const watcher = new CookieWatcher({
+    cookieFile,
+    onCookieChange,
+    onError
+  });
+  watcher.start();
+  return watcher;
+}
+
+// src/utils/env-detector.ts
+function isProductionValue(value) {
+  const productionValues = [
+    "production",
+    // 生产环境
+    "prod",
+    // 生产环境
+    "prd",
+    // 生产环境
+    "release",
+    // 发布环境
+    "staging",
+    // 预发布环境
+    "uat"
+    // 预发布环境
+  ];
+  return productionValues.includes(value.toLowerCase().trim());
+}
+function detectProductionEnvironment(customEnvs = [], debug = false, loggerPrefix = "[env-detector]") {
+  const env = process.env;
+  if (customEnvs.length > 0) {
+    for (const envName of customEnvs) {
+      const envValue = env[envName];
+      if (envValue && isProductionValue(envValue)) {
+        if (debug) {
+          console.log(`${loggerPrefix} Detected production via custom env: ${envName}=${envValue}`);
+        }
+        return true;
+      }
+    }
+  }
+  const commonEnvNames = [
+    "NODE_ENV",
+    "BUILD_MODE",
+    "VUE_APP_ENV",
+    "VITE_NODE_ENV",
+    "WEBPACK_MODE",
+    "CI_ENV",
+    "APP_ENV",
+    "ENV",
+    "DEPLOY_ENV",
+    "RUN_MODE"
+  ];
+  for (const envName of commonEnvNames) {
+    const envValue = env[envName];
+    if (envValue && isProductionValue(envValue)) {
+      if (debug) {
+        console.log(`${loggerPrefix} Detected production via env: ${envName}=${envValue}`);
+      }
+      return true;
+    }
+  }
+  if (env.CI === "true" || env.CI === "1" || env.CI === "yes") {
+    if (debug) {
+      console.log(`${loggerPrefix} Detected production via CI env`);
+    }
+    return true;
+  }
+  if (env.npm_lifecycle_event) {
+    const lifecycleEvent = env.npm_lifecycle_event.toLowerCase();
+    if (lifecycleEvent.includes("build") || lifecycleEvent.includes("prod") || lifecycleEvent.includes("prd") || lifecycleEvent.includes("release")) {
+      if (debug) {
+        console.log(`${loggerPrefix} Detected production via lifecycle event: ${env.npm_lifecycle_event}`);
+      }
+      return true;
+    }
+  }
+  const processArgs = process.argv.join("").toLowerCase();
+  if (processArgs.includes("build") || processArgs.includes("production") || processArgs.includes("--mode=production") || processArgs.includes("--prod") || processArgs.includes("--release")) {
+    if (debug) {
+      console.log(`${loggerPrefix} Detected production via process arguments`);
+    }
+    return true;
+  }
+  return false;
+}
+function shouldEnableWatch(watch, customEnvs = [], debug = false, loggerPrefix = "[env-detector]") {
+  if (typeof watch === "boolean") {
+    if (debug && !watch) {
+      console.log(`${loggerPrefix} Watch disabled by user setting`);
+    }
+    return watch;
+  }
+  const isProduction = detectProductionEnvironment(customEnvs, debug, loggerPrefix);
+  if (isProduction) {
+    if (debug) {
+      console.log(`${loggerPrefix} Auto-detected production mode - disabling watch`);
+    }
+    return false;
+  }
+  if (debug) {
+    console.log(`${loggerPrefix} Auto-detected development mode - enabling watch`);
+  }
+  return true;
+}
+
+// src/proxy/apply-dev-cookie-header.ts
+function applyDevCookieHeader(proxyReq, cookie) {
+  if (!cookie) return;
+  proxyReq.removeHeader("cookie");
+  proxyReq.removeHeader("Cookie");
+  proxyReq.setHeader("Cookie", cookie);
+}
+
+// src/proxy/core.ts
+var AutoProxyCookie = class {
+  constructor(options) {
+    this.currentCookie = "";
+    this.server = null;
+    this.proxyServer = null;
+    this.watcher = null;
+    this.handleCookieChange = (newCookie) => {
+      if (newCookie !== this.currentCookie) {
+        this.currentCookie = newCookie;
+        this.log("info", "[AutoProxyCookie] Cookie updated:", newCookie ? "(has cookie)" : "(empty)");
+        if (this.options.autoRestart && this.options.restartMarkerFile) {
+          const markerPath = path3.resolve(this.options.restartMarkerFile);
+          fs2.writeFileSync(markerPath, JSON.stringify({
+            timestamp: Date.now(),
+            cookie: newCookie
+          }, null, 2));
+          this.log("info", "[AutoProxyCookie] Restart marker written to:", markerPath);
+          this.log("info", "[AutoProxyCookie] Please restart the dev server for changes to take effect");
+        }
+      }
+    };
+    this.handleOnProxyReq = (proxyReq, req, res, _options) => {
+      if (this.currentCookie) {
+        applyDevCookieHeader(proxyReq, this.currentCookie);
+      }
+      this.log("debug", "[AutoProxyCookie] Proxy Request:", req.method, req.url);
+      if (this.options.hooks.onProxyReq) {
+        try {
+          this.options.hooks.onProxyReq(proxyReq, req, res);
+        } catch (err) {
+          this.log("error", "[AutoProxyCookie] onProxyReq hook error:", err.message);
+        }
+      }
+    };
+    this.handleOnProxyRes = (proxyRes, req, res) => {
+      const allowedHeaders = [
+        "Content-Type",
+        "Content-Length",
+        "Authorization",
+        "Set-Cookie",
+        "X-Requested-With",
+        "Access-Control-Allow-Origin",
+        "Access-Control-Allow-Credentials"
+      ];
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(","));
+      res.setHeader("Access-Control-Allow-Credentials", "true");
+      this.log("debug", "[AutoProxyCookie] Proxy Response:", req.url, proxyRes.statusCode);
+      if (this.options.hooks.onProxyRes) {
+        try {
+          this.options.hooks.onProxyRes(proxyRes, req, res);
+        } catch (err) {
+          this.log("error", "[AutoProxyCookie] onProxyRes hook error:", err.message);
+        }
+      }
+    };
+    this.handleOnError = (err, req, res) => {
+      this.log("error", "[AutoProxyCookie] Proxy Error:", err.message);
+      this.log("error", "[AutoProxyCookie] URL:", req.url);
+      if (res instanceof http.ServerResponse && !res.headersSent) {
+        res.writeHead(503, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({
+          success: false,
+          message: "\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+          error: err.message
+        }));
+      }
+      if (this.options.hooks.onError) {
+        try {
+          this.options.hooks.onError(err, req, res);
+        } catch (hookErr) {
+          this.log("error", "[AutoProxyCookie] onError hook error:", hookErr.message);
+        }
+      }
+    };
+    this.handleOnWsError = (err, req, socket) => {
+      this.log("error", "[AutoProxyCookie] WebSocket Proxy Error:", err.message);
+      this.log("error", "[AutoProxyCookie] WebSocket URL:", req.url);
+      if (socket) {
+        socket.close();
+      }
+      if (this.options.hooks.onWsError) {
+        try {
+          this.options.hooks.onWsError(err, req, socket);
+        } catch (hookErr) {
+          this.log("error", "[AutoProxyCookie] onWsError hook error:", hookErr.message);
+        }
+      }
+    };
+    const defaultHooks = {
+      onProxyReq: () => {
+      },
+      onProxyRes: () => {
+      },
+      onError: () => {
+      },
+      onWsError: () => {
+      }
+    };
+    const mergedOptions = {
+      ...options,
+      hooks: {
+        ...defaultHooks,
+        ...options.hooks || {}
+      }
+    };
+    this.options = {
+      debug: false,
+      autoRestart: false,
+      restartMarkerFile: ".cookie-restart-marker",
+      proxyMap: {},
+      ignorePaths: [],
+      ws: true,
+      changeOrigin: true,
+      secure: false,
+      followRedirects: true,
+      autoRewrite: false,
+      protocolRewrite: void 0,
+      logLevel: "info",
+      cookieDomainRewrite: "*",
+      cookiePathRewrite: false,
+      headers: {},
+      ...mergedOptions
+    };
+    this.cookieReader = new CookieReader({ cookieFile: options.cookieFile });
+  }
+  getProxyUrl(req) {
+    const pathname = req.url?.split("?")[0] || "/";
+    const proxyMap = this.options.proxyMap || {};
+    for (const [prefix, target] of Object.entries(proxyMap)) {
+      if (pathname.startsWith(prefix)) {
+        return target;
+      }
+    }
+    return this.options.target;
+  }
+  isIgnoredPath(pathname) {
+    const ignorePaths = this.options.ignorePaths || [];
+    return ignorePaths.some(
+      (ignored) => pathname.startsWith(ignored)
+    );
+  }
+  log(level, ...args) {
+    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    const currentLevel = levels[this.options.logLevel || "info"];
+    const msgLevel = levels[level];
+    if (msgLevel >= currentLevel) {
+      if (level === "error") {
+        console.error(...args);
+      } else if (level === "warn") {
+        console.warn(...args);
+      } else {
+        console.log(...args);
+      }
+    }
+  }
+  createProxyOptions(target) {
+    const {
+      ws,
+      changeOrigin,
+      secure,
+      followRedirects,
+      autoRewrite,
+      protocolRewrite,
+      cookieDomainRewrite,
+      cookiePathRewrite,
+      headers
+    } = this.options;
+    return {
+      target,
+      ws,
+      changeOrigin,
+      secure,
+      followRedirects,
+      autoRewrite,
+      protocolRewrite,
+      cookieDomainRewrite,
+      cookiePathRewrite,
+      headers: {
+        ...headers
+      },
+      ignorePath: false
+    };
+  }
+  async setup(server) {
+    this.server = server;
+    this.currentCookie = this.cookieReader.readCookie();
+    try {
+      const baseOptions = {
+        target: this.options.target,
+        changeOrigin: this.options.changeOrigin,
+        secure: this.options.secure,
+        followRedirects: this.options.followRedirects,
+        autoRewrite: this.options.autoRewrite,
+        protocolRewrite: this.options.protocolRewrite,
+        cookieDomainRewrite: this.options.cookieDomainRewrite,
+        cookiePathRewrite: this.options.cookiePathRewrite,
+        ws: this.options.ws
+      };
+      this.proxyServer = httpProxy.createProxyServer(baseOptions);
+      this.proxyServer.on("proxyReq", this.handleOnProxyReq);
+      this.proxyServer.on("proxyRes", this.handleOnProxyRes);
+      this.proxyServer.on("error", this.handleOnError);
+      if (this.options.ws) {
+        this.proxyServer.on("wsError", this.handleOnWsError);
+      }
+      this.log("info", "[AutoProxyCookie] Proxy server created with WebSocket support");
+    } catch (err) {
+      this.log("warn", "[AutoProxyCookie] http-proxy create failed, using basic mode:", err.message);
+    }
+    server.middlewares.use((req, res, next) => {
+      const pathname = new URL(req.url || "/", "http://localhost").pathname;
+      if (this.isIgnoredPath(pathname)) {
+        next();
+        return;
+      }
+      this.currentCookie = this.cookieReader.readCookie();
+      if (this.proxyServer) {
+        const target = this.getProxyUrl(req);
+        if (this.options.debug || this.options.logLevel === "debug") {
+          this.log("info", `[AutoProxyCookie] ${pathname} -> ${target}`);
+        }
+        const proxyOptions = this.createProxyOptions(target);
+        try {
+          this.proxyServer.web(req, res, proxyOptions);
+        } catch (err) {
+          this.log("error", "[AutoProxyCookie] Proxy web error:", err.message);
+          next(err);
+        }
+      } else {
+        next();
+      }
+    });
+    if (this.options.ws && this.server.httpServer && this.proxyServer) {
+      this.server.httpServer.on("upgrade", (req, socket, head) => {
+        const pathname = new URL(req.url || "/", "http://localhost").pathname;
+        if (this.isIgnoredPath(pathname)) {
+          socket.destroy();
+          return;
+        }
+        const target = this.getProxyUrl(req);
+        this.proxyServer?.ws(req, socket, head, {
+          target,
+          ws: true,
+          changeOrigin: this.options.changeOrigin,
+          secure: this.options.secure
+        });
+      });
+      this.log("info", "[AutoProxyCookie] WebSocket upgrade handler registered");
+    }
+    this.startFileWatch();
+    this.log("info", "[AutoProxyCookie] Auto-proxy middleware enabled");
+    this.log("info", "[AutoProxyCookie] Target:", this.options.target);
+    this.log("info", "[AutoProxyCookie] Cookie file:", this.options.cookieFile);
+    if (this.options.autoRestart) {
+      this.log("info", "[AutoProxyCookie] Auto-restart enabled");
+    }
+    if (this.options.ws) {
+      this.log("info", "[AutoProxyCookie] WebSocket support enabled");
+    }
+  }
+  startFileWatch() {
+    let shouldWatch;
+    if (this.options.isDev !== void 0) {
+      shouldWatch = this.options.isDev;
+      if (this.options.debug) {
+        console.log(`[AutoProxyCookie] isDev=${this.options.isDev}, ${shouldWatch ? "enabling" : "disabling"} watch`);
+      }
+    } else {
+      shouldWatch = true;
+      if (this.options.debug) {
+        console.log("[AutoProxyCookie] Default behavior: enabling watch (dev mode)");
+      }
+    }
+    if (shouldWatch) {
+      this.watcher = watchCookieFile(
+        this.options.cookieFile,
+        this.handleCookieChange,
+        (error) => {
+          this.log("error", "[AutoProxyCookie] File watch error:", error.message);
+        }
+      );
+    } else if (this.options.debug) {
+      console.log("[AutoProxyCookie] File watch disabled");
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher = null;
+    }
+    if (this.proxyServer) {
+      this.proxyServer.close();
+      this.proxyServer = null;
+    }
+    this.log("info", "[AutoProxyCookie] Stopped");
+  }
+  getCurrentCookie() {
+    return this.currentCookie;
+  }
+};
+function createAutoProxyCookie(options) {
+  return new AutoProxyCookie(options);
+}
+
+// src/proxy/vite-plugin.ts
+function viteAutoProxyCookie(options) {
+  const {
+    name = "vite-auto-proxy-cookie",
+    isDev,
+    ...autoProxyOptions
+  } = options;
+  let autoProxy = null;
+  return {
+    name,
+    apply: "serve",
+    async configureServer(server) {
+      autoProxy = createAutoProxyCookie({
+        ...autoProxyOptions,
+        debug: options.debug ?? false,
+        autoRestart: options.autoRestart ?? true,
+        isDev
+      });
+      try {
+        await autoProxy.setup(server);
+      } catch (error) {
+        console.error("[vite-auto-proxy-cookie] Failed to setup proxy:", error);
+        if (options.debug) {
+          console.log("[vite-auto-proxy-cookie] Falling back to middleware mode");
+        }
+      }
+    },
+    closeBundle() {
+      autoProxy?.stop();
+    }
+  };
+}
+
+// src/proxy/vite-cookie-plugin.ts
+function viteDevProxyCookie(options) {
+  const { cookieFile, debug = false, onCookieChange, watch = "auto", isDev } = options;
+  let watcher = null;
+  let currentCookie = "";
+  const cookieReader = new CookieReader({ cookieFile });
+  return {
+    name: "vite-dev-proxy-cookie",
+    apply: "serve",
+    configureServer(server) {
+      currentCookie = cookieReader.readCookie();
+      if (debug) {
+        console.log("[vite-dev-proxy-cookie] Initial cookie loaded");
+      }
+      const middlewares = server.middlewares || server._middlewares || server.app;
+      if (middlewares && typeof middlewares.use === "function") {
+        middlewares.use((req, _res, next) => {
+          if (currentCookie && req.url?.startsWith("/")) {
+            req.headers = req.headers || {};
+            req.headers["cookie"] = currentCookie;
+          }
+          next();
+        });
+      } else {
+        console.warn("[vite-dev-proxy-cookie] Could not access middleware stack, cookie injection disabled");
+      }
+      let shouldWatch;
+      if (isDev !== void 0) {
+        shouldWatch = isDev;
+        if (debug) {
+          console.log(`[vite-dev-proxy-cookie] isDev=${isDev}, ${shouldWatch ? "enabling" : "disabling"} watch`);
+        }
+      } else {
+        shouldWatch = shouldEnableWatch(watch, [], debug, "[vite-dev-proxy-cookie]");
+      }
+      if (shouldWatch) {
+        watcher = watchCookieFile(
+          cookieFile,
+          (newCookie) => {
+            currentCookie = newCookie;
+            onCookieChange?.(newCookie);
+            console.log("[vite-dev-proxy-cookie] Cookie changed, please restart server for full effect");
+          },
+          (error) => {
+            console.error("[vite-dev-proxy-cookie] Watch error:", error.message);
+          }
+        );
+      } else if (debug) {
+        console.log("[vite-dev-proxy-cookie] File watch disabled");
+      }
+    },
+    closeBundle() {
+      watcher?.stop();
+    }
+  };
+}
+
+// src/proxy/vue-proxy-config.ts
+import * as path4 from "path";
+function createVueProxyConfig(target, options = {}) {
+  const {
+    getCookie,
+    debug = false,
+    headers = {},
+    ws = false,
+    changeOrigin = true,
+    secure = false,
+    onError: customOnError
+  } = options;
+  const config = {
+    ws,
+    target,
+    changeOrigin,
+    secure,
+    headers,
+    onProxyReq: (proxyReq, req) => {
+      const cookie = getCookie ? getCookie() : "";
+      if (cookie) {
+        applyDevCookieHeader(proxyReq, cookie);
+      }
+      if (debug) {
+        const reqPath = req.url || "/";
+        console.log("[Proxy Request]", reqPath, req.method, cookie ? "(with cookie)" : "(no cookie)");
+      }
+    },
+    onError: customOnError || ((err) => {
+      console.error("\n[Proxy Error]", err.message);
+    })
+  };
+  return config;
+}
+function createFileCookieGetter(cookieFile, options = {}) {
+  const {
+    watch = "auto",
+    debug = false,
+    productionEnvs = [],
+    isDev
+  } = options;
+  const reader = new CookieReader({ cookieFile: path4.resolve(cookieFile) });
+  let shouldWatch;
+  if (isDev !== void 0) {
+    shouldWatch = isDev;
+    if (debug) {
+      console.log(`[CookieFile] isDev=${isDev}, ${shouldWatch ? "enabling" : "disabling"} watch`);
+    }
+  } else {
+    shouldWatch = shouldEnableWatch(watch, productionEnvs, debug, "[CookieFile]");
+  }
+  if (shouldWatch) {
+    watchCookieFile(
+      path4.resolve(cookieFile),
+      (newCookie) => {
+        if (debug) {
+          console.log("[CookieFile] Updated:", newCookie ? "(has cookie)" : "(empty)");
+        }
+      },
+      (error) => {
+        console.error("[CookieFile] Watch error:", error.message);
+      }
+    );
+  } else if (debug) {
+    console.log("[CookieFile] File watch disabled");
+  }
+  return () => reader.readCookie();
+}
+function createAutoProxyConfig(options) {
+  const { target, ignorePaths = [], includePaths = [], additionalProxies = {}, getCookie, debug, headers } = options;
+  const result = {};
+  if (includePaths.length > 0) {
+    for (const proxyPath of includePaths) {
+      result[proxyPath] = createVueProxyConfig(target, { getCookie, debug, headers });
+    }
+  } else {
+    const defaultProxy = {
+      ws: false,
+      target,
+      changeOrigin: true,
+      secure: false,
+      headers,
+      onProxyReq: (proxyReq, req) => {
+        const reqPath = req.url || "/";
+        if (ignorePaths.some((p) => reqPath.startsWith(p))) {
+          return;
+        }
+        const cookie = getCookie ? getCookie() : "";
+        if (cookie) {
+          applyDevCookieHeader(proxyReq, cookie);
+        }
+        if (debug) {
+          console.log("[Proxy Request]", reqPath, req.method, cookie ? "(with cookie)" : "(no cookie)");
+        }
+      },
+      onError: (err) => {
+        console.error("\n[Proxy Error]", err.message);
+      }
+    };
+    result["/"] = defaultProxy;
+  }
+  for (const [proxyPath, proxyTarget] of Object.entries(additionalProxies)) {
+    result[proxyPath] = createVueProxyConfig(proxyTarget, { getCookie, debug, headers });
+  }
+  return result;
+}
+
+// src/proxy/vite-adapter.ts
+var viteVersion = "";
+var majorVersion = null;
+function detectViteVersion() {
+  if (majorVersion !== null) {
+    return majorVersion;
+  }
+  try {
+    const pkg = __require("vite/package.json");
+    viteVersion = pkg.version;
+    majorVersion = parseInt(viteVersion.split(".")[0], 10);
+  } catch {
+    majorVersion = 5;
+  }
+  return majorVersion;
+}
+function createDevProxyCookie(options) {
+  const {
+    mode = "auto",
+    watch = "auto",
+    isDev,
+    ...restOptions
+  } = options;
+  const version = detectViteVersion();
+  if (options.debug) {
+    console.log(`[dev-proxy-cookie] Detected Vite ${version}.x`);
+  }
+  if (mode === "cookie" || mode === "auto" && !options.target) {
+    return viteDevProxyCookie({
+      cookieFile: options.cookieFile,
+      debug: options.debug,
+      onCookieChange: options.onCookieChange,
+      watch,
+      isDev
+    });
+  }
+  const pluginOptions = {
+    cookieFile: options.cookieFile,
+    target: options.target,
+    debug: options.debug,
+    autoRestart: options.autoRestart ?? true,
+    restartMarkerFile: options.restartMarkerFile,
+    proxyMap: options.proxyMap,
+    ignorePaths: options.ignorePaths
+  };
+  return viteAutoProxyCookie(pluginOptions);
+}
+function getViteVersion() {
+  detectViteVersion();
+  return viteVersion;
+}
+function getViteMajorVersion() {
+  return detectViteVersion();
+}
+export {
+  AutoProxyCookie,
+  CookieReader,
+  CookieWatcher,
+  createAutoProxyConfig,
+  createAutoProxyCookie,
+  createCookieGetter,
+  createDevProxyCookie,
+  createFileCookieGetter,
+  createVueProxyConfig,
+  detectProductionEnvironment,
+  getViteMajorVersion,
+  getViteVersion,
+  isProductionValue,
+  shouldEnableWatch,
+  viteAutoProxyCookie,
+  viteDevProxyCookie,
+  watchCookieFile
+};