rspack-plugin-mock 1.3.0 → 2.0.0

package/dist/ws-BcLCWVaK.js

@@ -0,0 +1,1003 @@
+import { attemptAsync, isArray, isBoolean, isEmptyObject, isFunction, isPlainObject, isString, objectKeys, partition, random, sleep, sortBy, timestamp, toArray, uniq } from "@pengzhanbo/utils";
+import path from "node:path";
+import ansis from "ansis";
+import picomatch from "picomatch";
+import { loadPackageJSONSync } from "local-pkg";
+import { match, parse, pathToRegexp } from "path-to-regexp";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import Debug from "debug";
+import { Volume, createFsFromVolume } from "memfs";
+import { parse as parse$1 } from "node:querystring";
+import crypto from "node:crypto";
+import cors from "cors";
+import bodyParser from "co-body";
+import formidable from "formidable";
+import http from "node:http";
+import { Buffer } from "node:buffer";
+import HTTP_STATUS from "http-status";
+import * as mime from "mime-types";
+import { WebSocketServer } from "ws";
+//#region src/utils/createMatcher.ts
+function createMatcher(include, exclude, defaultIgnore = true) {
+	const pattern = [];
+	const ignore = [...defaultIgnore ? ["**/node_modules/**"] : [], ...toArray(exclude)];
+	toArray(include).forEach((item) => {
+		if (item[0] === "!") ignore.push(item.slice(1));
+		else pattern.push(item);
+	});
+	return {
+		pattern,
+		ignore,
+		isMatch: picomatch(pattern, { ignore })
+	};
+}
+//#endregion
+//#region src/utils/doesProxyContextMatchUrl.ts
+const PATTERN_CACHE = /* @__PURE__ */ new Map();
+function doesProxyContextMatchUrl(context, req) {
+	const url = req.url;
+	if (typeof context === "function") return context(url, req);
+	if (context[0] === "^") {
+		let pattern = PATTERN_CACHE.get(context);
+		if (!pattern) PATTERN_CACHE.set(context, pattern = new RegExp(context));
+		return pattern.test(url);
+	}
+	return url.startsWith(context);
+}
+//#endregion
+//#region src/utils/getDeps.ts
+function getPackageDeps(cwd) {
+	const { dependencies, devDependencies, peerDependencies, optionalDependencies } = loadPackageJSONSync(cwd) || {};
+	return {
+		...dependencies,
+		...devDependencies,
+		...peerDependencies,
+		...optionalDependencies
+	};
+}
+function getPackageDepList(cwd) {
+	return uniq(objectKeys(getPackageDeps(cwd)));
+}
+//#endregion
+//#region src/utils/is.ts
+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";
+}
+//#endregion
+//#region src/utils/isObjectSubset.ts
+/**
+* Checks if target object is a subset of source object.
+* That is, all properties and their corresponding values in target exist in source.
+*
+* 深度比较两个对象之间，target 是否属于 source 的子集，
+* 即 target 的所有属性和对应的值，都在 source 中，
+*/
+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 (isArray(source) && 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 (isPlainObject(source) && isPlainObject(target)) return isObjectSubset(source, target);
+	return Object.is(source, target);
+}
+//#endregion
+//#region src/utils/isPathMatch.ts
+const cache = /* @__PURE__ */ new Map();
+/**
+* 判断 path 是否匹配 pattern
+*/
+function isPathMatch(pattern, path) {
+	let regexp = cache.get(pattern);
+	if (!regexp) {
+		regexp = pathToRegexp(pattern).regexp;
+		cache.set(pattern, regexp);
+	}
+	return regexp.test(path);
+}
+//#endregion
+//#region src/utils/logger.ts
+const logLevels = {
+	silent: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4
+};
+function createLogger(prefix, defaultLevel = "info") {
+	prefix = `[${prefix}]`;
+	function output(type, msg, level) {
+		level = isBoolean(level) ? level ? defaultLevel : "error" : level;
+		if (logLevels[level] >= logLevels[type]) {
+			const method = type === "info" || type === "debug" ? "log" : type;
+			const tag = type === "debug" ? ansis.magenta.bold(prefix) : type === "info" ? ansis.cyan.bold(prefix) : type === "warn" ? ansis.yellow.bold(prefix) : ansis.red.bold(prefix);
+			const format = `${ansis.dim((/* @__PURE__ */ new Date()).toLocaleTimeString())} ${tag} ${msg}`;
+			console[method](format);
+		}
+	}
+	return {
+		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);
+		}
+	};
+}
+getDirname(import.meta.url);
+const vfs = createFsFromVolume(new Volume());
+function getDirname(importMetaUrl) {
+	return path.dirname(fileURLToPath(importMetaUrl));
+}
+Debug("vite:mock-dev-server");
+const windowsSlashRE = /\\/g;
+const isWindows = os.platform() === "win32";
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+	return path.posix.normalize(isWindows ? slash(id) : id);
+}
+//#endregion
+//#region src/utils/urlParse.ts
+/**
+* nodejs 从 19.0.0 开始 弃用 url.parse，因此使用 url.parse 来解析 可能会报错，
+* 使用 URL 来解析
+*/
+function urlParse(input) {
+	const url = new URL(input, "http://example.com");
+	return {
+		pathname: decodeURIComponent(url.pathname),
+		query: parse$1(url.search.replace(/^\?/, ""))
+	};
+}
+//#endregion
+//#region src/utils/waitingFor.ts
+function waitingFor(onSuccess, maxRetry = 5) {
+	return function wait(getter, retry = 0) {
+		const value = getter();
+		if (value) onSuccess(value);
+		else if (retry < maxRetry) setTimeout(() => wait(getter, retry + 1), 100);
+	};
+}
+//#endregion
+//#region src/compiler/processData.ts
+function processRawData(rawData) {
+	return rawData.filter((item) => item[0]).map(([raw, __filepath__]) => {
+		let mockConfig;
+		if (raw.default) if (isArray(raw.default)) mockConfig = raw.default.map((item) => ({
+			...item,
+			__filepath__
+		}));
+		else mockConfig = {
+			...raw.default,
+			__filepath__
+		};
+		else if ("url" in raw) mockConfig = {
+			...raw,
+			__filepath__
+		};
+		else {
+			mockConfig = [];
+			objectKeys(raw || {}).forEach((key) => {
+				const data = raw[key];
+				if (isArray(data)) mockConfig.push(...data.map((item) => ({
+					...item,
+					__filepath__
+				})));
+				else mockConfig.push({
+					...data,
+					__filepath__
+				});
+			});
+		}
+		return mockConfig;
+	});
+}
+function processMockData(mockList) {
+	const list = [];
+	for (const [, handle] of mockList.entries()) if (handle) list.push(...toArray(handle));
+	const mocks = {};
+	list.filter((mock) => isPlainObject(mock) && mock.enabled !== false && mock.url).forEach((mock) => {
+		const { pathname, query } = urlParse(mock.url);
+		const list = mocks[pathname] ??= [];
+		const current = {
+			...mock,
+			url: pathname
+		};
+		if (current.ws !== true) {
+			const validator = current.validator;
+			if (!isEmptyObject(query)) if (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 };
+		}
+		list.push(current);
+	});
+	objectKeys(mocks).forEach((key) => {
+		mocks[key] = sortByValidator(mocks[key]);
+	});
+	return mocks;
+}
+function sortByValidator(mocks) {
+	return sortBy(mocks, (item) => {
+		if (item.ws === true) return 0;
+		const { validator } = item;
+		if (!validator || isEmptyObject(validator)) return 2;
+		if (isFunction(validator)) return 0;
+		return 1 / Object.keys(validator).reduce((prev, key) => prev + keysCount(validator[key]), 0);
+	});
+}
+function keysCount(obj) {
+	if (!obj) return 0;
+	return objectKeys(obj).length;
+}
+//#endregion
+//#region src/core/cors.ts
+/**
+* Create CORS middleware
+*
+* 创建 CORS 中间件
+*
+* @param corsOptions - CORS options / CORS 配置项
+* @returns CORS middleware function or undefined / CORS 中间件函数或未定义
+*/
+function createCors(corsOptions) {
+	const corsMiddleware = corsOptions ? cors(corsOptions) : void 0;
+	return corsMiddleware ? (req, res) => new Promise((resolve, reject) => corsMiddleware(req, res, (err) => {
+		err ? reject(err) : resolve();
+	})) : void 0;
+}
+//#endregion
+//#region src/core/request.ts
+/**
+* 解析请求体 request.body
+*/
+async function parseRequestBody(req, formidableOptions, bodyParserOptions = {}) {
+	const method = req.method.toUpperCase();
+	if (["HEAD", "OPTIONS"].includes(method)) return void 0;
+	const type = req.headers["content-type"]?.toLocaleLowerCase() || "";
+	const { limit, formLimit, jsonLimit, textLimit, ...rest } = bodyParserOptions;
+	try {
+		if (type.startsWith("application/json")) return await bodyParser.json(req, {
+			limit: jsonLimit || limit,
+			...rest
+		});
+		if (type.startsWith("application/x-www-form-urlencoded")) return await bodyParser.form(req, {
+			limit: formLimit || limit,
+			...rest
+		});
+		if (type.startsWith("text/plain")) return await bodyParser.text(req, {
+			limit: textLimit || limit,
+			...rest
+		});
+		if (type.startsWith("multipart/form-data")) return await parseRequestBodyWithMultipart(req, formidableOptions);
+	} catch (e) {
+		console.error(e);
+	}
+}
+const DEFAULT_FORMIDABLE_OPTIONS = {
+	keepExtensions: true,
+	filename(name, ext, part) {
+		return part?.originalFilename || `${name}.${Date.now()}${ext ? `.${ext}` : ""}`;
+	}
+};
+/**
+* 解析 request form multipart body
+*/
+async function parseRequestBodyWithMultipart(req, options) {
+	const form = formidable({
+		...DEFAULT_FORMIDABLE_OPTIONS,
+		...options
+	});
+	return new Promise((resolve, reject) => {
+		form.parse(req, (error, fields, files) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve({
+				...fields,
+				...files
+			});
+		});
+	});
+}
+const matcherCache = /* @__PURE__ */ new Map();
+/**
+* 解析请求 url 中的动态参数 params
+*/
+function parseRequestParams(pattern, url) {
+	let matcher = matcherCache.get(pattern);
+	if (!matcher) {
+		matcher = match(pattern, { decode: decodeURIComponent });
+		matcherCache.set(pattern, matcher);
+	}
+	const matched = matcher(url);
+	return matched ? matched.params : {};
+}
+/**
+* 验证请求是否符合 validator
+*/
+function requestValidate(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 formatLog(prefix, data) {
+	return !data || isEmptyObject(data) ? "" : `  ${ansis.gray(`${prefix}:`)}${JSON.stringify(data)}`;
+}
+function requestLog(request, filepath) {
+	const { url, method, query, params, body } = request;
+	let { pathname } = new URL(url, "http://example.com");
+	pathname = ansis.green(decodeURIComponent(pathname));
+	const ms = ansis.magenta.bold(method);
+	const qs = formatLog("query", query);
+	const ps = formatLog("params", params);
+	const bs = formatLog("body", body);
+	const file = `  ${ansis.dim.underline(`(${filepath})`)}`;
+	return `${ms} ${pathname}${qs}${ps}${bs}${file}`;
+}
+//#endregion
+//#region src/core/findMockData.ts
+/**
+* 查找匹配的 mock data
+*/
+function findMockData(mockList, logger, { pathname, method, request }) {
+	return mockList.find((mock) => {
+		if (!pathname || !mock || !mock.url || mock.ws) return false;
+		if (!(mock.method ? isArray(mock.method) ? mock.method : [mock.method] : ["GET", "POST"]).includes(method)) return false;
+		const hasMock = isPathMatch(mock.url, pathname);
+		if (hasMock && mock.validator) {
+			const params = parseRequestParams(mock.url, pathname);
+			if (isFunction(mock.validator)) return mock.validator({
+				params,
+				...request
+			});
+			else try {
+				return requestValidate({
+					params,
+					...request
+				}, mock.validator);
+			} catch (e) {
+				const file = mock.__filepath__;
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at validator (${ansis.underline(file)})`, mock.log);
+				return false;
+			}
+		}
+		return hasMock;
+	});
+}
+//#endregion
+//#region src/cookies/constants.ts
+/**
+* RegExp to match field-content in RFC 7230 sec 3.2
+*
+* field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+* field-vchar   = VCHAR / obs-text
+* obs-text      = %x80-FF
+*/
+const fieldContentRegExp = /^[\t\u0020-\u007E\u0080-\u00FF]+$/;
+/**
+* RegExp to match Priority cookie attribute value.
+*/
+const PRIORITY_REGEXP = /^(?:low|medium|high)$/i;
+/**
+* Cache for generated name regular expressions.
+*/
+const REGEXP_CACHE = Object.create(null);
+/**
+* RegExp to match all characters to escape in a RegExp.
+*/
+const REGEXP_ESCAPE_CHARS_REGEXP = /[\^$\\.*+?()[\]{}|]/g;
+/**
+* RegExp to match basic restricted name characters for loose validation.
+*/
+const RESTRICTED_NAME_CHARS_REGEXP = /[;=]/;
+/**
+* RegExp to match basic restricted value characters for loose validation.
+*/
+const RESTRICTED_VALUE_CHARS_REGEXP = /;/;
+/**
+* RegExp to match Same-Site cookie attribute value.
+*/
+const SAME_SITE_REGEXP = /^(?:lax|none|strict)$/i;
+//#endregion
+//#region src/cookies/Cookie.ts
+var Cookie = class {
+	name;
+	value;
+	maxAge;
+	expires;
+	path = "/";
+	domain;
+	secure = false;
+	httpOnly = true;
+	sameSite = false;
+	overwrite = false;
+	priority;
+	partitioned;
+	constructor(name, value, options = {}) {
+		if (!fieldContentRegExp.test(name) || RESTRICTED_NAME_CHARS_REGEXP.test(name)) throw new TypeError("argument name is invalid");
+		if (value && (!fieldContentRegExp.test(value) || RESTRICTED_VALUE_CHARS_REGEXP.test(value))) throw new TypeError("argument value is invalid");
+		this.name = name;
+		this.value = value;
+		Object.assign(this, options);
+		if (!this.value) {
+			this.expires = /* @__PURE__ */ new Date(0);
+			this.maxAge = void 0;
+		}
+		if (this.path && !fieldContentRegExp.test(this.path)) throw new TypeError("[Cookie] option path is invalid");
+		if (this.domain && !fieldContentRegExp.test(this.domain)) throw new TypeError("[Cookie] option domain is invalid");
+		if (typeof this.maxAge === "number" ? Number.isNaN(this.maxAge) || !Number.isFinite(this.maxAge) : this.maxAge) throw new TypeError("[Cookie] option maxAge is invalid");
+		if (this.priority && !PRIORITY_REGEXP.test(this.priority)) throw new TypeError("[Cookie] option priority is invalid");
+		if (this.sameSite && this.sameSite !== true && !SAME_SITE_REGEXP.test(this.sameSite)) throw new TypeError("[Cookie] option sameSite is invalid");
+	}
+	toString() {
+		return `${this.name}=${this.value}`;
+	}
+	toHeader() {
+		let header = this.toString();
+		if (this.maxAge) this.expires = new Date(Date.now() + this.maxAge);
+		if (this.path) header += `; path=${this.path}`;
+		if (this.expires) header += `; expires=${this.expires.toUTCString()}`;
+		if (this.domain) header += `; domain=${this.domain}`;
+		if (this.priority) header += `; priority=${this.priority.toLowerCase()}`;
+		if (this.sameSite) header += `; samesite=${this.sameSite === true ? "strict" : this.sameSite.toLowerCase()}`;
+		if (this.secure) header += "; secure";
+		if (this.httpOnly) header += "; httponly";
+		if (this.partitioned) header += "; partitioned";
+		return header;
+	}
+};
+//#endregion
+//#region src/cookies/timeSafeCompare.ts
+function bufferEqual(a, b) {
+	if (a.length !== b.length) return false;
+	if (crypto.timingSafeEqual) return crypto.timingSafeEqual(a, b);
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function createHmac(key, data) {
+	return crypto.createHmac("sha256", key).update(data).digest();
+}
+function timeSafeCompare(a, b) {
+	const sa = String(a);
+	const sb = String(b);
+	const key = crypto.randomBytes(32);
+	return bufferEqual(createHmac(key, sa), createHmac(key, sb)) && a === b;
+}
+//#endregion
+//#region src/cookies/Keygrip.ts
+const SLASH_PATTERN = /[/+=]/g;
+const REPLACE_MAP = {
+	"/": "_",
+	"+": "-",
+	"=": ""
+};
+var Keygrip = class {
+	algorithm;
+	encoding;
+	keys = [];
+	constructor(keys, algorithm, encoding) {
+		this.keys = keys;
+		this.algorithm = algorithm || "sha256";
+		this.encoding = encoding || "base64";
+	}
+	sign(data, key = this.keys[0]) {
+		return crypto.createHmac(this.algorithm, key).update(data).digest(this.encoding).replace(SLASH_PATTERN, (m) => REPLACE_MAP[m]);
+	}
+	index(data, digest) {
+		for (let i = 0, l = this.keys.length; i < l; i++) if (timeSafeCompare(digest, this.sign(data, this.keys[i]))) return i;
+		return -1;
+	}
+	verify(data, digest) {
+		return this.index(data, digest) > -1;
+	}
+};
+//#endregion
+//#region src/cookies/Cookies.ts
+var Cookies = class {
+	request;
+	response;
+	secure;
+	keys;
+	constructor(req, res, options = {}) {
+		this.request = req;
+		this.response = res;
+		this.secure = options.secure;
+		if (options.keys instanceof Keygrip) this.keys = options.keys;
+		else if (isArray(options.keys)) this.keys = new Keygrip(options.keys);
+	}
+	set(name, value, options) {
+		const req = this.request;
+		const res = this.response;
+		const headers = toArray(res.getHeader("Set-Cookie"));
+		const cookie = new Cookie(name, value, options);
+		const signed = options?.signed ?? !!this.keys;
+		const secure = this.secure === void 0 ? req.protocol === "https" || isRequestEncrypted(req) : Boolean(this.secure);
+		if (!secure && options?.secure) throw new Error("Cannot send secure cookie over unencrypted connection");
+		cookie.secure = options?.secure ?? secure;
+		pushCookie(headers, cookie);
+		if (signed && options) {
+			if (!this.keys) throw new Error(".keys required for signed cookies");
+			cookie.value = this.keys.sign(cookie.toString());
+			cookie.name += ".sig";
+			pushCookie(headers, cookie);
+		}
+		(res.set ? http.OutgoingMessage.prototype.setHeader : res.setHeader).call(res, "Set-Cookie", headers);
+		return this;
+	}
+	get(name, options) {
+		const signName = `${name}.sig`;
+		const signed = options?.signed ?? !!this.keys;
+		const header = this.request.headers.cookie;
+		if (!header) return;
+		const match = header.match(getPattern(name));
+		if (!match) return;
+		let value = match[1];
+		if (value[0] === "\"") value = value.slice(1, -1);
+		if (!options || !signed) return value;
+		const remote = this.get(signName);
+		if (!remote) return;
+		const data = `${name}=${value}`;
+		if (!this.keys) throw new Error(".keys required for signed cookies");
+		const index = this.keys.index(data, remote);
+		if (index < 0) this.set(signName, null, {
+			path: "/",
+			signed: false
+		});
+		else {
+			index && this.set(signName, this.keys.sign(data), { signed: false });
+			return value;
+		}
+	}
+};
+/**
+* Get the pattern to search for a cookie in a string.
+*/
+function getPattern(name) {
+	if (!REGEXP_CACHE[name]) REGEXP_CACHE[name] = new RegExp(`(?:^|;) *${name.replace(REGEXP_ESCAPE_CHARS_REGEXP, "\\$&")}=([^;]*)`);
+	return REGEXP_CACHE[name];
+}
+/**
+* Get the encrypted status for a request.
+*/
+function isRequestEncrypted(req) {
+	return Boolean(req.socket ? req.socket.encrypted : req.connection.encrypted);
+}
+function pushCookie(headers, cookie) {
+	if (cookie.overwrite) {
+		for (let i = headers.length - 1; i >= 0; i--) if (headers[i].indexOf(`${cookie.name}=`) === 0) headers.splice(i, 1);
+	}
+	headers.push(cookie.toHeader());
+}
+//#endregion
+//#region src/core/matchingWeight.ts
+const tokensCache = {};
+function getTokens(rule) {
+	if (tokensCache[rule]) return tokensCache[rule];
+	const res = [];
+	const flatten = (tokens, group = false) => {
+		for (const token of tokens) if (token.type === "text") {
+			const sub = token.value.split("/").filter(Boolean);
+			sub.length && res.push(...sub.map((v) => ({
+				type: "text",
+				value: v
+			})));
+		} else if (token.type === "group") flatten(token.tokens, true);
+		else {
+			if (group) token.optional = true;
+			res.push(token);
+		}
+	};
+	flatten(parse(rule).tokens);
+	tokensCache[rule] = res;
+	return res;
+}
+function getHighest(rules) {
+	let weights = rules.map((rule) => getTokens(rule).length);
+	weights = weights.length === 0 ? [1] : weights;
+	return Math.max(...weights) + 2;
+}
+function computedWeight(rule, highest) {
+	const tokens = getTokens(rule);
+	const dym = tokens.filter((token) => token.type !== "text");
+	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 = token.type !== "text";
+		const isWildcard = token.type === "wildcard";
+		const isOptional = !!token.optional;
+		exp += isDynamic ? 1 : 0;
+		if (i === tokens.length - 1 && isWildcard) weight += (isOptional ? 5 : 4) * 10 ** (tokens.length === 1 ? highest + 1 : highest);
+		else {
+			if (isWildcard) weight += 3 * 10 ** (highest - 1);
+			else weight += 2 * 10 ** exp;
+			if (isOptional) weight += 10 ** exp;
+		}
+	}
+	return weight;
+}
+function defaultPriority(rules) {
+	const highest = getHighest(rules);
+	return rules.sort((a, b) => computedWeight(a, highest) - computedWeight(b, highest));
+}
+/**
+* Calculate matching weight for mock URLs
+*
+* 计算 Mock URL 的匹配权重
+*
+* @param rules - Array of URL patterns / URL 模式数组
+* @param url - Request URL / 请求 URL
+* @param priority - Priority configuration / 优先级配置
+* @returns Sorted array of matched rules / 排序后的匹配规则数组
+*/
+function matchingWeight(rules, url, priority) {
+	let matched = defaultPriority(rules.filter((rule) => isPathMatch(rule, url)));
+	const { global = [], special = {} } = priority;
+	if (global.length === 0 && isEmptyObject(special) || matched.length === 0) return matched;
+	const [dynamics, statics] = partition(matched, (rule) => getTokens(rule).filter((token) => token.type !== "text").length > 0);
+	const globalMatch = global.filter((rule) => dynamics.includes(rule));
+	if (globalMatch.length > 0) matched = uniq([
+		...statics,
+		...globalMatch,
+		...dynamics
+	]);
+	if (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 } = isArray(options) ? {
+		rules: options,
+		when: []
+	} : options;
+	if (lowerRules.includes(matched[0])) {
+		if (when.length === 0 || when.some((path) => pathToRegexp(path).regexp.test(url))) matched = uniq([specialRule, ...matched]);
+	}
+	return matched;
+}
+//#endregion
+//#region src/core/requestRecovery.ts
+/**
+* 请求复原
+*
+* 由于 parseReqBody 在解析请求时，会将请求流消费，
+* 导致当接口不需要被 mock，继而由 vite http-proxy 转发时，请求流无法继续。
+* 为此，我们在请求流中记录请求数据，当当前请求无法继续时，可以从备份中恢复请求流
+*/
+const requestCollectCache = /* @__PURE__ */ new WeakMap();
+function collectRequest(req) {
+	const chunks = [];
+	req.addListener("data", (chunk) => {
+		chunks.push(Buffer.from(chunk));
+	});
+	req.addListener("end", () => {
+		if (chunks.length) requestCollectCache.set(req, Buffer.concat(chunks));
+	});
+}
+function rewriteRequest(proxyReq, req) {
+	const buffer = requestCollectCache.get(req);
+	if (buffer) {
+		requestCollectCache.delete(req);
+		if (!proxyReq.headersSent) proxyReq.setHeader("Content-Length", buffer.byteLength);
+		if (!proxyReq.writableEnded) proxyReq.write(buffer);
+	}
+}
+//#endregion
+//#region src/core/response.ts
+/**
+* 根据状态码获取状态文本
+*/
+function getHTTPStatusText(status) {
+	return HTTP_STATUS[status] || "Unknown";
+}
+/**
+* 设置响应状态
+*/
+function provideResponseStatus(response, status = 200, statusText) {
+	response.statusCode = status;
+	response.statusMessage = statusText || getHTTPStatusText(status);
+}
+/**
+* 设置响应头
+*/
+async function provideResponseHeaders(req, res, mock, logger) {
+	const { headers, type = "json" } = mock;
+	const filepath = mock.__filepath__;
+	const contentType = mime.contentType(type) || mime.contentType(mime.lookup(type) || "");
+	if (contentType) res.setHeader("Content-Type", contentType);
+	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 = isFunction(headers) ? await headers(req) : headers;
+		Object.keys(raw).forEach((key) => {
+			res.setHeader(key, raw[key]);
+		});
+	} catch (e) {
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at headers (${ansis.underline(filepath)})`, mock.log);
+	}
+}
+/**
+* 设置响应cookie
+*/
+async function provideResponseCookies(req, res, mock, logger) {
+	const { cookies } = mock;
+	const filepath = mock.__filepath__;
+	if (!cookies) return;
+	try {
+		const raw = isFunction(cookies) ? await cookies(req) : cookies;
+		Object.keys(raw).forEach((key) => {
+			const cookie = raw[key];
+			if (isArray(cookie)) {
+				const [value, options] = cookie;
+				res.setCookie(key, value, options);
+			} else res.setCookie(key, cookie);
+		});
+	} catch (e) {
+		logger.error(`${ansis.red(`mock error at ${req.url.split("?")[0]}`)}\n${e}\n  at cookies (${ansis.underline(filepath)})`, mock.log);
+	}
+}
+/**
+* 设置响应数据
+*/
+function sendResponseData(res, raw, type) {
+	if (isReadableStream(raw)) raw.pipe(res);
+	else if (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" ? Buffer.from(content) : content);
+	}
+}
+/**
+* 实际响应延迟
+*/
+async function responseRealDelay(startTime, delay) {
+	if (!delay || typeof delay === "number" && delay <= 0 || isArray(delay) && delay.length !== 2) return;
+	let realDelay = 0;
+	if (isArray(delay)) {
+		const [min, max] = delay;
+		realDelay = random(min, max);
+	} else realDelay = delay - (timestamp() - startTime);
+	if (realDelay > 0) await sleep(realDelay);
+}
+//#endregion
+//#region src/core/mockMiddleware.ts
+function baseMiddleware(compiler, { formidableOptions = {}, bodyParserOptions = {}, proxies, cookiesOptions, logger, priority = {}, cors: corsOptions }) {
+	const cors = createCors(corsOptions);
+	const [globFilter, contextFilter] = partition(proxies, (item) => isString(item) && item.includes("*"));
+	const { isMatch: isGlobProxiesMatch } = createMatcher(globFilter, [], false);
+	return async function(req, res, next) {
+		const startTime = timestamp();
+		const { query, pathname } = urlParse(req.url);
+		if (!pathname || proxies.length === 0) return next();
+		if (contextFilter.length && !contextFilter.some((context) => doesProxyContextMatchUrl(context, req))) return next();
+		if (globFilter.length && !isGlobProxiesMatch(pathname)) return next();
+		const mockData = compiler.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 parseRequestBody(req, formidableOptions, bodyParserOptions);
+		const cookies = new Cookies(req, res, cookiesOptions);
+		const getCookie = cookies.get.bind(cookies);
+		const method = req.method.toUpperCase();
+		let mock;
+		let _mockUrl;
+		for (const mockUrl of mockUrls) {
+			mock = findMockData(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 ? ansis.underline.bold(m) : ansis.dim(m)).join(", ");
+			logger.warn(`${ansis.green(pathname)} matches  ${matched} , but mock data is not found.`);
+			return next();
+		}
+		if (cors) {
+			const [error] = await attemptAsync(cors, req, res);
+			if (error) {
+				logger.error(`CORS error: ${error}`);
+				return next(error);
+			}
+		}
+		const request = req;
+		const response = res;
+		request.body = reqBody;
+		request.query = query;
+		request.refererQuery = refererQuery;
+		request.params = parseRequestParams(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;
+		provideResponseStatus(response, status, statusText);
+		await provideResponseHeaders(request, response, mock, logger);
+		await provideResponseCookies(request, response, mock, logger);
+		logger.info(requestLog(request, filepath), logLevel);
+		logger.debug(`${ansis.magenta("DEBUG")} ${ansis.underline(pathname)}  matches: [ ${mockUrls.map((m) => m === _mockUrl ? ansis.underline.bold(m) : ansis.dim(m)).join(", ")} ]\n`);
+		if (body) {
+			try {
+				const content = isFunction(body) ? await body(request) : body;
+				await responseRealDelay(startTime, delay);
+				sendResponseData(response, content, type);
+			} catch (e) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at body (${ansis.underline(filepath)})`, logLevel);
+				provideResponseStatus(response, 500);
+				res.end("");
+			}
+			return;
+		}
+		if (responseFn) {
+			try {
+				await responseRealDelay(startTime, delay);
+				await responseFn(request, response, next);
+			} catch (e) {
+				logger.error(`${ansis.red(`mock error at ${pathname}`)}\n${e}\n  at response (${ansis.underline(filepath)})`, logLevel);
+				provideResponseStatus(response, 500);
+				res.end("");
+			}
+			return;
+		}
+		res.end("");
+	};
+}
+//#endregion
+//#region src/core/ws.ts
+function mockWebSocket(compiler, httpServer, { wsProxies: proxies, cookiesOptions, logger }) {
+	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 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) => {
+		try {
+			mock.setup?.(wss, context);
+			wss.on("close", () => wssMap.delete(pathname));
+			wss.on("error", (e) => {
+				logger.error(`${ansis.red(`WebSocket mock error at ${wss.path}`)}\n${e}\n  at setup (${filepath})`, mock.log);
+			});
+		} catch (e) {
+			logger.error(`${ansis.red(`WebSocket mock error at ${wss.path}`)}\n${e}\n  at setup (${filepath})`, mock.log);
+		}
+	};
+	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));
+	};
+	compiler.on("update", ({ filepath }) => {
+		if (!hmrMap.has(filepath)) return;
+		const mockUrlList = hmrMap.get(filepath);
+		if (!mockUrlList) return;
+		for (const mockUrl of mockUrlList.values()) for (const mock of compiler.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);
+		}
+	});
+	const [globFilter, contextFilter] = partition(proxies, (item) => isString(item) && item.includes("*"));
+	const { isMatch: isGlobProxiesMatch } = createMatcher(globFilter, [], false);
+	httpServer?.on("upgrade", (req, socket, head) => {
+		const { pathname, query } = urlParse(req.url);
+		if (!pathname || proxies.length === 0) return;
+		if (contextFilter.length && !contextFilter.some((context) => doesProxyContextMatchUrl(context, req))) return;
+		if (globFilter.length && !isGlobProxiesMatch(pathname)) return;
+		const mockData = compiler.mockData;
+		const mockUrl = objectKeys(mockData).find((key) => isPathMatch(key, pathname));
+		if (!mockUrl) return;
+		const mock = mockData[mockUrl].find((mock) => {
+			return mock.url && mock.ws && isPathMatch(mock.url, 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 Cookies(req, req, cookiesOptions);
+		const { query: refererQuery } = urlParse(req.headers.referer || "");
+		request.query = query;
+		request.refererQuery = refererQuery;
+		request.params = parseRequestParams(mockUrl, pathname);
+		request.getCookie = cookies.get.bind(cookies);
+		wss.handleUpgrade(request, socket, head, (ws) => {
+			logger.info(`${ansis.magenta(ansis.bold("WebSocket"))} ${ansis.green(req.url)} connected ${ansis.dim(`(${filepath})`)}`, mock.log);
+			wssContext.connectionList.push({
+				req: request,
+				ws
+			});
+			emitConnection(wss, ws, request, wssContext.connectionList);
+		});
+	});
+	httpServer?.on("close", () => {
+		for (const wssMap of poolMap.values()) {
+			for (const wss of wssMap.values()) {
+				cleanupRunner(wssContextMap.get(wss).cleanupList);
+				wss.close();
+			}
+			wssMap.clear();
+		}
+		poolMap.clear();
+		hmrMap.clear();
+	});
+}
+function getWss(wssMap, pathname) {
+	let wss = wssMap.get(pathname);
+	if (!wss) wssMap.set(pathname, wss = new WebSocketServer({ noServer: true }));
+	return wss;
+}
+function 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);
+	});
+}
+function cleanupRunner(cleanupList) {
+	let cleanup;
+	while (cleanup = cleanupList.shift()) cleanup?.();
+}
+//#endregion
+export { processRawData as a, normalizePath as c, logLevels as d, getPackageDepList as f, processMockData as i, vfs as l, createMatcher as m, baseMiddleware as n, sortByValidator as o, getPackageDeps as p, rewriteRequest as r, waitingFor as s, mockWebSocket as t, createLogger as u };