vitepress 1.4.1 → 1.4.3

package/dist/node/{serve-4DnZ8_Si.js → chunk-BGE1nmDJ.js}

@@ -31,8 +31,10 @@ import require$$0$4 from 'tty';
 import require$$0$1 from 'constants';
 import require$$5 from 'assert';
 import { webcrypto } from 'node:crypto';
-import { createHighlighter, bundledLanguages, isSpecialLang } from 'shiki';
 import { transformerNotationDiff, transformerNotationFocus, transformerNotationHighlight, transformerNotationErrorLevel, transformerCompactLineOptions } from '@shikijs/transformers';
+import { createRequire as createRequire$1 } from 'node:module';
+import { createHighlighter, isSpecialLang } from 'shiki';
+import { c as createSyncFn } from './chunk-DQlKmeN_.js';
 import MiniSearch from 'minisearch';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -12826,10 +12828,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;
@@ -12837,29 +12835,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;
@@ -12869,54 +12857,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"),
 		}
 	};
 
@@ -12928,7 +12916,7 @@ function requirePicocolors () {
 var picocolorsExports = /*@__PURE__*/ requirePicocolors();
 var c$1 = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
 
-const require$1 = createRequire(import.meta.url);
+const require$2 = createRequire(import.meta.url);
 const PKG_ROOT = resolve$1(fileURLToPath$1(import.meta.url), "../..");
 const DIST_CLIENT_PATH = resolve$1(PKG_ROOT, "client");
 const APP_PATH = join(DIST_CLIENT_PATH, "app");
@@ -12957,15 +12945,15 @@ function resolveAliases({ root, themeDir }, ssr) {
     },
     {
       find: /^vue-demi$/,
-      replacement: require$1.resolve("vitepress/vue-demi")
+      replacement: require$2.resolve("vitepress/vue-demi")
     }
   ];
   if (!ssr) {
     let vuePath;
     try {
-      vuePath = require$1.resolve(vueRuntimePath, { paths: [root] });
+      vuePath = require$2.resolve(vueRuntimePath, { paths: [root] });
     } catch (e) {
-      vuePath = require$1.resolve(vueRuntimePath);
+      vuePath = require$2.resolve(vueRuntimePath);
     }
     aliases.push({
       find: /^vue$/,
@@ -13214,63 +13202,66 @@ function requireResolveSymlink () {
 	Object.defineProperty(resolveSymlink, "__esModule", { value: true });
 	resolveSymlink.build = void 0;
 	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;
 }
 
@@ -13354,28 +13345,27 @@ function requireWalkDirectory () {
 	walkDirectory.build = void 0;
 	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)
@@ -13414,7 +13404,7 @@ function requireQueue () {
 	        this.count++;
 	    }
 	    dequeue(error, output) {
-	        if (--this.count === 0 || error)
+	        if (--this.count <= 0 || error)
 	            this.onQueueEmpty(error, output);
 	    }
 	}
@@ -13515,15 +13505,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
@@ -13538,11 +13531,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);
@@ -13558,7 +13551,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);
@@ -13567,9 +13560,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);
@@ -16049,21 +16043,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 };
@@ -16099,8 +16099,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);
@@ -18821,6 +18821,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;
 
@@ -34452,8 +34456,12 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
+const require$1 = createRequire$1(import.meta.url);
+const resolveLangSync = createSyncFn(
+  require$1.resolve("vitepress/dist/node/worker_shikiResolveLang.js")
+);
 const nanoid = customAlphabet("abcdefghijklmnopqrstuvwxyz", 10);
-const attrsToLines = (attrs) => {
+function attrsToLines(attrs) {
   attrs = attrs.replace(/^(?:\[.*?\])?.*?([\d,-]+).*/, "$1").trim();
   const result = [];
   if (!attrs) {
@@ -34472,7 +34480,7 @@ const attrsToLines = (attrs) => {
     line: v,
     classes: ["highlighted"]
   }));
-};
+}
 async function highlight(theme, options, logger = console) {
   const {
     defaultHighlightLang: defaultLang = "",
@@ -34480,7 +34488,10 @@ async function highlight(theme, options, logger = console) {
   } = options;
   const highlighter = await createHighlighter({
     themes: typeof theme === "object" && "light" in theme && "dark" in theme ? [theme.light, theme.dark] : [theme],
-    langs: [...Object.keys(bundledLanguages), ...options.languages || []],
+    langs: [
+      ...options.languages || [],
+      ...Object.values(options.languageAlias || {})
+    ],
     langAlias: options.languageAlias
   });
   await options?.shikiSetup?.(highlighter);
@@ -34509,74 +34520,82 @@ 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)) {
+          const resolvedLang = resolveLangSync(lang);
+          if (!resolvedLang) {
+            logger.warn(
+              c$1.yellow(
+                `
 The language '${lang}' is not loaded, falling back to '${defaultLang || "txt"}' for syntax highlighting.`
-          )
-        );
-        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"] = "";
+              )
+            );
+            lang = defaultLang;
+          } else {
+            highlighter.loadLanguageSync(resolvedLang);
           }
-        },
-        {
-          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,-]+)}/;
@@ -34872,16 +34891,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) {
@@ -34957,7 +34983,7 @@ const createMarkdownRenderer = async (srcDir, options = {}, base = "/", logger =
     options.config(md);
   }
   return md;
-};
+}
 
 var crossSpawn = {exports: {}};
 
@@ -44282,6 +44308,7 @@ async function createVitePressPlugin(siteConfig, ssr = false, pageToHashMap, cli
           siteConfig.logger.error(err);
           return;
         }
+        disposeMdItInstance();
         clearCache();
         await recreateServer?.();
         return;
@@ -44315,7 +44342,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);
@@ -48508,7 +48535,7 @@ async function generateSitemap(siteConfig) {
   });
 }
 
-var version = "1.4.1";
+var version = "1.4.3";
 
 async function renderPage(render, config, page, result, appChunk, cssChunk, assets, pageToHashMap, metadataScript, additionalHeadTags) {
   const routePath = `/${page.replace(/\.md$/, "")}`;
@@ -52331,4 +52358,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 };