vite-plugin-mock-dev-server 1.6.1 → 1.7.1

package/dist/index.cjs

@@ -1,153 +1,51 @@
-"use strict";
-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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+var _chunkFND5XIG2cjs = require('./chunk-FND5XIG2.cjs');
+
+
+
+
+
+
+
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  baseMiddleware: () => baseMiddleware,
-  createDefineMock: () => createDefineMock,
-  createLogger: () => createLogger,
-  default: () => src_default,
-  defineMock: () => defineMock,
-  defineMockData: () => defineMockData,
-  logLevels: () => logLevels,
-  mockDevServerPlugin: () => mockDevServerPlugin,
-  mockWebSocket: () => mockWebSocket,
-  sortByValidator: () => sortByValidator,
-  transformMockData: () => transformMockData
-});
-module.exports = __toCommonJS(src_exports);
 
-// node_modules/.pnpm/tsup@8.2.3_jiti@1.21.0_postcss@8.4.40_typescript@5.5.4/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+
+
+
+
+
+var _chunkS76FMTCDcjs = require('./chunk-S76FMTCD.cjs');
 
 // src/plugin.ts
-var import_node_process5 = __toESM(require("process"), 1);
-var import_utils16 = require("@pengzhanbo/utils");
+var _utils = require('@pengzhanbo/utils');
 
-// src/build.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_process3 = __toESM(require("process"), 1);
-var import_utils2 = require("@pengzhanbo/utils");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_is_core_module = __toESM(require("is-core-module"), 1);
-var import_pluginutils = require("@rollup/pluginutils");
-var import_picocolors = __toESM(require("picocolors"), 1);
+// src/core/build.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 
-// src/compiler.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_module = require("module");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
-var import_node_process = __toESM(require("process"), 1);
-var import_esbuild = require("esbuild");
-var import_json5 = __toESM(require("json5"), 1);
+var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
+var _iscoremodule = require('is-core-module'); var _iscoremodule2 = _interopRequireDefault(_iscoremodule);
+var _pluginutils = require('@rollup/pluginutils');
+var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
+
+// src/core/compiler.ts
 
-// src/utils.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_node_querystring = require("querystring");
-var import_node_url = require("url");
-var import_node_os = __toESM(require("os"), 1);
-var import_debug = __toESM(require("debug"), 1);
-var import_path_to_regexp = require("path-to-regexp");
-function isStream(stream) {
-  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
-}
-function isReadableStream(stream) {
-  return isStream(stream) && stream.readable !== false && typeof stream._read === "function" && typeof stream._readableState === "object";
-}
-function getDirname(importMetaUrl2) {
-  return import_node_path.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl2));
-}
-var debug = (0, import_debug.default)("vite:mock-dev-server");
-function lookupFile(dir, formats, options) {
-  for (const format of formats) {
-    const fullPath = import_node_path.default.join(dir, format);
-    if (import_node_fs.default.existsSync(fullPath) && import_node_fs.default.statSync(fullPath).isFile()) {
-      const result = (options == null ? void 0 : options.pathOnly) ? fullPath : import_node_fs.default.readFileSync(fullPath, "utf-8");
-      if (!(options == null ? void 0 : options.predicate) || options.predicate(result))
-        return result;
-    }
-  }
-  const parentDir = import_node_path.default.dirname(dir);
-  if (parentDir !== dir && (!(options == null ? void 0 : options.rootDir) || parentDir.startsWith(options == null ? void 0 : options.rootDir))) {
-    return lookupFile(parentDir, formats, options);
-  }
-}
-function ensureProxies(serverProxy = {}) {
-  const httpProxies = [];
-  const wsProxies = [];
-  Object.keys(serverProxy).forEach((key) => {
-    var _a, _b;
-    const value = serverProxy[key];
-    if (typeof value === "string" || !value.ws && !((_a = value.target) == null ? void 0 : _a.toString().startsWith("ws:")) && !((_b = value.target) == null ? void 0 : _b.toString().startsWith("wss:"))) {
-      httpProxies.push(key);
-    } else {
-      wsProxies.push(key);
-    }
-  });
-  return { httpProxies, wsProxies };
-}
-function doesProxyContextMatchUrl(context, url) {
-  return context[0] === "^" && new RegExp(context).test(url) || url.startsWith(context);
-}
-function parseParams(pattern, url) {
-  const urlMatch = (0, import_path_to_regexp.match)(pattern, { decode: decodeURIComponent })(url) || {
-    params: {}
-  };
-  return urlMatch.params || {};
-}
-function urlParse(input) {
-  const url = new import_node_url.URL(input, "http://example.com");
-  const pathname = decodeURIComponent(url.pathname);
-  const query = (0, import_node_querystring.parse)(url.search.replace(/^\?/, ""));
-  return { pathname, query };
-}
-var windowsSlashRE = /\\/g;
-var isWindows = import_node_os.default.platform() === "win32";
-function slash(p) {
-  return p.replace(windowsSlashRE, "/");
-}
-function normalizePath(id) {
-  return import_node_path.default.posix.normalize(isWindows ? slash(id) : id);
-}
 
-// src/compiler.ts
+var _url = require('url');
+
+var _esbuild = require('esbuild');
+var _json5 = require('json5'); var _json52 = _interopRequireDefault(_json5);
 var externalizeDeps = {
   name: "externalize-deps",
   setup(build2) {
     build2.onResolve({ filter: /.*/ }, ({ path: id }) => {
-      if (id[0] !== "." && !import_node_path2.default.isAbsolute(id))
+      if (id[0] !== "." && !_path2.default.isAbsolute(id))
         return { external: true };
     });
   }
@@ -155,10 +53,10 @@ var externalizeDeps = {
 var json5Loader = {
   name: "json5-loader",
   setup(build2) {
-    build2.onLoad({ filter: /\.json5$/ }, async ({ path: path4 }) => {
-      const content = await import_node_fs2.promises.readFile(path4, "utf-8");
+    build2.onLoad({ filter: /\.json5$/ }, async ({ path: path3 }) => {
+      const content = await _fs.promises.readFile(path3, "utf-8");
       return {
-        contents: `export default ${JSON.stringify(import_json5.default.parse(content))}`,
+        contents: `export default ${JSON.stringify(_json52.default.parse(content))}`,
         loader: "js"
       };
     });
@@ -167,8 +65,8 @@ var json5Loader = {
 var jsonLoader = {
   name: "json-loader",
   setup(build2) {
-    build2.onLoad({ filter: /\.json$/ }, async ({ path: path4 }) => {
-      const content = await import_node_fs2.promises.readFile(path4, "utf-8");
+    build2.onLoad({ filter: /\.json$/ }, async ({ path: path3 }) => {
+      const content = await _fs.promises.readFile(path3, "utf-8");
       return {
         contents: `export default ${content}`,
         loader: "js"
@@ -176,6 +74,20 @@ var jsonLoader = {
     });
   }
 };
+var renamePlugin = {
+  name: "rename-plugin",
+  setup(build2) {
+    build2.onResolve({ filter: /.*/ }, ({ path: id }) => {
+      if (id === "vite-plugin-mock-dev-server") {
+        return {
+          path: "vite-plugin-mock-dev-server/helper",
+          external: true
+        };
+      }
+      return null;
+    });
+  }
+};
 function aliasPlugin(alias) {
   return {
     name: "alias-plugin",
@@ -208,215 +120,107 @@ function aliasMatches(pattern, importee) {
   return importee.startsWith(`${pattern}/`);
 }
 async function transformWithEsbuild(entryPoint, options) {
-  var _a;
-  const { isESM = true, define, alias, cwd = import_node_process.default.cwd() } = options;
+  const { isESM = true, define, alias, cwd = _process2.default.cwd() } = options;
+  const filepath = _path2.default.resolve(cwd, entryPoint);
+  const filename = _path2.default.basename(entryPoint);
+  const dirname = _path2.default.dirname(filepath);
   try {
-    const result = await (0, import_esbuild.build)({
+    const result = await _esbuild.build.call(void 0, {
       entryPoints: [entryPoint],
       outfile: "out.js",
       write: false,
-      target: ["node16"],
+      target: ["node18"],
       platform: "node",
       bundle: true,
       metafile: true,
       format: isESM ? "esm" : "cjs",
-      define,
-      plugins: [aliasPlugin(alias), externalizeDeps, jsonLoader, json5Loader],
+      define: {
+        ...define,
+        __dirname: JSON.stringify(dirname),
+        __filename: JSON.stringify(filename),
+        ...isESM ? {} : { "import.meta.url": JSON.stringify(_url.pathToFileURL.call(void 0, filepath)) }
+      },
+      plugins: [aliasPlugin(alias), renamePlugin, externalizeDeps, jsonLoader, json5Loader],
       absWorkingDir: cwd
     });
     return {
       code: result.outputFiles[0].text,
-      deps: ((_a = result.metafile) == null ? void 0 : _a.inputs) || {}
+      deps: _optionalChain([result, 'access', _2 => _2.metafile, 'optionalAccess', _3 => _3.inputs]) || {}
     };
   } catch (e) {
     console.error(e);
   }
   return { code: "", deps: {} };
 }
-var _dirname = getDirname(importMetaUrl);
-var _require = (0, import_node_module.createRequire)(_dirname);
 async function loadFromCode({
   filepath,
   code,
   isESM,
   cwd
 }) {
-  filepath = import_node_path2.default.resolve(cwd, filepath);
-  if (isESM) {
-    const fileBase = `${filepath}.timestamp-${Date.now()}`;
-    const fileNameTmp = `${fileBase}.mjs`;
-    const fileUrl = `${(0, import_node_url2.pathToFileURL)(fileBase)}.mjs`;
-    await import_node_fs2.promises.writeFile(fileNameTmp, code, "utf8");
+  filepath = _path2.default.resolve(cwd, filepath);
+  const ext = isESM ? ".mjs" : ".cjs";
+  const filepathTmp = `${filepath}.timestamp-${Date.now()}${ext}`;
+  const file = _url.pathToFileURL.call(void 0, filepathTmp).toString();
+  await _fs.promises.writeFile(filepathTmp, code, "utf8");
+  try {
+    const mod = await import(file);
+    return mod.default || mod;
+  } finally {
     try {
-      return await import(fileUrl);
-    } finally {
-      try {
-        import_node_fs2.default.unlinkSync(fileNameTmp);
-      } catch {
-      }
+      _fs2.default.unlinkSync(filepathTmp);
+    } catch (e2) {
     }
-  } else {
-    const extension = import_node_path2.default.extname(filepath);
-    const realFileName = import_node_fs2.default.realpathSync(filepath);
-    const loaderExt = extension in _require.extensions ? extension : ".js";
-    const defaultLoader = _require.extensions[loaderExt];
-    _require.extensions[loaderExt] = (module2, filename) => {
-      if (filename === realFileName) {
-        ;
-        module2._compile(code, filename);
-      } else {
-        defaultLoader(module2, filename);
-      }
-    };
-    delete _require.cache[_require.resolve(filepath)];
-    const raw = _require(filepath);
-    _require.extensions[loaderExt] = defaultLoader;
-    return raw.__esModule ? raw : { default: raw };
   }
 }
 
-// src/define.ts
-var import_node_process2 = __toESM(require("process"), 1);
-function viteDefine(config) {
-  const processNodeEnv = {};
-  const nodeEnv = import_node_process2.default.env.NODE_ENV || config.mode;
-  Object.assign(processNodeEnv, {
-    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
-    "global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
-    "globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
-  });
-  const userDefine = {};
-  const userDefineEnv = {};
-  for (const key in config.define) {
-    const val = config.define[key];
-    const isMetaEnv = key.startsWith("import.meta.env.");
-    if (typeof val === "string") {
-      if (canJsonParse(val)) {
-        userDefine[key] = val;
-        if (isMetaEnv)
-          userDefineEnv[key.slice(16)] = val;
-      }
-    } else {
-      userDefine[key] = handleDefineValue(val);
-      if (isMetaEnv)
-        userDefineEnv[key.slice(16)] = val;
-    }
-  }
-  const importMetaKeys = {};
-  const importMetaEnvKeys = {};
-  const importMetaFallbackKeys = {};
-  importMetaKeys["import.meta.hot"] = `undefined`;
-  for (const key in config.env) {
-    const val = JSON.stringify(config.env[key]);
-    importMetaKeys[`import.meta.env.${key}`] = val;
-    importMetaEnvKeys[key] = val;
-  }
-  importMetaFallbackKeys["import.meta.env"] = `undefined`;
-  const define = {
-    ...processNodeEnv,
-    ...importMetaKeys,
-    ...userDefine,
-    ...importMetaFallbackKeys
-  };
-  if ("import.meta.env" in define) {
-    define["import.meta.env"] = serializeDefine({
-      ...importMetaEnvKeys,
-      ...userDefineEnv
-    });
-  }
-  return define;
-}
-function serializeDefine(define) {
-  let res = `{`;
-  const keys = Object.keys(define);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const val = define[key];
-    res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
-    if (i !== keys.length - 1)
-      res += `, `;
-  }
-  return `${res}}`;
-}
-function handleDefineValue(value) {
-  if (typeof value === "undefined")
-    return "undefined";
-  if (typeof value === "string")
-    return value;
-  return JSON.stringify(value);
-}
-function canJsonParse(value) {
-  try {
-    JSON.parse(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/build.ts
-var packageName = true ? "vite-plugin-mock-dev-server" : "vite-plugin-mock-dev-server";
-var packageVersion = true ? "1.6.1" : "latest";
-async function generateMockServer(ctx, config, options) {
-  const include = (0, import_utils2.toArray)(options.include);
-  const exclude = (0, import_utils2.toArray)(options.exclude);
-  const define = viteDefine(config);
-  const cwd = options.cwd || import_node_process3.default.cwd();
-  const { httpProxies } = ensureProxies(config.server.proxy || {});
-  httpProxies.push(...(0, import_utils2.toArray)(options.prefix));
-  const wsProxies = (0, import_utils2.toArray)(options.wsPrefix);
+// src/core/build.ts
+async function generateMockServer(ctx, options) {
+  const include = _utils.toArray.call(void 0, options.include);
+  const exclude = _utils.toArray.call(void 0, options.exclude);
+  const cwd = options.cwd || _process2.default.cwd();
   let pkg = {};
   try {
-    const pkgStr = lookupFile(config.root, ["package.json"]);
+    const pkgStr = _chunkS76FMTCDcjs.lookupFile.call(void 0, options.context, ["package.json"]);
     if (pkgStr)
       pkg = JSON.parse(pkgStr);
-  } catch {
+  } catch (e3) {
   }
   const outputDir = options.build.dist;
   const content = await generateMockEntryCode(cwd, include, exclude);
-  const mockEntry = import_node_path3.default.join(cwd, `mock-data-${Date.now()}.js`);
-  await import_promises.default.writeFile(mockEntry, content, "utf-8");
-  const { code, deps } = await transformWithEsbuild(mockEntry, {
-    define,
-    alias: config.resolve.alias
-  });
-  const mockDeps = getMockDependencies(deps, config.resolve.alias);
-  await import_promises.default.unlink(mockEntry);
+  const mockEntry = _path2.default.join(cwd, `mock-data-${Date.now()}.js`);
+  await _promises2.default.writeFile(mockEntry, content, "utf-8");
+  const { code, deps } = await transformWithEsbuild(mockEntry, options);
+  const mockDeps = getMockDependencies(deps, options.alias);
+  await _promises2.default.unlink(mockEntry);
   const outputList = [
     {
-      filename: import_node_path3.default.join(outputDir, "mock-data.js"),
+      filename: _path2.default.join(outputDir, "mock-data.js"),
       source: code
     },
     {
-      filename: import_node_path3.default.join(outputDir, "index.js"),
-      source: generatorServerEntryCode(
-        httpProxies,
-        wsProxies,
-        options.cookiesOptions,
-        options.bodyParserOptions,
-        options.priority,
-        options.build
-      )
+      filename: _path2.default.join(outputDir, "index.js"),
+      source: generatorServerEntryCode(options)
     },
     {
-      filename: import_node_path3.default.join(outputDir, "package.json"),
+      filename: _path2.default.join(outputDir, "package.json"),
       source: generatePackageJson(pkg, mockDeps)
     }
   ];
   try {
-    if (import_node_path3.default.isAbsolute(outputDir)) {
+    if (_path2.default.isAbsolute(outputDir)) {
       for (const { filename } of outputList) {
-        if (import_node_fs3.default.existsSync(filename))
-          await import_promises.default.rm(filename);
+        if (_fs2.default.existsSync(filename))
+          await _promises2.default.rm(filename);
       }
-      config.logger.info(`${import_picocolors.default.green("\u2713")} generate mock server in ${import_picocolors.default.cyan(outputDir)}`);
+      options.logger.info(`${_picocolors2.default.green("\u2713")} generate mock server in ${_picocolors2.default.cyan(outputDir)}`);
       for (const { filename, source } of outputList) {
-        import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(filename), { recursive: true });
-        await import_promises.default.writeFile(filename, source, "utf-8");
+        _fs2.default.mkdirSync(_path2.default.dirname(filename), { recursive: true });
+        await _promises2.default.writeFile(filename, source, "utf-8");
         const sourceSize = (source.length / 1024).toFixed(2);
-        const name = import_node_path3.default.relative(outputDir, filename);
+        const name = _path2.default.relative(outputDir, filename);
         const space = name.length < 30 ? " ".repeat(30 - name.length) : "";
-        config.logger.info(`  ${import_picocolors.default.green(name)}${space}${import_picocolors.default.bold(import_picocolors.default.dim(`${sourceSize} kB`))}`);
+        options.logger.info(`  ${_picocolors2.default.green(name)}${space}${_picocolors2.default.bold(_picocolors2.default.dim(`${sourceSize} kB`))}`);
       }
     } else {
       for (const { filename, source } of outputList) {
@@ -433,17 +237,25 @@ async function generateMockServer(ctx, config, options) {
 }
 function getMockDependencies(deps, alias) {
   const list = /* @__PURE__ */ new Set();
-  const excludeDeps = [packageName, "connect", "cors"];
+  const excludeDeps = ["vite-plugin-mock-dev-server", "connect", "cors"];
   const isAlias = (p) => alias.find(({ find }) => aliasMatches(find, p));
   Object.keys(deps).forEach((mPath) => {
     const imports = deps[mPath].imports.filter((_) => _.external && !_.path.startsWith("<define:") && !isAlias(_.path)).map((_) => _.path);
     imports.forEach((dep) => {
-      if (!excludeDeps.includes(dep) && !(0, import_is_core_module.default)(dep))
-        list.add(dep);
+      const name = normalizePackageName(dep);
+      if (!excludeDeps.includes(name) && !_iscoremodule2.default.call(void 0, name))
+        list.add(name);
     });
   });
   return Array.from(list);
 }
+function normalizePackageName(dep) {
+  const [scope, name] = dep.split("/");
+  if (scope[0] === "@") {
+    return `${scope}/${name}`;
+  }
+  return scope;
+}
 function generatePackageJson(pkg, mockDeps) {
   const { dependencies = {}, devDependencies = {} } = pkg;
   const dependents = { ...dependencies, ...devDependencies };
@@ -454,9 +266,9 @@ function generatePackageJson(pkg, mockDeps) {
       start: "node index.js"
     },
     dependencies: {
-      "connect": "^3.7.0",
-      "vite-plugin-mock-dev-server": `^${packageVersion}`,
-      "cors": "^2.8.5"
+      connect: "^3.7.0",
+      ["vite-plugin-mock-dev-server"]: `^${"1.7.0"}`,
+      cors: "^2.8.5"
     },
     pnpm: { peerDependencyRules: { ignoreMissing: ["vite"] } }
   };
@@ -465,35 +277,37 @@ function generatePackageJson(pkg, mockDeps) {
   });
   return JSON.stringify(mockPkg, null, 2);
 }
-function generatorServerEntryCode(httpProxies, wsProxies, cookiesOptions = {}, bodyParserOptions = {}, priority = {}, build2) {
+function generatorServerEntryCode({
+  proxies,
+  wsProxies,
+  cookiesOptions,
+  bodyParserOptions,
+  priority,
+  build: build2
+}) {
   const { serverPort, log } = build2;
   return `import { createServer } from 'node:http';
 import connect from 'connect';
 import corsMiddleware from 'cors';
-import { baseMiddleware, createLogger, mockWebSocket } from 'vite-plugin-mock-dev-server';
+import { baseMiddleware, createLogger, mockWebSocket } from 'vite-plugin-mock-dev-server/server';
 import mockData from './mock-data.js';
 
 const app = connect();
 const server = createServer(app);
 const logger = createLogger('mock-server', '${log}');
-const httpProxies = ${JSON.stringify(httpProxies)};
+const proxies = ${JSON.stringify(proxies)};
 const wsProxies = ${JSON.stringify(wsProxies)};
 const cookiesOptions = ${JSON.stringify(cookiesOptions)};
 const bodyParserOptions = ${JSON.stringify(bodyParserOptions)};
 const priority = ${JSON.stringify(priority)};
+const compiler = { mockData }
 
-mockWebSocket({ 
-  loader: { mockData },
-  httpServer: server,
-  proxies: wsProxies,
-  cookiesOptions,
-  logger,
-});
+mockWebSocket(compiler, server, { wsProxies, cookiesOptions, logger });
 
 app.use(corsMiddleware());
-app.use(baseMiddleware({ mockData }, {
+app.use(baseMiddleware(compiler, {
   formidableOptions: { multiples: true },
-  proxies: httpProxies,
+  proxies,
   priority,
   cookiesOptions,
   bodyParserOptions,
@@ -506,717 +320,72 @@ console.log('listen: http://localhost:${serverPort}');
 `;
 }
 async function generateMockEntryCode(cwd, include, exclude) {
-  const includePaths = await (0, import_fast_glob.default)(include, { cwd });
-  const includeFilter = (0, import_pluginutils.createFilter)(include, exclude, {
+  const includePaths = await _fastglob2.default.call(void 0, include, { cwd });
+  const includeFilter = _pluginutils.createFilter.call(void 0, include, exclude, {
     resolve: false
   });
   const mockFiles = includePaths.filter(includeFilter);
   let importers = "";
-  let exporters = "";
+  const exporters = [];
   mockFiles.forEach((filepath, index) => {
-    const file = normalizePath(import_node_path3.default.join(cwd, filepath));
+    const file = _chunkS76FMTCDcjs.normalizePath.call(void 0, _path2.default.join(cwd, filepath));
     importers += `import * as m${index} from '${file}';
 `;
-    exporters += `m${index}, `;
+    exporters.push(`[m${index}, '${filepath}']`);
   });
-  return `import { transformMockData } from 'vite-plugin-mock-dev-server';
+  return `import { transformMockData, transformRawData } from 'vite-plugin-mock-dev-server/server';
 ${importers}
-const exporters = [${exporters}];
-const mockList = exporters.map((raw) => {
-  let mockConfig
-  if (raw.default) {
-    mockConfig = raw.default
-  } else {
-    mockConfig = []
-    Object.keys(raw || {}).forEach((key) => {
-      Array.isArray(raw[key])
-        ? mockConfig.push(...raw[key])
-        : mockConfig.push(raw[key])
-    })
-  }
-  return mockConfig
+const exporters = [
+  ${exporters.join(",\n  ")}
+];
+const mockList = exporters.map(([mod, filepath]) => {
+  const raw = mod.default || mod;
+  return transformRawData(raw, filepath);
 });
 export default transformMockData(mockList);`;
 }
 
-// src/mockMiddleware.ts
-var import_utils14 = require("@pengzhanbo/utils");
-var import_cors = __toESM(require("cors"), 1);
-var import_path_to_regexp5 = require("path-to-regexp");
-var import_picocolors5 = __toESM(require("picocolors"), 1);
-
-// src/baseMiddleware.ts
-var import_node_buffer2 = require("buffer");
-var import_utils6 = require("@pengzhanbo/utils");
-var import_cookies = __toESM(require("cookies"), 1);
-var import_http_status = __toESM(require("http-status"), 1);
-var mime = __toESM(require("mime-types"), 1);
-var import_path_to_regexp3 = require("path-to-regexp");
-var import_picocolors2 = __toESM(require("picocolors"), 1);
+// src/core/mockMiddleware.ts
+var _cors = require('cors'); var _cors2 = _interopRequireDefault(_cors);
+var _pathtoregexp = require('path-to-regexp');
 
-// src/matchingWeight.ts
-var import_utils4 = require("@pengzhanbo/utils");
-var import_path_to_regexp2 = require("path-to-regexp");
-var tokensCache = {};
-function getTokens(rule) {
-  if (tokensCache[rule])
-    return tokensCache[rule];
-  const tks = (0, import_path_to_regexp2.parse)(rule);
-  const tokens = [];
-  for (const tk of tks) {
-    if (!(0, import_utils4.isString)(tk)) {
-      tokens.push(tk);
-    } else {
-      const hasPrefix = tk[0] === "/";
-      const subTks = hasPrefix ? tk.slice(1).split("/") : tk.split("/");
-      tokens.push(
-        `${hasPrefix ? "/" : ""}${subTks[0]}`,
-        ...subTks.slice(1).map((t) => `/${t}`)
-      );
-    }
-  }
-  tokensCache[rule] = tokens;
-  return tokens;
-}
-function getHighest(rules) {
-  let weights = rules.map((rule) => getTokens(rule).length);
-  weights = weights.length === 0 ? [1] : weights;
-  return Math.max(...weights) + 2;
-}
-function sortFn(rule) {
-  const tokens = getTokens(rule);
-  let w = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!(0, import_utils4.isString)(token))
-      w += 10 ** (i + 1);
-    w += 10 ** (i + 1);
-  }
-  return w;
-}
-function preSort(rules) {
-  let matched = [];
-  const preMatch = [];
-  for (const rule of rules) {
-    const tokens = getTokens(rule);
-    const len = tokens.filter((token) => typeof token !== "string").length;
-    if (!preMatch[len])
-      preMatch[len] = [];
-    preMatch[len].push(rule);
-  }
-  for (const match2 of preMatch.filter((v) => v && v.length > 0))
-    matched = [...matched, ...(0, import_utils4.sortBy)(match2, sortFn).reverse()];
-  return matched;
-}
-function defaultPriority(rules) {
-  const highest = getHighest(rules);
-  return (0, import_utils4.sortBy)(rules, (rule) => {
-    const tokens = getTokens(rule);
-    const dym = tokens.filter((token) => typeof token !== "string");
-    if (dym.length === 0)
-      return 0;
-    let weight = dym.length;
-    let exp = 0;
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i];
-      const isDynamic = !(0, import_utils4.isString)(token);
-      const {
-        pattern = "",
-        modifier,
-        prefix,
-        name
-      } = isDynamic ? token : {};
-      const isGlob = pattern && pattern.includes(".*");
-      const isSlash = prefix === "/";
-      const isNamed = (0, import_utils4.isString)(name);
-      exp += isDynamic && isSlash ? 1 : 0;
-      if (i === tokens.length - 1 && isGlob) {
-        weight += 5 * 10 ** (tokens.length === 1 ? highest + 1 : highest);
-      } else {
-        if (isGlob) {
-          weight += 3 * 10 ** (highest - 1);
-        } else if (pattern) {
-          if (isSlash) {
-            weight += (isNamed ? 2 : 1) * 10 ** (exp + 1);
-          } else {
-            weight -= 1 * 10 ** exp;
-          }
-        }
-      }
-      if (modifier === "+")
-        weight += 1 * 10 ** (highest - 1);
-      if (modifier === "*")
-        weight += 1 * 10 ** (highest - 1) + 1;
-      if (modifier === "?")
-        weight += 1 * 10 ** (exp + (isSlash ? 1 : 0));
-    }
-    return weight;
-  });
-}
-function matchingWeight(rules, url, priority) {
-  let matched = defaultPriority(
-    preSort(rules.filter((rule) => (0, import_path_to_regexp2.pathToRegexp)(rule).test(url)))
-  );
-  const { global = [], special = {} } = priority;
-  if (global.length === 0 && (0, import_utils4.isEmptyObject)(special) || matched.length === 0)
-    return matched;
-  const [statics, dynamics] = twoPartMatch(matched);
-  const globalMatch = global.filter((rule) => dynamics.includes(rule));
-  if (globalMatch.length > 0) {
-    matched = (0, import_utils4.uniq)([...statics, ...globalMatch, ...dynamics]);
-  }
-  if ((0, import_utils4.isEmptyObject)(special))
-    return matched;
-  const specialRule = Object.keys(special).filter(
-    (rule) => matched.includes(rule)
-  )[0];
-  if (!specialRule)
-    return matched;
-  const options = special[specialRule];
-  const { rules: lowerRules, when } = (0, import_utils4.isArray)(options) ? { rules: options, when: [] } : options;
-  if (lowerRules.includes(matched[0])) {
-    if (when.length === 0 || when.some((path4) => (0, import_path_to_regexp2.pathToRegexp)(path4).test(url))) {
-      matched = (0, import_utils4.uniq)([specialRule, ...matched]);
-    }
-  }
-  return matched;
-}
-function twoPartMatch(rules) {
-  const statics = [];
-  const dynamics = [];
-  for (const rule of rules) {
-    const tokens = getTokens(rule);
-    const dym = tokens.filter((token) => typeof token !== "string");
-    if (dym.length > 0)
-      dynamics.push(rule);
-    else statics.push(rule);
-  }
-  return [statics, dynamics];
-}
+// src/core/mockCompiler.ts
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
 
-// src/parseReqBody.ts
-var import_co_body = __toESM(require("co-body"), 1);
-var import_formidable = __toESM(require("formidable"), 1);
-async function parseReqBody(req, formidableOptions, bodyParserOptions = {}) {
-  var _a;
-  const method = req.method.toUpperCase();
-  if (["GET", "DELETE", "HEAD"].includes(method))
-    return void 0;
-  const type = ((_a = req.headers["content-type"]) == null ? void 0 : _a.toLocaleLowerCase()) || "";
-  const { limit, formLimit, jsonLimit, textLimit, ...rest } = bodyParserOptions;
-  try {
-    if (type.startsWith("application/json")) {
-      return await import_co_body.default.json(req, {
-        limit: jsonLimit || limit,
-        ...rest
-      });
-    }
-    if (type.startsWith("application/x-www-form-urlencoded")) {
-      return await import_co_body.default.form(req, {
-        limit: formLimit || limit,
-        ...rest
-      });
-    }
-    if (type.startsWith("text/plain")) {
-      return await import_co_body.default.text(req, {
-        limit: textLimit || limit,
-        ...rest
-      });
-    }
-    if (type.startsWith("multipart/form-data"))
-      return await parseMultipart(req, formidableOptions);
-  } catch (e) {
-    console.error(e);
-  }
-  return void 0;
-}
-async function parseMultipart(req, options) {
-  const form = (0, import_formidable.default)(options);
-  return new Promise((resolve, reject) => {
-    form.parse(req, (error, fields, files) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve({ ...fields, ...files });
-    });
-  });
-}
-
-// src/requestRecovery.ts
-var import_node_buffer = require("buffer");
-var cache = /* @__PURE__ */ new WeakMap();
-function collectRequest(req) {
-  const chunks = [];
-  req.addListener("data", (chunk) => {
-    chunks.push(import_node_buffer.Buffer.from(chunk));
-  });
-  req.addListener("end", () => {
-    if (chunks.length)
-      cache.set(req, import_node_buffer.Buffer.concat(chunks));
-  });
-}
-function recoverRequest(config) {
-  if (!config.server)
-    return;
-  const proxies = config.server.proxy || {};
-  Object.keys(proxies).forEach((key) => {
-    const target = proxies[key];
-    const options = typeof target === "string" ? { target } : target;
-    if (options.ws)
-      return;
-    const { configure, ...rest } = options;
-    proxies[key] = {
-      ...rest,
-      configure(proxy, options2) {
-        configure == null ? void 0 : configure(proxy, options2);
-        proxy.on("proxyReq", (proxyReq, req) => {
-          const buffer = cache.get(req);
-          if (buffer) {
-            cache.delete(req);
-            if (!proxyReq.headersSent)
-              proxyReq.setHeader("Content-Length", buffer.byteLength);
-            if (!proxyReq.writableEnded)
-              proxyReq.write(buffer);
-          }
-        });
-      }
-    };
-  });
-}
-
-// src/validator.ts
-var import_utils5 = require("@pengzhanbo/utils");
-function validate(request, validator) {
-  return isObjectSubset(request.headers, validator.headers) && isObjectSubset(request.body, validator.body) && isObjectSubset(request.params, validator.params) && isObjectSubset(request.query, validator.query) && isObjectSubset(request.refererQuery, validator.refererQuery);
-}
-function isObjectSubset(source, target) {
-  if (!target)
-    return true;
-  for (const key in target) {
-    if (!isIncluded(source[key], target[key]))
-      return false;
-  }
-  return true;
-}
-function isIncluded(source, target) {
-  if ((0, import_utils5.isArray)(source) && (0, import_utils5.isArray)(target)) {
-    const seen = /* @__PURE__ */ new Set();
-    return target.every(
-      (ti) => source.some((si, i) => {
-        if (seen.has(i))
-          return false;
-        const included = isIncluded(si, ti);
-        if (included)
-          seen.add(i);
-        return included;
-      })
-    );
-  }
-  if ((0, import_utils5.isObject)(source) && (0, import_utils5.isObject)(target))
-    return isObjectSubset(source, target);
-  return Object.is(source, target);
-}
-
-// src/baseMiddleware.ts
-function baseMiddleware(mockLoader, {
-  formidableOptions = {},
-  bodyParserOptions = {},
-  proxies,
-  cookiesOptions,
-  logger,
-  priority = {}
-}) {
-  return async function(req, res, next) {
-    const startTime = (0, import_utils6.timestamp)();
-    const { query, pathname } = urlParse(req.url);
-    if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url))) {
-      return next();
-    }
-    const mockData = mockLoader.mockData;
-    const mockUrls = matchingWeight(Object.keys(mockData), pathname, priority);
-    if (mockUrls.length === 0) {
-      return next();
-    }
-    collectRequest(req);
-    const { query: refererQuery } = urlParse(req.headers.referer || "");
-    const reqBody = await parseReqBody(req, formidableOptions, bodyParserOptions);
-    const cookies = new import_cookies.default(req, res, cookiesOptions);
-    const getCookie = cookies.get.bind(cookies);
-    const method = req.method.toUpperCase();
-    let mock;
-    let _mockUrl;
-    for (const mockUrl of mockUrls) {
-      mock = fineMock(mockData[mockUrl], logger, {
-        pathname,
-        method,
-        request: {
-          query,
-          refererQuery,
-          body: reqBody,
-          headers: req.headers,
-          getCookie
-        }
-      });
-      if (mock) {
-        _mockUrl = mockUrl;
-        break;
-      }
-    }
-    if (!mock) {
-      const matched = mockUrls.map(
-        (m) => m === _mockUrl ? import_picocolors2.default.underline(import_picocolors2.default.bold(m)) : import_picocolors2.default.dim(m)
-      ).join(", ");
-      logger.warn(
-        `${import_picocolors2.default.green(
-          pathname
-        )} matches  ${matched} , but mock data is not found.`
-      );
-      return next();
-    }
-    const request = req;
-    const response = res;
-    request.body = reqBody;
-    request.query = query;
-    request.refererQuery = refererQuery;
-    request.params = parseParams(mock.url, pathname);
-    request.getCookie = getCookie;
-    response.setCookie = cookies.set.bind(cookies);
-    const {
-      body,
-      delay,
-      type = "json",
-      response: responseFn,
-      status = 200,
-      statusText,
-      log: logLevel,
-      __filepath__: filepath
-    } = mock;
-    responseStatus(response, status, statusText);
-    await provideHeaders(request, response, mock, logger);
-    await provideCookies(request, response, mock, logger);
-    logger.info(requestLog(request, filepath), logLevel);
-    logger.debug(
-      `${import_picocolors2.default.magenta("DEBUG")} ${import_picocolors2.default.underline(
-        pathname
-      )}  matches: [ ${mockUrls.map(
-        (m) => m === _mockUrl ? import_picocolors2.default.underline(import_picocolors2.default.bold(m)) : import_picocolors2.default.dim(m)
-      ).join(", ")} ]
-`
-    );
-    if (body) {
-      try {
-        const content = (0, import_utils6.isFunction)(body) ? await body(request) : body;
-        await realDelay(startTime, delay);
-        sendData(response, content, type);
-      } catch (e) {
-        logger.error(
-          `${import_picocolors2.default.red(
-            `mock error at ${pathname}`
-          )}
-${e}
-  at body (${import_picocolors2.default.underline(filepath)})`,
-          logLevel
-        );
-        responseStatus(response, 500);
-        res.end("");
-      }
-      return;
-    }
-    if (responseFn) {
-      try {
-        await realDelay(startTime, delay);
-        await responseFn(request, response, next);
-      } catch (e) {
-        logger.error(
-          `${import_picocolors2.default.red(
-            `mock error at ${pathname}`
-          )}
-${e}
-  at response (${import_picocolors2.default.underline(filepath)})`,
-          logLevel
-        );
-        responseStatus(response, 500);
-        res.end("");
-      }
-      return;
-    }
-    res.end("");
-  };
-}
-function fineMock(mockList, logger, {
-  pathname,
-  method,
-  request
-}) {
-  return mockList.find((mock) => {
-    if (!pathname || !mock || !mock.url || mock.ws === true)
-      return false;
-    const methods = mock.method ? (0, import_utils6.isArray)(mock.method) ? mock.method : [mock.method] : ["GET", "POST"];
-    if (!methods.includes(method))
-      return false;
-    const hasMock = (0, import_path_to_regexp3.pathToRegexp)(mock.url).test(pathname);
-    if (hasMock && mock.validator) {
-      const params = parseParams(mock.url, pathname);
-      if ((0, import_utils6.isFunction)(mock.validator)) {
-        return mock.validator({ params, ...request });
-      } else {
-        try {
-          return validate({ params, ...request }, mock.validator);
-        } catch (e) {
-          const file = mock.__filepath__;
-          logger.error(
-            `${import_picocolors2.default.red(
-              `mock error at ${pathname}`
-            )}
-${e}
-  at validator (${import_picocolors2.default.underline(file)})`,
-            mock.log
-          );
-          return false;
-        }
-      }
-    }
-    return hasMock;
-  });
-}
-function responseStatus(response, status = 200, statusText) {
-  response.statusCode = status;
-  response.statusMessage = statusText || getHTTPStatusText(status);
-}
-async function provideHeaders(req, res, mock, logger) {
-  const { headers, type = "json" } = mock;
-  const filepath = mock.__filepath__;
-  const contentType2 = mime.contentType(type) || mime.contentType(mime.lookup(type) || "");
-  if (contentType2)
-    res.setHeader("Content-Type", contentType2);
-  res.setHeader("Cache-Control", "no-cache,max-age=0");
-  res.setHeader("X-Mock-Power-By", "vite-plugin-mock-dev-server");
-  if (filepath)
-    res.setHeader("X-File-Path", filepath);
-  if (!headers)
-    return;
-  try {
-    const raw = (0, import_utils6.isFunction)(headers) ? await headers(req) : headers;
-    Object.keys(raw).forEach((key) => {
-      res.setHeader(key, raw[key]);
-    });
-  } catch (e) {
-    logger.error(
-      `${import_picocolors2.default.red(
-        `mock error at ${req.url.split("?")[0]}`
-      )}
-${e}
-  at headers (${import_picocolors2.default.underline(filepath)})`,
-      mock.log
-    );
-  }
-}
-async function provideCookies(req, res, mock, logger) {
-  const { cookies } = mock;
-  const filepath = mock.__filepath__;
-  if (!cookies)
-    return;
-  try {
-    const raw = (0, import_utils6.isFunction)(cookies) ? await cookies(req) : cookies;
-    Object.keys(raw).forEach((key) => {
-      const cookie = raw[key];
-      if ((0, import_utils6.isArray)(cookie)) {
-        const [value, options] = cookie;
-        res.setCookie(key, value, options);
-      } else {
-        res.setCookie(key, cookie);
-      }
-    });
-  } catch (e) {
-    logger.error(
-      `${import_picocolors2.default.red(
-        `mock error at ${req.url.split("?")[0]}`
-      )}
-${e}
-  at cookies (${import_picocolors2.default.underline(filepath)})`,
-      mock.log
-    );
-  }
-}
-function sendData(res, raw, type) {
-  if (isReadableStream(raw)) {
-    raw.pipe(res);
-  } else if (import_node_buffer2.Buffer.isBuffer(raw)) {
-    res.end(type === "text" || type === "json" ? raw.toString("utf-8") : raw);
-  } else {
-    const content = typeof raw === "string" ? raw : JSON.stringify(raw);
-    res.end(type === "buffer" ? import_node_buffer2.Buffer.from(content) : content);
-  }
-}
-async function realDelay(startTime, delay) {
-  if (!delay || typeof delay === "number" && delay <= 0 || (0, import_utils6.isArray)(delay) && delay.length !== 2) {
-    return;
-  }
-  let realDelay2 = 0;
-  if ((0, import_utils6.isArray)(delay)) {
-    const [min, max] = delay;
-    realDelay2 = (0, import_utils6.random)(min, max);
-  } else {
-    realDelay2 = delay - ((0, import_utils6.timestamp)() - startTime);
-  }
-  if (realDelay2 > 0)
-    await (0, import_utils6.sleep)(realDelay2);
-}
-function getHTTPStatusText(status) {
-  return import_http_status.default[status] || "Unknown";
-}
-function requestLog(request, filepath) {
-  const { url, method, query, params, body } = request;
-  let { pathname } = new URL(url, "http://example.com");
-  pathname = import_picocolors2.default.green(decodeURIComponent(pathname));
-  const format = (prefix, data) => {
-    return !data || (0, import_utils6.isEmptyObject)(data) ? "" : `  ${import_picocolors2.default.gray(`${prefix}:`)}${JSON.stringify(data)}`;
-  };
-  const ms = import_picocolors2.default.magenta(import_picocolors2.default.bold(method));
-  const qs = format("query", query);
-  const ps = format("params", params);
-  const bs = format("body", body);
-  const file = `  ${import_picocolors2.default.dim(import_picocolors2.default.underline(`(${filepath})`))}`;
-  return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
-}
 
-// src/logger.ts
-var import_utils8 = require("@pengzhanbo/utils");
-var import_picocolors3 = __toESM(require("picocolors"), 1);
-var logLevels = {
-  silent: 0,
-  error: 1,
-  warn: 2,
-  info: 3,
-  debug: 4
-};
-function createLogger(prefix, defaultLevel = "info") {
-  prefix = `[${prefix}]`;
-  function output(type, msg, level) {
-    level = (0, import_utils8.isBoolean)(level) ? level ? defaultLevel : "error" : level;
-    const thresh = logLevels[level];
-    if (thresh >= logLevels[type]) {
-      const method = type === "info" || type === "debug" ? "log" : type;
-      const tag = type === "debug" ? import_picocolors3.default.magenta(import_picocolors3.default.bold(prefix)) : type === "info" ? import_picocolors3.default.cyan(import_picocolors3.default.bold(prefix)) : type === "warn" ? import_picocolors3.default.yellow(import_picocolors3.default.bold(prefix)) : import_picocolors3.default.red(import_picocolors3.default.bold(prefix));
-      const format = `${import_picocolors3.default.dim(
-        (/* @__PURE__ */ new Date()).toLocaleTimeString()
-      )} ${tag} ${msg}`;
-      console[method](format);
-    }
-  }
-  const logger = {
-    debug(msg, level = defaultLevel) {
-      output("debug", msg, level);
-    },
-    info(msg, level = defaultLevel) {
-      output("info", msg, level);
-    },
-    warn(msg, level = defaultLevel) {
-      output("warn", msg, level);
-    },
-    error(msg, level = defaultLevel) {
-      output("error", msg, level);
-    }
-  };
-  return logger;
-}
+var _chokidar = require('chokidar'); var _chokidar2 = _interopRequireDefault(_chokidar);
 
-// src/MockLoader.ts
-var import_node_events = __toESM(require("events"), 1);
-var import_node_process4 = __toESM(require("process"), 1);
-var import_utils11 = require("@pengzhanbo/utils");
-var import_chokidar = __toESM(require("chokidar"), 1);
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-var import_pluginutils2 = require("@rollup/pluginutils");
 
-// src/transform.ts
-var import_utils9 = require("@pengzhanbo/utils");
-function transformMockData(mockList) {
-  const list = [];
-  for (const [, handle] of mockList.entries()) {
-    if (handle)
-      list.push(...(0, import_utils9.toArray)(handle));
-  }
-  const mocks = {};
-  list.filter((mock) => (0, import_utils9.isObject)(mock) && mock.enabled !== false && mock.url).forEach((mock) => {
-    const { pathname, query } = urlParse(mock.url);
-    const list2 = mocks[pathname] ??= [];
-    const current = { ...mock, url: pathname };
-    if (current.ws !== true) {
-      const validator = current.validator;
-      if (!(0, import_utils9.isEmptyObject)(query)) {
-        if ((0, import_utils9.isFunction)(validator)) {
-          current.validator = function(request) {
-            return isObjectSubset(request.query, query) && validator(request);
-          };
-        } else if (validator) {
-          current.validator = { ...validator };
-          current.validator.query = current.validator.query ? { ...query, ...current.validator.query } : query;
-        } else {
-          current.validator = { query };
-        }
-      }
-    }
-    list2.push(current);
-  });
-  Object.keys(mocks).forEach((key) => {
-    mocks[key] = sortByValidator(mocks[key]);
-  });
-  return mocks;
+function createMockCompiler(options) {
+  return new MockCompiler(options);
 }
-function sortByValidator(mocks) {
-  return (0, import_utils9.sortBy)(mocks, (item) => {
-    if (item.ws === true)
-      return 0;
-    const { validator } = item;
-    if (!validator || (0, import_utils9.isEmptyObject)(validator))
-      return 2;
-    if ((0, import_utils9.isFunction)(validator))
-      return 0;
-    const count = Object.keys(validator).reduce(
-      (prev, key) => prev + keysCount(validator[key]),
-      0
-    );
-    return 1 / count;
-  });
-}
-function keysCount(obj) {
-  if (!obj)
-    return 0;
-  return Object.keys(obj).length;
-}
-
-// src/MockLoader.ts
-var MockLoader = class extends import_node_events.default {
+var MockCompiler = (_class = class extends _events2.default {
   constructor(options) {
-    super();
+    super();_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);;
     this.options = options;
-    this.cwd = options.cwd || import_node_process4.default.cwd();
+    this.cwd = options.cwd || _process2.default.cwd();
     try {
-      const pkg = lookupFile(this.cwd, ["package.json"]);
+      const pkg = _chunkS76FMTCDcjs.lookupFile.call(void 0, this.cwd, ["package.json"]);
       this.moduleType = !!pkg && JSON.parse(pkg).type === "module" ? "esm" : "cjs";
-    } catch {
+    } catch (e4) {
     }
   }
-  moduleCache = /* @__PURE__ */ new Map();
-  moduleDeps = /* @__PURE__ */ new Map();
-  cwd;
-  mockWatcher;
-  depsWatcher;
-  moduleType = "cjs";
-  _mockData = {};
+  __init() {this.moduleCache = /* @__PURE__ */ new Map()}
+  __init2() {this.moduleDeps = /* @__PURE__ */ new Map()}
+  
+  
+  
+  __init3() {this.moduleType = "cjs"}
+  __init4() {this._mockData = {}}
   get mockData() {
     return this._mockData;
   }
-  load() {
+  run() {
     const { include, exclude } = this.options;
-    const includeFilter = (0, import_pluginutils2.createFilter)(include, exclude, {
-      resolve: false
-    });
-    (0, import_fast_glob2.default)(include, { cwd: this.cwd }).then(
+    const includeFilter = _pluginutils.createFilter.call(void 0, include, exclude, { resolve: false });
+    _fastglob2.default.call(void 0, include, { cwd: this.cwd }).then(
       (files) => files.filter(includeFilter).map((file) => () => this.loadMock(file))
-    ).then((loadList) => (0, import_utils11.promiseParallel)(loadList, 10)).then(() => this.updateMockList());
+    ).then((loadList) => _utils.promiseParallel.call(void 0, loadList, 10)).then(() => this.updateMockList());
     this.watchMockEntry();
     this.watchDeps();
     let timer = null;
@@ -1242,27 +411,27 @@ var MockLoader = class extends import_node_events.default {
   }
   watchMockEntry() {
     const { include } = this.options;
-    const [firstGlob, ...otherGlob] = include;
-    const watcher = this.mockWatcher = import_chokidar.default.watch(firstGlob, {
+    const [firstGlob, ...otherGlob] = _utils.toArray.call(void 0, include);
+    const watcher = this.mockWatcher = _chokidar2.default.watch(firstGlob, {
       ignoreInitial: true,
       cwd: this.cwd
     });
     if (otherGlob.length > 0)
       otherGlob.forEach((glob) => watcher.add(glob));
     watcher.on("add", async (filepath) => {
-      filepath = normalizePath(filepath);
+      filepath = _chunkS76FMTCDcjs.normalizePath.call(void 0, filepath);
       this.emit("mock:update", filepath);
-      debug("watcher:add", filepath);
+      _chunkS76FMTCDcjs.debug.call(void 0, "watcher:add", filepath);
     });
     watcher.on("change", async (filepath) => {
-      filepath = normalizePath(filepath);
+      filepath = _chunkS76FMTCDcjs.normalizePath.call(void 0, filepath);
       this.emit("mock:update", filepath);
-      debug("watcher:change", filepath);
+      _chunkS76FMTCDcjs.debug.call(void 0, "watcher:change", filepath);
     });
     watcher.on("unlink", async (filepath) => {
-      filepath = normalizePath(filepath);
+      filepath = _chunkS76FMTCDcjs.normalizePath.call(void 0, filepath);
       this.emit("mock:unlink", filepath);
-      debug("watcher:unlink", filepath);
+      _chunkS76FMTCDcjs.debug.call(void 0, "watcher:unlink", filepath);
     });
   }
   /**
@@ -1271,19 +440,19 @@ var MockLoader = class extends import_node_events.default {
    */
   watchDeps() {
     const oldDeps = [];
-    this.depsWatcher = import_chokidar.default.watch([], {
+    this.depsWatcher = _chokidar2.default.watch([], {
       ignoreInitial: true,
       cwd: this.cwd
     });
     this.depsWatcher.on("change", (filepath) => {
-      filepath = normalizePath(filepath);
+      filepath = _chunkS76FMTCDcjs.normalizePath.call(void 0, filepath);
       const mockFiles = this.moduleDeps.get(filepath);
-      mockFiles == null ? void 0 : mockFiles.forEach((file) => {
+      _optionalChain([mockFiles, 'optionalAccess', _4 => _4.forEach, 'call', _5 => _5((file) => {
         this.emit("mock:update", file);
-      });
+      })]);
     });
     this.depsWatcher.on("unlink", (filepath) => {
-      filepath = normalizePath(filepath);
+      filepath = _chunkS76FMTCDcjs.normalizePath.call(void 0, filepath);
       this.moduleDeps.delete(filepath);
     });
     this.on("update:deps", () => {
@@ -1296,12 +465,11 @@ var MockLoader = class extends import_node_events.default {
     });
   }
   close() {
-    var _a, _b;
-    (_a = this.mockWatcher) == null ? void 0 : _a.close();
-    (_b = this.depsWatcher) == null ? void 0 : _b.close();
+    _optionalChain([this, 'access', _6 => _6.mockWatcher, 'optionalAccess', _7 => _7.close, 'call', _8 => _8()]);
+    _optionalChain([this, 'access', _9 => _9.depsWatcher, 'optionalAccess', _10 => _10.close, 'call', _11 => _11()]);
   }
   updateMockList() {
-    this._mockData = transformMockData(this.moduleCache);
+    this._mockData = _chunkS76FMTCDcjs.transformMockData.call(void 0, this.moduleCache);
   }
   updateModuleDeps(filepath, deps) {
     Object.keys(deps).forEach((mPath) => {
@@ -1331,227 +499,25 @@ var MockLoader = class extends import_node_events.default {
       { isESM, define, alias, cwd: this.cwd }
     );
     try {
-      const raw = await loadFromCode({
-        filepath,
-        code,
-        isESM,
-        cwd: this.cwd
-      }) || {};
-      let mockConfig;
-      if ((0, import_utils11.hasOwn)(raw, "default")) {
-        mockConfig = raw.default;
-      } else {
-        mockConfig = [];
-        Object.keys(raw).forEach(
-          (key) => mockConfig.push(...(0, import_utils11.toArray)(raw[key]))
-        );
-      }
-      if ((0, import_utils11.isArray)(mockConfig)) {
-        mockConfig.forEach((mock) => mock.__filepath__ = filepath);
-      } else {
-        ;
-        mockConfig.__filepath__ = filepath;
-      }
-      this.moduleCache.set(filepath, mockConfig);
+      const raw = await loadFromCode({ filepath, code, isESM, cwd: this.cwd }) || {};
+      this.moduleCache.set(filepath, _chunkS76FMTCDcjs.transformRawData.call(void 0, raw, filepath));
       this.updateModuleDeps(filepath, deps);
     } catch (e) {
       console.error(e);
     }
   }
-};
-
-// src/ws.ts
-var import_cookies2 = __toESM(require("cookies"), 1);
-var import_path_to_regexp4 = require("path-to-regexp");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
-var import_ws = require("ws");
-function mockWebSocket({
-  loader,
-  httpServer,
-  proxies,
-  cookiesOptions,
-  logger
-}) {
-  var _a;
-  const hmrMap = /* @__PURE__ */ new Map();
-  const poolMap = /* @__PURE__ */ new Map();
-  const wssContextMap = /* @__PURE__ */ new WeakMap();
-  const getWssMap = (mockUrl) => {
-    let wssMap = poolMap.get(mockUrl);
-    if (!wssMap)
-      poolMap.set(mockUrl, wssMap = /* @__PURE__ */ new Map());
-    return wssMap;
-  };
-  const getWss = (wssMap, pathname) => {
-    let wss = wssMap.get(pathname);
-    if (!wss)
-      wssMap.set(pathname, wss = new import_ws.WebSocketServer({ noServer: true }));
-    return wss;
-  };
-  const addHmr = (filepath, mockUrl) => {
-    let urlList = hmrMap.get(filepath);
-    if (!urlList)
-      hmrMap.set(filepath, urlList = /* @__PURE__ */ new Set());
-    urlList.add(mockUrl);
-  };
-  const setupWss = (wssMap, wss, mock, context, pathname, filepath) => {
-    var _a2;
-    try {
-      (_a2 = mock.setup) == null ? void 0 : _a2.call(mock, wss, context);
-      wss.on("close", () => wssMap.delete(pathname));
-      wss.on("error", (e) => {
-        logger.error(
-          `${import_picocolors4.default.red(
-            `WebSocket mock error at ${wss.path}`
-          )}
-${e}
-  at setup (${filepath})`,
-          mock.log
-        );
-      });
-    } catch (e) {
-      logger.error(
-        `${import_picocolors4.default.red(
-          `WebSocket mock error at ${wss.path}`
-        )}
-${e}
-  at setup (${filepath})`,
-        mock.log
-      );
-    }
-  };
-  const emitConnection = (wss, ws, req, connectionList) => {
-    wss.emit("connection", ws, req);
-    ws.on("close", () => {
-      const i = connectionList.findIndex((item) => item.ws === ws);
-      if (i !== -1)
-        connectionList.splice(i, 1);
-    });
-  };
-  const restartWss = (wssMap, wss, mock, pathname, filepath) => {
-    const { cleanupList, connectionList, context } = wssContextMap.get(wss);
-    cleanupRunner(cleanupList);
-    connectionList.forEach(({ ws }) => ws.removeAllListeners());
-    wss.removeAllListeners();
-    setupWss(wssMap, wss, mock, context, pathname, filepath);
-    connectionList.forEach(
-      ({ ws, req }) => emitConnection(wss, ws, req, connectionList)
-    );
-  };
-  (_a = loader.on) == null ? void 0 : _a.call(loader, "mock:update-end", (filepath) => {
-    if (!hmrMap.has(filepath))
-      return;
-    const mockUrlList = hmrMap.get(filepath);
-    if (!mockUrlList)
-      return;
-    for (const mockUrl of mockUrlList.values()) {
-      for (const mock of loader.mockData[mockUrl]) {
-        if (!mock.ws || mock.__filepath__ !== filepath)
-          return;
-        const wssMap = getWssMap(mockUrl);
-        for (const [pathname, wss] of wssMap.entries())
-          restartWss(wssMap, wss, mock, pathname, filepath);
-      }
-    }
-  });
-  httpServer == null ? void 0 : httpServer.on("upgrade", (req, socket, head) => {
-    const { pathname, query } = urlParse(req.url);
-    if (!pathname || proxies.length === 0 || !proxies.some((context) => doesProxyContextMatchUrl(context, req.url))) {
-      return;
-    }
-    const mockData = loader.mockData;
-    const mockUrl = Object.keys(mockData).find((key) => {
-      return (0, import_path_to_regexp4.pathToRegexp)(key).test(pathname);
-    });
-    if (!mockUrl)
-      return;
-    const mock = mockData[mockUrl].find((mock2) => {
-      return mock2.url && mock2.ws && (0, import_path_to_regexp4.pathToRegexp)(mock2.url).test(pathname);
-    });
-    if (!mock)
-      return;
-    const filepath = mock.__filepath__;
-    addHmr(filepath, mockUrl);
-    const wssMap = getWssMap(mockUrl);
-    const wss = getWss(wssMap, pathname);
-    let wssContext = wssContextMap.get(wss);
-    if (!wssContext) {
-      const cleanupList = [];
-      const context = {
-        onCleanup: (cleanup) => cleanupList.push(cleanup)
-      };
-      wssContext = { cleanupList, context, connectionList: [] };
-      wssContextMap.set(wss, wssContext);
-      setupWss(wssMap, wss, mock, context, pathname, filepath);
-    }
-    const request = req;
-    const cookies = new import_cookies2.default(req, req, cookiesOptions);
-    const { query: refererQuery } = urlParse(req.headers.referer || "");
-    request.query = query;
-    request.refererQuery = refererQuery;
-    request.params = parseParams(mockUrl, pathname);
-    request.getCookie = cookies.get.bind(cookies);
-    wss.handleUpgrade(request, socket, head, (ws) => {
-      logger.info(
-        `${import_picocolors4.default.magenta(import_picocolors4.default.bold("WebSocket"))} ${import_picocolors4.default.green(
-          req.url
-        )} connected ${import_picocolors4.default.dim(`(${filepath})`)}`,
-        mock.log
-      );
-      wssContext.connectionList.push({ req: request, ws });
-      emitConnection(wss, ws, request, wssContext.connectionList);
-    });
-  });
-  httpServer == null ? void 0 : httpServer.on("close", () => {
-    for (const wssMap of poolMap.values()) {
-      for (const wss of wssMap.values()) {
-        const wssContext = wssContextMap.get(wss);
-        cleanupRunner(wssContext.cleanupList);
-        wss.close();
-      }
-      wssMap.clear();
-    }
-    poolMap.clear();
-    hmrMap.clear();
-  });
-}
-function cleanupRunner(cleanupList) {
-  let cleanup;
-  while (cleanup = cleanupList.shift())
-    cleanup == null ? void 0 : cleanup();
-}
+}, _class);
 
-// src/mockMiddleware.ts
-function mockServerMiddleware(config, options, httpServer, ws) {
-  const logger = createLogger(
-    "vite:mock",
-    (0, import_utils14.isBoolean)(options.log) ? options.log ? "info" : "error" : options.log
-  );
-  const loader = new MockLoader({
-    cwd: options.cwd,
-    include: (0, import_utils14.toArray)(options.include),
-    exclude: (0, import_utils14.toArray)(options.exclude),
-    define: viteDefine(config),
-    alias: config.resolve.alias
-  });
-  loader.load();
-  loader.on("mock:update-end", () => {
+// src/core/mockMiddleware.ts
+function mockServerMiddleware(options, server, ws) {
+  const compiler = createMockCompiler(options);
+  compiler.run();
+  compiler.on("mock:update-end", () => {
     if (options.reload)
-      ws == null ? void 0 : ws.send({ type: "full-reload" });
-  });
-  httpServer == null ? void 0 : httpServer.on("close", () => loader.close());
-  const { httpProxies } = ensureProxies(config.server.proxy || {});
-  const prefix = (0, import_utils14.toArray)(options.prefix);
-  const proxies = (0, import_utils14.uniq)([...prefix, ...httpProxies]);
-  if (!proxies.length && !(0, import_utils14.toArray)(options.wsPrefix).length)
-    logger.warn(`No proxy was configured, mock server will not work. See ${import_picocolors5.default.cyan("https://vite-plugin-mock-dev-server.netlify.app/guide/usage")}`);
-  mockWebSocket({
-    loader,
-    httpServer,
-    proxies: (0, import_utils14.toArray)(options.wsPrefix),
-    cookiesOptions: options.cookiesOptions,
-    logger
+      _optionalChain([ws, 'optionalAccess', _12 => _12.send, 'call', _13 => _13({ type: "full-reload" })]);
   });
+  _optionalChain([server, 'optionalAccess', _14 => _14.on, 'call', _15 => _15("close", () => compiler.close())]);
+  _chunkS76FMTCDcjs.mockWebSocket.call(void 0, compiler, server, options);
   const middlewares = [];
   middlewares.push(
     /**
@@ -1565,55 +531,116 @@ function mockServerMiddleware(config, options, httpServer, ws) {
      * 也会使用 viteConfig.server.cors 配置，并支持 用户可以对 mock 中的 cors 中间件进行配置。
      * 而用户的配置也仅对 mock 的接口生效。
      */
-    corsMiddleware(loader, proxies, config, options),
-    baseMiddleware(loader, {
-      formidableOptions: options.formidableOptions,
-      proxies,
-      cookiesOptions: options.cookiesOptions,
-      bodyParserOptions: options.bodyParserOptions,
-      priority: options.priority,
-      logger
-    })
+    corsMiddleware(compiler, options),
+    _chunkS76FMTCDcjs.baseMiddleware.call(void 0, compiler, options)
   );
   return middlewares.filter(Boolean);
 }
-function corsMiddleware(mockLoader, proxies, config, options) {
-  let corsOptions = {};
-  const enabled = options.cors === false ? false : config.server.cors !== false;
-  if (enabled && config.server.cors !== false) {
-    corsOptions = {
-      ...corsOptions,
-      ...typeof config.server.cors === "boolean" ? {} : config.server.cors
-    };
-  }
-  if (enabled && options.cors !== false) {
-    corsOptions = {
-      ...corsOptions,
-      ...typeof options.cors === "boolean" ? {} : options.cors
-    };
-  }
-  return !enabled ? void 0 : function(req, res, next) {
-    const { pathname } = urlParse(req.url);
-    if (!pathname || proxies.length === 0 || !proxies.some(
-      (context) => doesProxyContextMatchUrl(context, req.url)
-    )) {
+function corsMiddleware(compiler, { proxies, cors: corsOptions }) {
+  return !corsOptions ? void 0 : function(req, res, next) {
+    const { pathname } = _chunkS76FMTCDcjs.urlParse.call(void 0, req.url);
+    if (!pathname || proxies.length === 0 || !proxies.some((context) => _chunkS76FMTCDcjs.doesProxyContextMatchUrl.call(void 0, context, req.url))) {
       return next();
     }
-    const mockData = mockLoader.mockData;
+    const mockData = compiler.mockData;
     const mockUrl = Object.keys(mockData).find(
-      (key) => (0, import_path_to_regexp5.pathToRegexp)(key).test(pathname)
+      (key) => _pathtoregexp.pathToRegexp.call(void 0, key).test(pathname)
     );
     if (!mockUrl)
       return next();
-    (0, import_cors.default)(corsOptions)(req, res, next);
+    _cors2.default.call(void 0, corsOptions)(req, res, next);
   };
 }
 
-// src/plugin.ts
-function mockDevServerPlugin({
+// src/core/resolvePluginOptions.ts
+
+
+
+
+// src/core/define.ts
+
+function viteDefine(config) {
+  const processNodeEnv = {};
+  const nodeEnv = _process2.default.env.NODE_ENV || config.mode;
+  Object.assign(processNodeEnv, {
+    "process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+    "globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
+  });
+  const userDefine = {};
+  const userDefineEnv = {};
+  for (const key in config.define) {
+    const val = config.define[key];
+    const isMetaEnv = key.startsWith("import.meta.env.");
+    if (typeof val === "string") {
+      if (canJsonParse(val)) {
+        userDefine[key] = val;
+        if (isMetaEnv)
+          userDefineEnv[key.slice(16)] = val;
+      }
+    } else {
+      userDefine[key] = handleDefineValue(val);
+      if (isMetaEnv)
+        userDefineEnv[key.slice(16)] = val;
+    }
+  }
+  const importMetaKeys = {};
+  const importMetaEnvKeys = {};
+  const importMetaFallbackKeys = {};
+  importMetaKeys["import.meta.hot"] = `undefined`;
+  for (const key in config.env) {
+    const val = JSON.stringify(config.env[key]);
+    importMetaKeys[`import.meta.env.${key}`] = val;
+    importMetaEnvKeys[key] = val;
+  }
+  importMetaFallbackKeys["import.meta.env"] = `undefined`;
+  const define = {
+    ...processNodeEnv,
+    ...importMetaKeys,
+    ...userDefine,
+    ...importMetaFallbackKeys
+  };
+  if ("import.meta.env" in define) {
+    define["import.meta.env"] = serializeDefine({
+      ...importMetaEnvKeys,
+      ...userDefineEnv
+    });
+  }
+  return define;
+}
+function serializeDefine(define) {
+  let res = `{`;
+  const keys = Object.keys(define);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const val = define[key];
+    res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`;
+    if (i !== keys.length - 1)
+      res += `, `;
+  }
+  return `${res}}`;
+}
+function handleDefineValue(value) {
+  if (typeof value === "undefined")
+    return "undefined";
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value);
+}
+function canJsonParse(value) {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch (e5) {
+    return false;
+  }
+}
+
+// src/core/resolvePluginOptions.ts
+function resolvePluginOptions({
   prefix = [],
   wsPrefix = [],
-  cwd = import_node_process5.default.cwd(),
+  cwd,
   include = ["mock/**/*.mock.{js,ts,cjs,mjs,json,json5}"],
   exclude = ["**/node_modules/**", "**/.vscode/**", "**/.git/**"],
   reload = false,
@@ -1624,15 +651,43 @@ function mockDevServerPlugin({
   cookiesOptions = {},
   bodyParserOptions = {},
   priority = {}
-} = {}) {
-  const pluginOptions = {
-    prefix,
-    wsPrefix,
-    cwd,
+}, config) {
+  const logger = _chunkS76FMTCDcjs.createLogger.call(void 0, "vite:mock", _utils.isBoolean.call(void 0, log) ? log ? "info" : "error" : log);
+  const { httpProxies } = _chunkS76FMTCDcjs.ensureProxies.call(void 0, config.server.proxy || {});
+  const proxies = _utils.uniq.call(void 0, [..._utils.toArray.call(void 0, prefix), ...httpProxies]);
+  const wsProxies = _utils.toArray.call(void 0, wsPrefix);
+  if (!proxies.length && !wsProxies.length)
+    logger.warn(`No proxy was configured, mock server will not work. See ${_picocolors2.default.cyan("https://vite-plugin-mock-dev-server.netlify.app/guide/usage")}`);
+  const enabled = cors2 === false ? false : config.server.cors !== false;
+  let corsOptions = {};
+  if (enabled && config.server.cors !== false) {
+    corsOptions = {
+      ...corsOptions,
+      ...typeof config.server.cors === "boolean" ? {} : config.server.cors
+    };
+  }
+  if (enabled && cors2 !== false) {
+    corsOptions = {
+      ...corsOptions,
+      ...typeof cors2 === "boolean" ? {} : cors2
+    };
+  }
+  const alias = [];
+  const aliasConfig = config.resolve.alias || [];
+  if (_utils.isArray.call(void 0, aliasConfig)) {
+    alias.push(...aliasConfig);
+  } else {
+    Object.entries(aliasConfig).forEach(([find, replacement]) => {
+      alias.push({ find, replacement });
+    });
+  }
+  return {
+    cwd: cwd || _process2.default.cwd(),
     include,
     exclude,
+    context: config.root,
     reload,
-    cors: cors2,
+    cors: enabled ? corsOptions : false,
     cookiesOptions,
     log,
     formidableOptions: {
@@ -1648,42 +703,50 @@ function mockDevServerPlugin({
         log: "error"
       },
       typeof build2 === "object" ? build2 : {}
-    ) : false
+    ) : false,
+    proxies,
+    wsProxies,
+    logger,
+    alias,
+    define: viteDefine(config)
   };
-  const plugins = [serverPlugin(pluginOptions)];
-  if (pluginOptions.build)
-    plugins.push(buildPlugin(pluginOptions));
+}
+
+// src/plugin.ts
+function mockDevServerPlugin(options = {}) {
+  const plugins = [serverPlugin(options)];
+  if (options.build)
+    plugins.push(buildPlugin(options));
   return plugins;
 }
-function buildPlugin(pluginOptions) {
+function buildPlugin(options) {
   let viteConfig = {};
+  let resolvedOptions;
   return {
     name: "vite-plugin-mock-dev-server-generator",
     enforce: "post",
     apply: "build",
     configResolved(config) {
       viteConfig = config;
+      resolvedOptions = resolvePluginOptions(options, config);
       config.logger.warn("");
     },
     async buildEnd(error) {
-      if (error)
+      if (error || viteConfig.command !== "build")
         return;
-      if (viteConfig.command !== "build")
-        return;
-      await generateMockServer(this, viteConfig, pluginOptions);
+      await generateMockServer(this, resolvedOptions);
     }
   };
 }
-function serverPlugin(pluginOptions) {
-  let viteConfig = {};
+function serverPlugin(options) {
+  let resolvedOptions;
   return {
     name: "vite-plugin-mock-dev-server",
     enforce: "pre",
     apply: "serve",
     config(config) {
-      var _a;
-      const wsPrefix = (0, import_utils16.toArray)(pluginOptions.wsPrefix);
-      if (wsPrefix.length && ((_a = config.server) == null ? void 0 : _a.proxy)) {
+      const wsPrefix = _utils.toArray.call(void 0, options.wsPrefix);
+      if (wsPrefix.length && _optionalChain([config, 'access', _16 => _16.server, 'optionalAccess', _17 => _17.proxy])) {
         const proxy = {};
         Object.keys(config.server.proxy).forEach((key) => {
           if (!wsPrefix.includes(key))
@@ -1691,124 +754,36 @@ function serverPlugin(pluginOptions) {
         });
         config.server.proxy = proxy;
       }
-      recoverRequest(config);
+      _chunkS76FMTCDcjs.recoverRequest.call(void 0, config);
     },
     configResolved(config) {
-      viteConfig = config;
+      resolvedOptions = resolvePluginOptions(options, config);
       config.logger.warn("");
     },
-    configureServer({ middlewares, config, httpServer, ws }) {
-      const middlewareList = mockServerMiddleware(
-        config,
-        pluginOptions,
-        httpServer,
-        ws
-      );
+    configureServer({ middlewares, httpServer, ws }) {
+      const middlewareList = mockServerMiddleware(resolvedOptions, httpServer, ws);
       middlewareList.forEach((middleware) => middlewares.use(middleware));
     },
     configurePreviewServer({ middlewares, httpServer }) {
-      const middlewareList = mockServerMiddleware(
-        viteConfig,
-        pluginOptions,
-        httpServer
-      );
+      const middlewareList = mockServerMiddleware(resolvedOptions, httpServer);
       middlewareList.forEach((middleware) => middlewares.use(middleware));
     }
   };
 }
 
-// src/defineMock.ts
-var import_utils17 = require("@pengzhanbo/utils");
-function defineMock(config) {
-  return config;
-}
-function createDefineMock(transformer) {
-  const define = (config) => {
-    if ((0, import_utils17.isArray)(config))
-      config = config.map((item) => transformer(item) || item);
-    else
-      config = transformer(config) || config;
-    return config;
-  };
-  return define;
-}
-
-// src/defineMockData.ts
-var import_utils18 = require("@pengzhanbo/utils");
-var mockDataCache = /* @__PURE__ */ new Map();
-var responseCache = /* @__PURE__ */ new WeakMap();
-var staleInterval = 70;
-var CacheImpl = class {
-  value;
-  // 初始化数据的备份，用于 判断 传入的初始化数据是否发生变更
-  #initialValue;
-  #lastUpdate;
-  constructor(value) {
-    this.value = value;
-    this.#initialValue = (0, import_utils18.deepClone)(value);
-    this.#lastUpdate = Date.now();
-  }
-  hotUpdate(value) {
-    if (Date.now() - this.#lastUpdate < staleInterval)
-      return;
-    if (!(0, import_utils18.deepEqual)(value, this.#initialValue)) {
-      this.value = value;
-      this.#initialValue = (0, import_utils18.deepClone)(value);
-      this.#lastUpdate = Date.now();
-    }
-  }
-};
-function defineMockData(key, initialData) {
-  if (!mockDataCache.has(key))
-    mockDataCache.set(key, new CacheImpl(initialData));
-  const cache2 = mockDataCache.get(key);
-  cache2.hotUpdate(initialData);
-  if (responseCache.has(cache2))
-    return responseCache.get(cache2);
-  const res = [
-    () => cache2.value,
-    (val) => {
-      if ((0, import_utils18.isFunction)(val))
-        val = val(cache2.value) ?? cache2.value;
-      cache2.value = val;
-    }
-  ];
-  Object.defineProperty(res, "value", {
-    get() {
-      return cache2.value;
-    },
-    set(val) {
-      cache2.value = val;
-    }
-  });
-  responseCache.set(cache2, res);
-  return res;
-}
-
 // src/index.ts
 var src_default = mockDevServerPlugin;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  baseMiddleware,
-  createDefineMock,
-  createLogger,
-  defineMock,
-  defineMockData,
-  logLevels,
-  mockDevServerPlugin,
-  mockWebSocket,
-  sortByValidator,
-  transformMockData
-});
 
-warnCjsUsage()
-function warnCjsUsage() {
-  if (process.env.VITE_CJS_IGNORE_WARNING) return
-  const yellow = (str) => `\u001b[33m${str}\u001b[39m`
-  const log = process.env.VITE_CJS_TRACE ? console.trace : console.warn
-  log(
-    yellow(
-      `The CJS build of vite-plugin-mock-dev-server's Node API is deprecated. See https://vitejs.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.`,
-    ),
-  )
-}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.baseMiddleware = _chunkS76FMTCDcjs.baseMiddleware; exports.createDefineMock = _chunkFND5XIG2cjs.createDefineMock; exports.createLogger = _chunkS76FMTCDcjs.createLogger; exports.default = src_default; exports.defineMock = _chunkFND5XIG2cjs.defineMock; exports.defineMockData = _chunkFND5XIG2cjs.defineMockData; exports.logLevels = _chunkS76FMTCDcjs.logLevels; exports.mockDevServerPlugin = mockDevServerPlugin; exports.mockWebSocket = _chunkS76FMTCDcjs.mockWebSocket; exports.sortByValidator = _chunkS76FMTCDcjs.sortByValidator; exports.transformMockData = _chunkS76FMTCDcjs.transformMockData; exports.transformRawData = _chunkS76FMTCDcjs.transformRawData;