vitepress 1.4.0 → 1.4.2

package/dist/node/{serve-Bvg4Nr_L.js → serve-BSNQCR34.js}

@@ -1,14 +1,13 @@
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
-import path$1, { resolve as resolve$1, parse as parse$4, basename, join, posix as posix$2, dirname, normalize as normalize$3 } from 'path';
-import path$2, { win32, posix as posix$1 } from 'node:path';
+import path$1, { resolve as resolve$1, parse as parse$4, basename, join, posix as posix$2, dirname } from 'path';
+import path$2, { win32, posix as posix$1, resolve as resolve$2, normalize as normalize$3, join as join$1 } from 'node:path';
 import process$2, { stdin, stdout } from 'node:process';
 import { lstat as lstat$4, readdir as readdir$3, readlink, realpath } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import * as fs$2 from 'node:fs';
-import fs__default$1 from 'node:fs';
-import * as fs$3 from 'fs';
-import fs__default, { realpathSync as realpathSync$1, lstatSync, readdir as readdir$2, readdirSync as readdirSync$1, readlinkSync, unlinkSync, rmdirSync, chmodSync, statSync, renameSync, rmSync } from 'fs';
+import fs__default from 'node:fs';
+import fs$3, { realpathSync as realpathSync$1, lstatSync, readdir as readdir$2, readdirSync as readdirSync$1, readlinkSync, unlinkSync, rmdirSync, chmodSync, statSync, renameSync, rmSync } from 'fs';
 import { EventEmitter } from 'node:events';
 import Stream from 'node:stream';
 import { StringDecoder } from 'node:string_decoder';
@@ -630,7 +629,7 @@ var hasRequiredGracefulFs;
 function requireGracefulFs () {
 	if (hasRequiredGracefulFs) return gracefulFs;
 	hasRequiredGracefulFs = 1;
-	var fs = fs__default;
+	var fs = fs$3;
 	var polyfills = requirePolyfills();
 	var legacy = requireLegacyStreams();
 	var clone = requireClone();
@@ -2420,7 +2419,7 @@ function requireJsonfile$1 () {
 	try {
 	  _fs = requireGracefulFs();
 	} catch (_) {
-	  _fs = fs__default;
+	  _fs = fs$3;
 	}
 	const universalify = requireUniversalify();
 	const { stringify, stripBom } = requireUtils$7();
@@ -2982,7 +2981,7 @@ function findUpSync(name, {
 		const filePath = path$2.isAbsolute(name) ? name : path$2.join(directory, name);
 
 		try {
-			const stats = fs__default$1.statSync(filePath, {throwIfNoEntry: false});
+			const stats = fs__default.statSync(filePath, {throwIfNoEntry: false});
 			if ((type === 'file' && stats?.isFile()) || (type === 'directory' && stats?.isDirectory())) {
 				return filePath;
 			}
@@ -10986,15 +10985,15 @@ const readdirSync = (path) => readdirSync$1(path, { withFileTypes: true });
 // than something like:
 // const makeCb = (res, rej) => (er, ...d) => er ? rej(er) : res(...d)
 // which would be a bit cleaner.
-const chmod$2 = (path, mode) => new Promise((res, rej) => fs__default.chmod(path, mode, (er, ...d) => (er ? rej(er) : res(...d))));
-const mkdir = (path, options) => new Promise((res, rej) => fs__default.mkdir(path, options, (er, made) => (er ? rej(er) : res(made))));
-const readdir$1 = (path) => new Promise((res, rej) => fs__default.readdir(path, { withFileTypes: true }, (er, data) => er ? rej(er) : res(data)));
-const rename$1 = (oldPath, newPath) => new Promise((res, rej) => fs__default.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
-const rm$1 = (path, options) => new Promise((res, rej) => fs__default.rm(path, options, (er, ...d) => (er ? rej(er) : res(...d))));
-const rmdir$3 = (path) => new Promise((res, rej) => fs__default.rmdir(path, (er, ...d) => (er ? rej(er) : res(...d))));
-const stat$1 = (path) => new Promise((res, rej) => fs__default.stat(path, (er, data) => (er ? rej(er) : res(data))));
-const lstat$3 = (path) => new Promise((res, rej) => fs__default.lstat(path, (er, data) => (er ? rej(er) : res(data))));
-const unlink$3 = (path) => new Promise((res, rej) => fs__default.unlink(path, (er, ...d) => (er ? rej(er) : res(...d))));
+const chmod$2 = (path, mode) => new Promise((res, rej) => fs$3.chmod(path, mode, (er, ...d) => (er ? rej(er) : res(...d))));
+const mkdir = (path, options) => new Promise((res, rej) => fs$3.mkdir(path, options, (er, made) => (er ? rej(er) : res(made))));
+const readdir$1 = (path) => new Promise((res, rej) => fs$3.readdir(path, { withFileTypes: true }, (er, data) => er ? rej(er) : res(data)));
+const rename$1 = (oldPath, newPath) => new Promise((res, rej) => fs$3.rename(oldPath, newPath, (er, ...d) => er ? rej(er) : res(...d)));
+const rm$1 = (path, options) => new Promise((res, rej) => fs$3.rm(path, options, (er, ...d) => (er ? rej(er) : res(...d))));
+const rmdir$3 = (path) => new Promise((res, rej) => fs$3.rmdir(path, (er, ...d) => (er ? rej(er) : res(...d))));
+const stat$1 = (path) => new Promise((res, rej) => fs$3.stat(path, (er, data) => (er ? rej(er) : res(data))));
+const lstat$3 = (path) => new Promise((res, rej) => fs$3.lstat(path, (er, data) => (er ? rej(er) : res(data))));
+const unlink$3 = (path) => new Promise((res, rej) => fs$3.unlink(path, (er, ...d) => (er ? rej(er) : res(...d))));
 const promises = {
     chmod: chmod$2,
     mkdir,
@@ -12827,10 +12826,6 @@ function requireSrc$1 () {
 var srcExports$1 = requireSrc$1();
 var _debug = /*@__PURE__*/getDefaultExportFromCjs(srcExports$1);
 
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
 var picocolors = {exports: {}};
 
 var hasRequiredPicocolors;
@@ -12838,29 +12833,19 @@ var hasRequiredPicocolors;
 function requirePicocolors () {
 	if (hasRequiredPicocolors) return picocolors.exports;
 	hasRequiredPicocolors = 1;
-	let argv = process.argv || [],
-		env = process.env;
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
 	let isColorSupported =
-		!("NO_COLOR" in env || argv.includes("--no-color")) &&
-		("FORCE_COLOR" in env ||
-			argv.includes("--color") ||
-			process.platform === "win32" ||
-			(commonjsRequire != null && require$$0$4.isatty(1) && env.TERM !== "dumb") ||
-			"CI" in env);
-
-	let formatter =
-		(open, close, replace = open) =>
+		!(!!env.NO_COLOR || argv.includes("--no-color")) &&
+		(!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || ((p.stdout || {}).isTTY && env.TERM !== "dumb") || !!env.CI);
+
+	let formatter = (open, close, replace = open) =>
 		input => {
-			let string = "" + input;
-			let index = string.indexOf(close, open.length);
-			return ~index
-				? open + replaceClose(string, close, replace, index) + close
-				: open + string + close
+			let string = "" + input, index = string.indexOf(close, open.length);
+			return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close
 		};
 
 	let replaceClose = (string, close, replace, index) => {
-		let result = "";
-		let cursor = 0;
+		let result = "", cursor = 0;
 		do {
 			result += string.substring(cursor, index) + replace;
 			cursor = index + close.length;
@@ -12870,54 +12855,54 @@ function requirePicocolors () {
 	};
 
 	let createColors = (enabled = isColorSupported) => {
-		let init = enabled ? formatter : () => String;
+		let f = enabled ? formatter : () => String;
 		return {
 			isColorSupported: enabled,
-			reset: init("\x1b[0m", "\x1b[0m"),
-			bold: init("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-			dim: init("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-			italic: init("\x1b[3m", "\x1b[23m"),
-			underline: init("\x1b[4m", "\x1b[24m"),
-			inverse: init("\x1b[7m", "\x1b[27m"),
-			hidden: init("\x1b[8m", "\x1b[28m"),
-			strikethrough: init("\x1b[9m", "\x1b[29m"),
-
-			black: init("\x1b[30m", "\x1b[39m"),
-			red: init("\x1b[31m", "\x1b[39m"),
-			green: init("\x1b[32m", "\x1b[39m"),
-			yellow: init("\x1b[33m", "\x1b[39m"),
-			blue: init("\x1b[34m", "\x1b[39m"),
-			magenta: init("\x1b[35m", "\x1b[39m"),
-			cyan: init("\x1b[36m", "\x1b[39m"),
-			white: init("\x1b[37m", "\x1b[39m"),
-			gray: init("\x1b[90m", "\x1b[39m"),
-
-			bgBlack: init("\x1b[40m", "\x1b[49m"),
-			bgRed: init("\x1b[41m", "\x1b[49m"),
-			bgGreen: init("\x1b[42m", "\x1b[49m"),
-			bgYellow: init("\x1b[43m", "\x1b[49m"),
-			bgBlue: init("\x1b[44m", "\x1b[49m"),
-			bgMagenta: init("\x1b[45m", "\x1b[49m"),
-			bgCyan: init("\x1b[46m", "\x1b[49m"),
-			bgWhite: init("\x1b[47m", "\x1b[49m"),
-
-			blackBright: init("\x1b[90m", "\x1b[39m"),
-			redBright: init("\x1b[91m", "\x1b[39m"),
-			greenBright: init("\x1b[92m", "\x1b[39m"),
-			yellowBright: init("\x1b[93m", "\x1b[39m"),
-			blueBright: init("\x1b[94m", "\x1b[39m"),
-			magentaBright: init("\x1b[95m", "\x1b[39m"),
-			cyanBright: init("\x1b[96m", "\x1b[39m"),
-			whiteBright: init("\x1b[97m", "\x1b[39m"),
-
-			bgBlackBright: init("\x1b[100m","\x1b[49m"),
-			bgRedBright: init("\x1b[101m","\x1b[49m"),
-			bgGreenBright: init("\x1b[102m","\x1b[49m"),
-			bgYellowBright: init("\x1b[103m","\x1b[49m"),
-			bgBlueBright: init("\x1b[104m","\x1b[49m"),
-			bgMagentaBright: init("\x1b[105m","\x1b[49m"),
-			bgCyanBright: init("\x1b[106m","\x1b[49m"),
-			bgWhiteBright: init("\x1b[107m","\x1b[49m"),
+			reset: f("\x1b[0m", "\x1b[0m"),
+			bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+			dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+			italic: f("\x1b[3m", "\x1b[23m"),
+			underline: f("\x1b[4m", "\x1b[24m"),
+			inverse: f("\x1b[7m", "\x1b[27m"),
+			hidden: f("\x1b[8m", "\x1b[28m"),
+			strikethrough: f("\x1b[9m", "\x1b[29m"),
+
+			black: f("\x1b[30m", "\x1b[39m"),
+			red: f("\x1b[31m", "\x1b[39m"),
+			green: f("\x1b[32m", "\x1b[39m"),
+			yellow: f("\x1b[33m", "\x1b[39m"),
+			blue: f("\x1b[34m", "\x1b[39m"),
+			magenta: f("\x1b[35m", "\x1b[39m"),
+			cyan: f("\x1b[36m", "\x1b[39m"),
+			white: f("\x1b[37m", "\x1b[39m"),
+			gray: f("\x1b[90m", "\x1b[39m"),
+
+			bgBlack: f("\x1b[40m", "\x1b[49m"),
+			bgRed: f("\x1b[41m", "\x1b[49m"),
+			bgGreen: f("\x1b[42m", "\x1b[49m"),
+			bgYellow: f("\x1b[43m", "\x1b[49m"),
+			bgBlue: f("\x1b[44m", "\x1b[49m"),
+			bgMagenta: f("\x1b[45m", "\x1b[49m"),
+			bgCyan: f("\x1b[46m", "\x1b[49m"),
+			bgWhite: f("\x1b[47m", "\x1b[49m"),
+
+			blackBright: f("\x1b[90m", "\x1b[39m"),
+			redBright: f("\x1b[91m", "\x1b[39m"),
+			greenBright: f("\x1b[92m", "\x1b[39m"),
+			yellowBright: f("\x1b[93m", "\x1b[39m"),
+			blueBright: f("\x1b[94m", "\x1b[39m"),
+			magentaBright: f("\x1b[95m", "\x1b[39m"),
+			cyanBright: f("\x1b[96m", "\x1b[39m"),
+			whiteBright: f("\x1b[97m", "\x1b[39m"),
+
+			bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+			bgRedBright: f("\x1b[101m", "\x1b[49m"),
+			bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+			bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+			bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+			bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+			bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+			bgWhiteBright: f("\x1b[107m", "\x1b[49m"),
 		}
 	};
 
@@ -13214,64 +13199,67 @@ function requireResolveSymlink () {
 	};
 	Object.defineProperty(resolveSymlink, "__esModule", { value: true });
 	resolveSymlink.build = void 0;
-	const fs_1 = __importDefault(fs__default);
+	const fs_1 = __importDefault(fs$3);
+	const path_1 = path$1;
 	const resolveSymlinksAsync = function (path, state, callback) {
-	    const { queue, options: { suppressErrors }, } = state;
-	    queue.enqueue();
-	    fs_1.default.stat(path, (error, stat) => {
-	        if (error) {
-	            queue.dequeue(suppressErrors ? null : error, state);
-	            return;
-	        }
-	        callback(stat, path);
-	        queue.dequeue(null, state);
-	    });
-	};
-	const resolveSymlinksWithRealPathsAsync = function (path, state, callback) {
 	    const { queue, options: { suppressErrors }, } = state;
 	    queue.enqueue();
 	    fs_1.default.realpath(path, (error, resolvedPath) => {
-	        if (error) {
-	            queue.dequeue(suppressErrors ? null : error, state);
-	            return;
-	        }
-	        fs_1.default.lstat(resolvedPath, (_error, stat) => {
+	        if (error)
+	            return queue.dequeue(suppressErrors ? null : error, state);
+	        fs_1.default.stat(resolvedPath, (error, stat) => {
+	            if (error)
+	                return queue.dequeue(suppressErrors ? null : error, state);
+	            if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+	                return queue.dequeue(null, state);
 	            callback(stat, resolvedPath);
 	            queue.dequeue(null, state);
 	        });
 	    });
 	};
-	const resolveSymlinksSync = function (path, state, callback) {
-	    try {
-	        const stat = fs_1.default.statSync(path);
-	        callback(stat, path);
-	    }
-	    catch (e) {
-	        if (!state.options.suppressErrors)
-	            throw e;
-	    }
-	};
-	const resolveSymlinksWithRealPathsSync = function (path, state, callback) {
+	const resolveSymlinks = function (path, state, callback) {
+	    const { queue, options: { suppressErrors }, } = state;
+	    queue.enqueue();
 	    try {
 	        const resolvedPath = fs_1.default.realpathSync(path);
-	        const stat = fs_1.default.lstatSync(resolvedPath);
+	        const stat = fs_1.default.statSync(resolvedPath);
+	        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+	            return;
 	        callback(stat, resolvedPath);
 	    }
 	    catch (e) {
-	        if (!state.options.suppressErrors)
+	        if (!suppressErrors)
 	            throw e;
 	    }
 	};
 	function build(options, isSynchronous) {
 	    if (!options.resolveSymlinks || options.excludeSymlinks)
 	        return null;
-	    if (options.useRealPaths)
-	        return isSynchronous
-	            ? resolveSymlinksWithRealPathsSync
-	            : resolveSymlinksWithRealPathsAsync;
-	    return isSynchronous ? resolveSymlinksSync : resolveSymlinksAsync;
+	    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 	}
 	resolveSymlink.build = build;
+	function isRecursive(path, resolved, state) {
+	    if (state.options.useRealPaths)
+	        return isRecursiveUsingRealPaths(resolved, state);
+	    let parent = (0, path_1.dirname)(path);
+	    let depth = 1;
+	    while (parent !== state.root && depth < 2) {
+	        const resolvedPath = state.symlinks.get(parent);
+	        const isSameRoot = !!resolvedPath &&
+	            (resolvedPath === resolved ||
+	                resolvedPath.startsWith(resolved) ||
+	                resolved.startsWith(resolvedPath));
+	        if (isSameRoot)
+	            depth++;
+	        else
+	            parent = (0, path_1.dirname)(parent);
+	    }
+	    state.symlinks.set(path, resolved);
+	    return depth > 1;
+	}
+	function isRecursiveUsingRealPaths(resolved, state) {
+	    return state.visited.includes(resolved + state.options.pathSeparator);
+	}
 	return resolveSymlink;
 }
 
@@ -13353,30 +13341,29 @@ function requireWalkDirectory () {
 	};
 	Object.defineProperty(walkDirectory, "__esModule", { value: true });
 	walkDirectory.build = void 0;
-	const fs_1 = __importDefault(fs__default);
+	const fs_1 = __importDefault(fs$3);
 	const readdirOpts = { withFileTypes: true };
-	const walkAsync = (state, directoryPath, currentDepth, callback) => {
-	    state.queue.enqueue();
-	    if (currentDepth < 0) {
-	        state.queue.dequeue(null, state);
-	        return;
-	    }
+	const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+	    if (currentDepth < 0)
+	        return state.queue.dequeue(null, state);
+	    state.visited.push(crawlPath);
 	    state.counts.directories++;
+	    state.queue.enqueue();
 	    // Perf: Node >= 10 introduced withFileTypes that helps us
 	    // skip an extra fs.stat call.
-	    fs_1.default.readdir(directoryPath || ".", readdirOpts, function process(error, entries = []) {
+	    fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
 	        callback(entries, directoryPath, currentDepth);
 	        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
 	    });
 	};
-	const walkSync = (state, directoryPath, currentDepth, callback) => {
-	    if (currentDepth < 0) {
+	const walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+	    if (currentDepth < 0)
 	        return;
-	    }
+	    state.visited.push(crawlPath);
 	    state.counts.directories++;
 	    let entries = [];
 	    try {
-	        entries = fs_1.default.readdirSync(directoryPath || ".", readdirOpts);
+	        entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
 	    }
 	    catch (e) {
 	        if (!state.options.suppressErrors)
@@ -13415,7 +13402,7 @@ function requireQueue () {
 	        this.count++;
 	    }
 	    dequeue(error, output) {
-	        if (--this.count === 0 || error)
+	        if (--this.count <= 0 || error)
 	            this.onQueueEmpty(error, output);
 	    }
 	}
@@ -13516,15 +13503,18 @@ function requireWalker () {
 	    constructor(root, options, callback) {
 	        this.isSynchronous = !callback;
 	        this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+	        this.root = (0, utils_1.normalizePath)(root, options);
 	        this.state = {
+	            root: this.root.slice(0, -1),
 	            // Perf: we explicitly tell the compiler to optimize for String arrays
 	            paths: [""].slice(0, 0),
 	            groups: [],
 	            counts: new counter_1.Counter(),
 	            options,
 	            queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
+	            symlinks: new Map(),
+	            visited: [""].slice(0, 0),
 	        };
-	        this.root = (0, utils_1.normalizePath)(root, this.state.options);
 	        /*
 	         * Perf: We conditionally change functions according to options. This gives a slight
 	         * performance boost. Since these functions are so small, they are automatically inlined
@@ -13539,11 +13529,11 @@ function requireWalker () {
 	        this.walkDirectory = walkDirectory.build(this.isSynchronous);
 	    }
 	    start() {
-	        this.walkDirectory(this.state, this.root, this.state.options.maxDepth, this.walk);
+	        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
 	        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
 	    }
 	    walk = (entries, directoryPath, depth) => {
-	        const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, }, } = this.state;
+	        const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator, }, } = this.state;
 	        if ((signal && signal.aborted) || (maxFiles && paths.length > maxFiles))
 	            return;
 	        this.pushDirectory(directoryPath, paths, filters);
@@ -13559,7 +13549,7 @@ function requireWalker () {
 	                let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
 	                if (exclude && exclude(entry.name, path))
 	                    continue;
-	                this.walkDirectory(this.state, path, depth - 1, this.walk);
+	                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
 	            }
 	            else if (entry.isSymbolicLink() && this.resolveSymlink) {
 	                let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
@@ -13568,9 +13558,10 @@ function requireWalker () {
 	                        resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
 	                        if (exclude && exclude(entry.name, resolvedPath))
 	                            return;
-	                        this.walkDirectory(this.state, resolvedPath, depth - 1, this.walk);
+	                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
 	                    }
 	                    else {
+	                        resolvedPath = useRealPaths ? resolvedPath : path;
 	                        const filename = (0, path_1.basename)(resolvedPath);
 	                        const directoryPath = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
 	                        resolvedPath = this.joinPath(filename, directoryPath);
@@ -16050,21 +16041,27 @@ function normalizePattern(pattern, expandDirectories, cwd, properties, isIgnore)
 function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, properties) {
   if (typeof patterns === "string") {
     patterns = [patterns];
+  } else if (!patterns) {
+    patterns = ["**/*"];
   }
   if (typeof ignore === "string") {
     ignore = [ignore];
   }
   const matchPatterns = [];
-  const ignorePatterns = ignore.map((p) => normalizePattern(p, expandDirectories, cwd, properties, true));
-  if (!patterns) {
-    return { match: ["**/*"], ignore: ignorePatterns };
-  }
-  for (let pattern of patterns) {
-    pattern = normalizePattern(pattern, expandDirectories, cwd, properties, false);
-    if (pattern.startsWith("!") && pattern[1] !== "(") {
-      ignorePatterns.push(pattern.slice(1));
-    } else {
-      matchPatterns.push(pattern);
+  const ignorePatterns = [];
+  for (const pattern of ignore) {
+    if (!pattern.startsWith("!") || pattern[1] === "(") {
+      const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, true);
+      ignorePatterns.push(newPattern);
+    }
+  }
+  for (const pattern of patterns) {
+    if (!pattern.startsWith("!") || pattern[1] === "(") {
+      const newPattern = normalizePattern(pattern, expandDirectories, cwd, properties, false);
+      matchPatterns.push(newPattern);
+    } else if (pattern[1] !== "!" || pattern[2] === "(") {
+      const newPattern = normalizePattern(pattern.slice(1), expandDirectories, cwd, properties, true);
+      ignorePatterns.push(newPattern);
     }
   }
   return { match: matchPatterns, ignore: ignorePatterns };
@@ -16100,8 +16097,8 @@ function crawl(options, cwd, sync) {
     filters: [(p, isDirectory) => matcher(processPath(p, cwd, properties.root, isDirectory, options.absolute))],
     exclude: (_, p) => exclude(processPath(p, cwd, properties.root, true, true)),
     pathSeparator: "/",
-    relativePaths: true
-    // resolveSymlinks: true
+    relativePaths: true,
+    resolveSymlinks: true
   };
   if (options.deep) {
     fdirOptions.maxDepth = Math.round(options.deep - properties.depthOffset);
@@ -16553,21 +16550,33 @@ function pathToRegexp(path, keys, options) {
 }
 
 function resolveRewrites(pages, userRewrites) {
-  const rewriteRules = Object.entries(userRewrites || {}).map(([from, to]) => ({
-    toPath: compile$1(`/${to}`, { validate: false }),
-    matchUrl: match(from.startsWith("^") ? new RegExp(from) : from)
-  }));
   const pageToRewrite = {};
   const rewriteToPage = {};
-  if (rewriteRules.length) {
+  if (typeof userRewrites === "function") {
     for (const page of pages) {
-      for (const { matchUrl, toPath } of rewriteRules) {
-        const res = matchUrl(page);
-        if (res) {
-          const dest = toPath(res.params).slice(1);
-          pageToRewrite[page] = dest;
-          rewriteToPage[dest] = page;
-          break;
+      const dest = userRewrites(page);
+      if (dest && dest !== page) {
+        pageToRewrite[page] = dest;
+        rewriteToPage[dest] = page;
+      }
+    }
+  } else if (typeof userRewrites === "object") {
+    const rewriteRules = Object.entries(userRewrites || {}).map(
+      ([from, to]) => ({
+        toPath: compile$1(`/${to}`, { validate: false }),
+        matchUrl: match(from.startsWith("^") ? new RegExp(from) : from)
+      })
+    );
+    if (rewriteRules.length) {
+      for (const page of pages) {
+        for (const { matchUrl, toPath } of rewriteRules) {
+          const res = matchUrl(page);
+          if (res) {
+            const dest = toPath(res.params).slice(1);
+            pageToRewrite[page] = dest;
+            rewriteToPage[dest] = page;
+            break;
+          }
         }
       }
     }
@@ -18810,6 +18819,10 @@ function requireMerge () {
 	return merge;
 }
 
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
 var binary$1;
 var hasRequiredBinary;
 
@@ -22345,7 +22358,7 @@ function requireGrayMatter () {
 	if (hasRequiredGrayMatter) return grayMatter;
 	hasRequiredGrayMatter = 1;
 
-	const fs = fs__default;
+	const fs = fs$3;
 	const sections = requireSectionMatter();
 	const defaults = requireDefaults();
 	const stringify = requireStringify$1();
@@ -34442,7 +34455,7 @@ function capitalize(str) {
 }
 
 const nanoid = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
-const attrsToLines = (attrs) => {
+function attrsToLines(attrs) {
   attrs = attrs.replace(/^(?:\[.*?\])?.*?([\d,-]+).*/, "$1").trim();
   const result = [];
   if (!attrs) {
@@ -34461,7 +34474,7 @@ const attrsToLines = (attrs) => {
     line: v,
     classes: ["highlighted"]
   }));
-};
+}
 async function highlight(theme, options, logger = console) {
   const {
     defaultHighlightLang: defaultLang = "",
@@ -34498,74 +34511,77 @@ async function highlight(theme, options, logger = console) {
   const lineNoStartRE = /=(\d*)/;
   const lineNoRE = /:(no-)?line-numbers(=\d*)?$/;
   const mustacheRE = /\{\{.*?\}\}/g;
-  return (str, lang, attrs) => {
-    const vPre = vueRE.test(lang) ? "" : "v-pre";
-    lang = lang.replace(lineNoStartRE, "").replace(lineNoRE, "").replace(vueRE, "").toLowerCase() || defaultLang;
-    if (lang) {
-      const langLoaded = highlighter.getLoadedLanguages().includes(lang);
-      if (!langLoaded && !isSpecialLang(lang)) {
-        logger.warn(
-          c$1.yellow(
-            `
+  return [
+    (str, lang, attrs) => {
+      const vPre = vueRE.test(lang) ? "" : "v-pre";
+      lang = lang.replace(lineNoStartRE, "").replace(lineNoRE, "").replace(vueRE, "").toLowerCase() || defaultLang;
+      if (lang) {
+        const langLoaded = highlighter.getLoadedLanguages().includes(lang);
+        if (!langLoaded && !isSpecialLang(lang)) {
+          logger.warn(
+            c$1.yellow(
+              `
 The language '${lang}' is not loaded, falling back to '${defaultLang || "txt"}' for syntax highlighting.`
-          )
-        );
-        lang = defaultLang;
+            )
+          );
+          lang = defaultLang;
+        }
       }
-    }
-    const lineOptions = attrsToLines(attrs);
-    const mustaches = /* @__PURE__ */ new Map();
-    const removeMustache = (s) => {
-      if (vPre) return s;
-      return s.replace(mustacheRE, (match) => {
-        let marker = mustaches.get(match);
-        if (!marker) {
-          marker = nanoid();
-          mustaches.set(match, marker);
-        }
-        return marker;
-      });
-    };
-    const restoreMustache = (s) => {
-      mustaches.forEach((marker, match) => {
-        s = s.replaceAll(marker, match);
-      });
-      return s;
-    };
-    str = removeMustache(str).trimEnd();
-    const highlighted = highlighter.codeToHtml(str, {
-      lang,
-      transformers: [
-        ...transformers,
-        transformerCompactLineOptions(lineOptions),
-        {
-          name: "vitepress:v-pre",
-          pre(node) {
-            if (vPre) node.properties["v-pre"] = "";
-          }
-        },
-        {
-          name: "vitepress:empty-line",
-          code(hast) {
-            hast.children.forEach((span) => {
-              if (span.type === "element" && span.tagName === "span" && Array.isArray(span.properties.class) && span.properties.class.includes("line") && span.children.length === 0) {
-                span.children.push({
-                  type: "element",
-                  tagName: "wbr",
-                  properties: {},
-                  children: []
-                });
-              }
-            });
+      const lineOptions = attrsToLines(attrs);
+      const mustaches = /* @__PURE__ */ new Map();
+      const removeMustache = (s) => {
+        if (vPre) return s;
+        return s.replace(mustacheRE, (match) => {
+          let marker = mustaches.get(match);
+          if (!marker) {
+            marker = nanoid();
+            mustaches.set(match, marker);
           }
-        },
-        ...userTransformers
-      ],
-      meta: { __raw: attrs },
-      ...typeof theme === "object" && "light" in theme && "dark" in theme ? { themes: theme, defaultColor: false } : { theme }
-    });
-    return restoreMustache(highlighted);
-  };
+          return marker;
+        });
+      };
+      const restoreMustache = (s) => {
+        mustaches.forEach((marker, match) => {
+          s = s.replaceAll(marker, match);
+        });
+        return s;
+      };
+      str = removeMustache(str).trimEnd();
+      const highlighted = highlighter.codeToHtml(str, {
+        lang,
+        transformers: [
+          ...transformers,
+          transformerCompactLineOptions(lineOptions),
+          {
+            name: "vitepress:v-pre",
+            pre(node) {
+              if (vPre) node.properties["v-pre"] = "";
+            }
+          },
+          {
+            name: "vitepress:empty-line",
+            code(hast) {
+              hast.children.forEach((span) => {
+                if (span.type === "element" && span.tagName === "span" && Array.isArray(span.properties.class) && span.properties.class.includes("line") && span.children.length === 0) {
+                  span.children.push({
+                    type: "element",
+                    tagName: "wbr",
+                    properties: {},
+                    children: []
+                  });
+                }
+              });
+            }
+          },
+          ...userTransformers
+        ],
+        meta: { __raw: attrs },
+        ...typeof theme === "object" && "light" in theme && "dark" in theme ? { themes: theme, defaultColor: false } : { theme }
+      });
+      return restoreMustache(highlighted);
+    },
+    highlighter.dispose
+  ];
 }
 
 const RE = /{([\d,-]+)}/;
@@ -34861,16 +34877,23 @@ const snippetPlugin = (md, srcDir) => {
   md.block.ruler.before("fence", "snippet", parser);
 };
 
-const createMarkdownRenderer = async (srcDir, options = {}, base = "/", logger = console) => {
+let md;
+let _disposeHighlighter;
+function disposeMdItInstance() {
+  if (md) {
+    md = void 0;
+    _disposeHighlighter?.();
+  }
+}
+async function createMarkdownRenderer(srcDir, options = {}, base = "/", logger = console) {
+  if (md) return md;
   const theme = options.theme ?? { light: "github-light", dark: "github-dark" };
   const codeCopyButtonTitle = options.codeCopyButtonTitle || "Copy Code";
   const hasSingleTheme = typeof theme === "string" || "name" in theme;
-  const md = MarkdownIt({
-    html: true,
-    linkify: true,
-    highlight: options.highlight || await highlight(theme, options, logger),
-    ...options
-  });
+  let [highlight$1, dispose] = options.highlight ? [options.highlight, () => {
+  }] : await highlight(theme, options, logger);
+  _disposeHighlighter = dispose;
+  md = MarkdownIt({ html: true, linkify: true, highlight: highlight$1, ...options });
   md.linkify.set({ fuzzyLink: false });
   md.use(restoreEntities);
   if (options.preConfig) {
@@ -34946,7 +34969,7 @@ const createMarkdownRenderer = async (srcDir, options = {}, base = "/", logger =
     options.config(md);
   }
   return md;
-};
+}
 
 var crossSpawn = {exports: {}};
 
@@ -34959,7 +34982,7 @@ function requireWindows () {
 	windows = isexe;
 	isexe.sync = sync;
 
-	var fs = fs__default;
+	var fs = fs$3;
 
 	function checkPathExt (path, options) {
 	  var pathext = options.pathExt !== undefined ?
@@ -35010,7 +35033,7 @@ function requireMode () {
 	mode = isexe;
 	isexe.sync = sync;
 
-	var fs = fs__default;
+	var fs = fs$3;
 
 	function isexe (path, options, cb) {
 	  fs.stat(path, function (er, stat) {
@@ -35433,7 +35456,7 @@ function requireReadShebang () {
 	if (hasRequiredReadShebang) return readShebang_1;
 	hasRequiredReadShebang = 1;
 
-	const fs = fs__default;
+	const fs = fs$3;
 	const shebangCommand = requireShebangCommand();
 
 	function readShebang(command) {
@@ -35760,13 +35783,13 @@ async function createMarkdownToVueRenderFn(srcDir, options = {}, pages, isBuild
   const dynamicRoutes = new Map(
     siteConfig?.dynamicRoutes?.routes.map((r) => [
       r.fullPath,
-      path$1.join(srcDir, r.route)
+      slash(path$1.join(srcDir, r.route))
     ]) || []
   );
   const rewrites = new Map(
     Object.entries(siteConfig?.rewrites.map || {}).map(([key, value]) => [
-      path$1.join(srcDir, key),
-      path$1.join(srcDir, value)
+      slash(path$1.join(srcDir, key)),
+      slash(path$1.join(srcDir, value))
     ]) || []
   );
   return async (src, file, publicDir) => {
@@ -44271,6 +44294,7 @@ async function createVitePressPlugin(siteConfig, ssr = false, pageToHashMap, cli
           siteConfig.logger.error(err);
           return;
         }
+        disposeMdItInstance();
         clearCache();
         await recreateServer?.();
         return;
@@ -44304,7 +44328,7 @@ async function createVitePressPlugin(siteConfig, ssr = false, pageToHashMap, cli
         return [
           ...modules,
           ...importers.map((id) => {
-            clearCache(id);
+            clearCache(slash(path$1.relative(srcDir, id)));
             return server.moduleGraph.getModuleById(id);
           })
         ].filter(Boolean);
@@ -45207,7 +45231,7 @@ function requireUtils () {
 	 * Copyright(c) 2011 Eugene Kalinin
 	 * MIT Licensed
 	 */
-	const fs_1 = fs__default;
+	const fs_1 = fs$3;
 	const stream_1 = require$$0$2;
 	const readline_1 = require$$2$1;
 	const url_1 = require$$3;
@@ -48305,7 +48329,7 @@ function requireSitemapSimple () {
 		const sitemap_stream_1 = requireSitemapStream();
 		const utils_1 = requireUtils();
 		const zlib_1 = require$$3$1;
-		const fs_1 = fs__default;
+		const fs_1 = fs$3;
 		const path_1 = path$1;
 		const stream_1 = require$$0$2;
 		const util_1 = require$$0$3;
@@ -48497,7 +48521,7 @@ async function generateSitemap(siteConfig) {
   });
 }
 
-var version = "1.4.0";
+var version = "1.4.2";
 
 async function renderPage(render, config, page, result, appChunk, cssChunk, assets, pageToHashMap, metadataScript, additionalHeadTags) {
   const routePath = `/${page.replace(/\.md$/, "")}`;
@@ -51227,6 +51251,15 @@ function requirePostcssPrefixSelector () {
 	              );
 	            }
 
+	            // replace :root, body, html with the prefix
+	            if ([':root', 'body', 'html'].some(globalSel => selector.startsWith(globalSel))) {
+	              if (options.skipGlobalSelectors) {
+	                return selector;
+	              }
+
+	              return selector.replace(/(html\s+body|:root\s+body|html|:root|body)/gm, prefix);
+	            }
+
 	            return prefixWithSpace + selector;
 	          });
 	        }
@@ -52096,9 +52129,9 @@ function viaLocal(dir, isEtag, uri, extns) {
 	let i=0, arr=toAssume(uri, extns);
 	let abs, stats, name, headers;
 	for (; i < arr.length; i++) {
-		abs = normalize$3(join(dir, name=arr[i]));
-		if (abs.startsWith(dir) && fs$3.existsSync(abs)) {
-			stats = fs$3.statSync(abs);
+		abs = normalize$3(join$1(dir, name=arr[i]));
+		if (abs.startsWith(dir) && fs$2.existsSync(abs)) {
+			stats = fs$2.statSync(abs);
 			if (stats.isDirectory()) continue;
 			headers = toHeaders(name, stats, isEtag);
 			headers['Cache-Control'] = isEtag ? 'no-cache' : 'no-store';
@@ -52146,7 +52179,7 @@ function send(req, res, file, stats, headers) {
 	}
 
 	res.writeHead(code, headers);
-	fs$3.createReadStream(file, opts).pipe(res);
+	fs$2.createReadStream(file, opts).pipe(res);
 }
 
 const ENCODING = {
@@ -52173,7 +52206,7 @@ function toHeaders(name, stats, isEtag) {
 }
 
 function sirv (dir, opts={}) {
-	dir = resolve$1(dir || '.');
+	dir = resolve$2(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
 	let setHeaders = opts.setHeaders || noop;
@@ -52311,4 +52344,4 @@ async function createServer(root = process.cwd(), serverOptions = {}, recreateSe
   });
 }
 
-export { ScaffoldThemeType as S, defineConfig as a, build as b, createMarkdownRenderer as c, defineLoader as d, defineConfigWithTheme as e, fs as f, glob as g, resolveUserConfig as h, mergeConfig as i, resolveSiteData as j, resolvePages as k, init as l, matter as m, serve as n, createServer as o, postcssPrefixSelector as p, getDefaultExportFromCjs as q, resolveConfig as r, scaffold as s, c$1 as t, clearCache as u, version as v };
+export { ScaffoldThemeType as S, defineConfig as a, build as b, createMarkdownRenderer as c, defineLoader as d, defineConfigWithTheme as e, fs as f, glob as g, resolveUserConfig as h, mergeConfig as i, resolveSiteData as j, resolvePages as k, init as l, matter as m, disposeMdItInstance as n, serve as o, postcssPrefixSelector as p, createServer as q, resolveConfig as r, scaffold as s, getDefaultExportFromCjs as t, c$1 as u, clearCache as v, version as w };