vitepress 1.4.1 → 1.4.3

package/dist/node/chunk-DQlKmeN_.js

@@ -0,0 +1,470 @@
+import { createHash } from 'node:crypto';
+import fs__default from 'node:fs';
+import module, { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { MessageChannel, Worker, workerData, parentPort, receiveMessageOnPort } from 'node:worker_threads';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+      t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+              t[p[i]] = s[p[i]];
+      }
+  return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const CWD = process.cwd();
+const cjsRequire$1 = typeof require === 'undefined' ? createRequire(import.meta.url) : require;
+const EXTENSIONS = ['.ts', '.tsx', ...Object.keys(cjsRequire$1.extensions)];
+
+const tryPkg = (pkg) => {
+    try {
+        return cjsRequire$1.resolve(pkg);
+    }
+    catch (_a) { }
+};
+const isPkgAvailable = (pkg) => !!tryPkg(pkg);
+const tryFile = (filePath, includeDir = false) => {
+    if (typeof filePath === 'string') {
+        return fs__default.existsSync(filePath) &&
+            (includeDir || fs__default.statSync(filePath).isFile())
+            ? filePath
+            : '';
+    }
+    for (const file of filePath !== null && filePath !== void 0 ? filePath : []) {
+        if (tryFile(file, includeDir)) {
+            return file;
+        }
+    }
+    return '';
+};
+const tryExtensions = (filepath, extensions = EXTENSIONS) => {
+    const ext = [...extensions, ''].find(ext => tryFile(filepath + ext));
+    return ext == null ? '' : filepath + ext;
+};
+const findUp = (searchEntry, searchFileOrIncludeDir, includeDir) => {
+    console.assert(path.isAbsolute(searchEntry));
+    if (!tryFile(searchEntry, true) ||
+        (searchEntry !== CWD && !searchEntry.startsWith(CWD + path.sep))) {
+        return '';
+    }
+    searchEntry = path.resolve(fs__default.statSync(searchEntry).isDirectory()
+        ? searchEntry
+        : path.resolve(searchEntry, '..'));
+    const isSearchFile = typeof searchFileOrIncludeDir === 'string';
+    const searchFile = 'package.json';
+    do {
+        const searched = tryFile(path.resolve(searchEntry, searchFile), isSearchFile);
+        if (searched) {
+            return searched;
+        }
+        searchEntry = path.resolve(searchEntry, '..');
+    } while (searchEntry === CWD || searchEntry.startsWith(CWD + path.sep));
+    return '';
+};
+
+const INT32_BYTES = 4;
+const TsRunner = {
+    TsNode: 'ts-node',
+    EsbuildRegister: 'esbuild-register',
+    EsbuildRunner: 'esbuild-runner',
+    SWC: 'swc',
+    TSX: 'tsx',
+};
+const { NODE_OPTIONS, SYNCKIT_EXEC_ARGV, SYNCKIT_GLOBAL_SHIMS, SYNCKIT_TIMEOUT, SYNCKIT_TS_RUNNER, } = process.env;
+const IS_NODE_20 = Number(process.versions.node.split('.')[0]) >= 20;
+const DEFAULT_TIMEOUT = SYNCKIT_TIMEOUT ? +SYNCKIT_TIMEOUT : undefined;
+const DEFAULT_EXEC_ARGV = (SYNCKIT_EXEC_ARGV === null || SYNCKIT_EXEC_ARGV === void 0 ? void 0 : SYNCKIT_EXEC_ARGV.split(',')) || [];
+const DEFAULT_TS_RUNNER = SYNCKIT_TS_RUNNER;
+const DEFAULT_GLOBAL_SHIMS = ['1', 'true'].includes(SYNCKIT_GLOBAL_SHIMS);
+const DEFAULT_GLOBAL_SHIMS_PRESET = [
+    {
+        moduleName: 'node-fetch',
+        globalName: 'fetch',
+    },
+    {
+        moduleName: 'node:perf_hooks',
+        globalName: 'performance',
+        named: 'performance',
+    },
+];
+const MTS_SUPPORTED_NODE_VERSION = 16;
+let syncFnCache;
+function extractProperties(object) {
+    if (object && typeof object === 'object') {
+        const properties = {};
+        for (const key in object) {
+            properties[key] = object[key];
+        }
+        return properties;
+    }
+}
+function createSyncFn(workerPath, timeoutOrOptions) {
+    syncFnCache !== null && syncFnCache !== void 0 ? syncFnCache : (syncFnCache = new Map());
+    const cachedSyncFn = syncFnCache.get(workerPath);
+    if (cachedSyncFn) {
+        return cachedSyncFn;
+    }
+    if (!path.isAbsolute(workerPath)) {
+        throw new Error('`workerPath` must be absolute');
+    }
+    const syncFn = startWorkerThread(workerPath, timeoutOrOptions);
+    syncFnCache.set(workerPath, syncFn);
+    return syncFn;
+}
+const cjsRequire = typeof require === 'undefined'
+    ? module.createRequire(import.meta.url)
+    : require;
+const dataUrl = (code) => new URL(`data:text/javascript,${encodeURIComponent(code)}`);
+const isFile = (path) => {
+    var _a;
+    try {
+        return !!((_a = fs__default.statSync(path, { throwIfNoEntry: false })) === null || _a === void 0 ? void 0 : _a.isFile());
+    }
+    catch (_b) {
+        return false;
+    }
+};
+const setupTsRunner = (workerPath, { execArgv, tsRunner }) => {
+    let ext = path.extname(workerPath);
+    if (!/[/\\]node_modules[/\\]/.test(workerPath) &&
+        (!ext || /^\.[cm]?js$/.test(ext))) {
+        const workPathWithoutExt = ext
+            ? workerPath.slice(0, -ext.length)
+            : workerPath;
+        let extensions;
+        switch (ext) {
+            case '.cjs': {
+                extensions = ['.cts', '.cjs'];
+                break;
+            }
+            case '.mjs': {
+                extensions = ['.mts', '.mjs'];
+                break;
+            }
+            default: {
+                extensions = ['.ts', '.js'];
+                break;
+            }
+        }
+        const found = tryExtensions(workPathWithoutExt, extensions);
+        let differentExt;
+        if (found && (!ext || (differentExt = found !== workPathWithoutExt))) {
+            workerPath = found;
+            if (differentExt) {
+                ext = path.extname(workerPath);
+            }
+        }
+    }
+    const isTs = /\.[cm]?ts$/.test(workerPath);
+    let jsUseEsm = workerPath.endsWith('.mjs');
+    let tsUseEsm = workerPath.endsWith('.mts');
+    if (isTs) {
+        if (!tsUseEsm) {
+            const pkg = findUp(workerPath);
+            if (pkg) {
+                tsUseEsm =
+                    cjsRequire(pkg).type ===
+                        'module';
+            }
+        }
+        if (tsRunner == null && isPkgAvailable(TsRunner.TsNode)) {
+            tsRunner = TsRunner.TsNode;
+        }
+        switch (tsRunner) {
+            case TsRunner.TsNode: {
+                if (tsUseEsm) {
+                    if (!execArgv.includes('--loader')) {
+                        execArgv = ['--loader', `${TsRunner.TsNode}/esm`, ...execArgv];
+                    }
+                }
+                else if (!execArgv.includes('-r')) {
+                    execArgv = ['-r', `${TsRunner.TsNode}/register`, ...execArgv];
+                }
+                break;
+            }
+            case TsRunner.EsbuildRegister: {
+                if (!execArgv.includes('-r')) {
+                    execArgv = ['-r', TsRunner.EsbuildRegister, ...execArgv];
+                }
+                break;
+            }
+            case TsRunner.EsbuildRunner: {
+                if (!execArgv.includes('-r')) {
+                    execArgv = ['-r', `${TsRunner.EsbuildRunner}/register`, ...execArgv];
+                }
+                break;
+            }
+            case TsRunner.SWC: {
+                if (!execArgv.includes('-r')) {
+                    execArgv = ['-r', `@${TsRunner.SWC}-node/register`, ...execArgv];
+                }
+                break;
+            }
+            case TsRunner.TSX: {
+                if (!execArgv.includes('--loader')) {
+                    execArgv = ['--loader', TsRunner.TSX, ...execArgv];
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unknown ts runner: ${String(tsRunner)}`);
+            }
+        }
+    }
+    else if (!jsUseEsm) {
+        const pkg = findUp(workerPath);
+        if (pkg) {
+            jsUseEsm =
+                cjsRequire(pkg).type === 'module';
+        }
+    }
+    let resolvedPnpLoaderPath;
+    if (process.versions.pnp) {
+        const nodeOptions = NODE_OPTIONS === null || NODE_OPTIONS === void 0 ? void 0 : NODE_OPTIONS.split(/\s+/);
+        let pnpApiPath;
+        try {
+            pnpApiPath = cjsRequire.resolve('pnpapi');
+        }
+        catch (_a) { }
+        if (pnpApiPath &&
+            !(nodeOptions === null || nodeOptions === void 0 ? void 0 : nodeOptions.some((option, index) => ['-r', '--require'].includes(option) &&
+                pnpApiPath === cjsRequire.resolve(nodeOptions[index + 1]))) &&
+            !execArgv.includes(pnpApiPath)) {
+            execArgv = ['-r', pnpApiPath, ...execArgv];
+            const pnpLoaderPath = path.resolve(pnpApiPath, '../.pnp.loader.mjs');
+            if (isFile(pnpLoaderPath)) {
+                resolvedPnpLoaderPath = pathToFileURL(pnpLoaderPath).toString();
+                if (!IS_NODE_20) {
+                    execArgv = [
+                        '--experimental-loader',
+                        resolvedPnpLoaderPath,
+                        ...execArgv,
+                    ];
+                }
+            }
+        }
+    }
+    return {
+        ext,
+        isTs,
+        jsUseEsm,
+        tsRunner,
+        tsUseEsm,
+        workerPath,
+        pnpLoaderPath: resolvedPnpLoaderPath,
+        execArgv,
+    };
+};
+const md5Hash = (text) => createHash('md5').update(text).digest('hex');
+const encodeImportModule = (moduleNameOrGlobalShim, type = 'import') => {
+    const { moduleName, globalName, named, conditional } = typeof moduleNameOrGlobalShim === 'string'
+        ? { moduleName: moduleNameOrGlobalShim }
+        : moduleNameOrGlobalShim;
+    const importStatement = type === 'import'
+        ? `import${globalName
+            ? ' ' +
+                (named === null
+                    ? '* as ' + globalName
+                    : (named === null || named === void 0 ? void 0 : named.trim())
+                        ? `{${named}}`
+                        : globalName) +
+                ' from'
+            : ''} '${path.isAbsolute(moduleName)
+            ? String(pathToFileURL(moduleName))
+            : moduleName}'`
+        : `${globalName
+            ? 'const ' + ((named === null || named === void 0 ? void 0 : named.trim()) ? `{${named}}` : globalName) + '='
+            : ''}require('${moduleName
+            .replace(/\\/g, '\\\\')}')`;
+    if (!globalName) {
+        return importStatement;
+    }
+    const overrideStatement = `globalThis.${globalName}=${(named === null || named === void 0 ? void 0 : named.trim()) ? named : globalName}`;
+    return (importStatement +
+        (conditional === false
+            ? `;${overrideStatement}`
+            : `;if(!globalThis.${globalName})${overrideStatement}`));
+};
+const _generateGlobals = (globalShims, type) => globalShims.reduce((acc, shim) => `${acc}${acc ? ';' : ''}${encodeImportModule(shim, type)}`, '');
+let globalsCache;
+let tmpdir;
+const _dirname = typeof __dirname === 'undefined'
+    ? path.dirname(fileURLToPath(import.meta.url))
+    : __dirname;
+let sharedBuffer;
+let sharedBufferView;
+const generateGlobals = (workerPath, globalShims, type = 'import') => {
+    globalsCache !== null && globalsCache !== void 0 ? globalsCache : (globalsCache = new Map());
+    const cached = globalsCache.get(workerPath);
+    if (cached) {
+        const [content, filepath] = cached;
+        if ((type === 'require' && !filepath) ||
+            (type === 'import' && filepath && isFile(filepath))) {
+            return content;
+        }
+    }
+    const globals = _generateGlobals(globalShims, type);
+    let content = globals;
+    let filepath;
+    if (type === 'import') {
+        if (!tmpdir) {
+            tmpdir = path.resolve(findUp(_dirname), '../node_modules/.synckit');
+        }
+        fs__default.mkdirSync(tmpdir, { recursive: true });
+        filepath = path.resolve(tmpdir, md5Hash(workerPath) + '.mjs');
+        content = encodeImportModule(filepath);
+        fs__default.writeFileSync(filepath, globals);
+    }
+    globalsCache.set(workerPath, [content, filepath]);
+    return content;
+};
+function startWorkerThread(workerPath, { timeout = DEFAULT_TIMEOUT, execArgv = DEFAULT_EXEC_ARGV, tsRunner = DEFAULT_TS_RUNNER, transferList = [], globalShims = DEFAULT_GLOBAL_SHIMS, } = {}) {
+    const { port1: mainPort, port2: workerPort } = new MessageChannel();
+    const { isTs, ext, jsUseEsm, tsUseEsm, tsRunner: finalTsRunner, workerPath: finalWorkerPath, pnpLoaderPath, execArgv: finalExecArgv, } = setupTsRunner(workerPath, { execArgv, tsRunner });
+    const workerPathUrl = pathToFileURL(finalWorkerPath);
+    if (/\.[cm]ts$/.test(finalWorkerPath)) {
+        const isTsxSupported = !tsUseEsm ||
+            Number.parseFloat(process.versions.node) >= MTS_SUPPORTED_NODE_VERSION;
+        if (!finalTsRunner) {
+            throw new Error('No ts runner specified, ts worker path is not supported');
+        }
+        else if ([
+            TsRunner.EsbuildRegister,
+            TsRunner.EsbuildRunner,
+            TsRunner.SWC,
+            ...(isTsxSupported ? [] : [TsRunner.TSX]),
+        ].includes(finalTsRunner)) {
+            throw new Error(`${finalTsRunner} is not supported for ${ext} files yet` +
+                (isTsxSupported
+                    ? ', you can try [tsx](https://github.com/esbuild-kit/tsx) instead'
+                    : ''));
+        }
+    }
+    const finalGlobalShims = (globalShims === true
+        ? DEFAULT_GLOBAL_SHIMS_PRESET
+        : Array.isArray(globalShims)
+            ? globalShims
+            : []).filter(({ moduleName }) => isPkgAvailable(moduleName));
+    sharedBufferView !== null && sharedBufferView !== void 0 ? sharedBufferView : (sharedBufferView = new Int32Array((sharedBuffer !== null && sharedBuffer !== void 0 ? sharedBuffer : (sharedBuffer = new SharedArrayBuffer(INT32_BYTES))), 0, 1));
+    const useGlobals = finalGlobalShims.length > 0;
+    const useEval = isTs ? !tsUseEsm : !jsUseEsm && useGlobals;
+    const worker = new Worker((jsUseEsm && useGlobals) || (tsUseEsm && finalTsRunner === TsRunner.TsNode)
+        ? dataUrl(`${generateGlobals(finalWorkerPath, finalGlobalShims)};import '${String(workerPathUrl)}'`)
+        : useEval
+            ? `${generateGlobals(finalWorkerPath, finalGlobalShims, 'require')};${encodeImportModule(finalWorkerPath, 'require')}`
+            : workerPathUrl, {
+        eval: useEval,
+        workerData: { sharedBuffer, workerPort, pnpLoaderPath },
+        transferList: [workerPort, ...transferList],
+        execArgv: finalExecArgv,
+    });
+    let nextID = 0;
+    const receiveMessageWithId = (port, expectedId, waitingTimeout) => {
+        const start = Date.now();
+        const status = Atomics.wait(sharedBufferView, 0, 0, waitingTimeout);
+        Atomics.store(sharedBufferView, 0, 0);
+        if (!['ok', 'not-equal'].includes(status)) {
+            const abortMsg = {
+                id: expectedId,
+                cmd: 'abort',
+            };
+            port.postMessage(abortMsg);
+            throw new Error('Internal error: Atomics.wait() failed: ' + status);
+        }
+        const _a = receiveMessageOnPort(mainPort).message, { id } = _a, message = __rest(_a, ["id"]);
+        if (id < expectedId) {
+            const waitingTime = Date.now() - start;
+            return receiveMessageWithId(port, expectedId, waitingTimeout ? waitingTimeout - waitingTime : undefined);
+        }
+        if (expectedId !== id) {
+            throw new Error(`Internal error: Expected id ${expectedId} but got id ${id}`);
+        }
+        return Object.assign({ id }, message);
+    };
+    const syncFn = (...args) => {
+        const id = nextID++;
+        const msg = { id, args };
+        worker.postMessage(msg);
+        const { result, error, properties } = receiveMessageWithId(mainPort, id, timeout);
+        if (error) {
+            throw Object.assign(error, properties);
+        }
+        return result;
+    };
+    worker.unref();
+    return syncFn;
+}
+function runAsWorker(fn) {
+    if (!workerData) {
+        return;
+    }
+    const { workerPort, sharedBuffer, pnpLoaderPath } = workerData;
+    if (pnpLoaderPath && IS_NODE_20) {
+        module.register(pnpLoaderPath);
+    }
+    const sharedBufferView = new Int32Array(sharedBuffer, 0, 1);
+    parentPort.on('message', ({ id, args }) => {
+        (() => __awaiter(this, void 0, void 0, function* () {
+            let isAborted = false;
+            const handleAbortMessage = (msg) => {
+                if (msg.id === id && msg.cmd === 'abort') {
+                    isAborted = true;
+                }
+            };
+            workerPort.on('message', handleAbortMessage);
+            let msg;
+            try {
+                msg = { id, result: yield fn(...args) };
+            }
+            catch (error) {
+                msg = { id, error, properties: extractProperties(error) };
+            }
+            workerPort.off('message', handleAbortMessage);
+            if (isAborted) {
+                return;
+            }
+            workerPort.postMessage(msg);
+            Atomics.add(sharedBufferView, 0, 1);
+            Atomics.notify(sharedBufferView, 0);
+        }))();
+    });
+}
+
+export { createSyncFn as c, runAsWorker as r };

package/dist/node/cli.js

@@ -1,8 +1,6 @@
-import { q as getDefaultExportFromCjs, t as c, u as clearCache, l as init, b as build, n as serve, v as version, o as createServer } from './serve-4DnZ8_Si.js';
+import { t as getDefaultExportFromCjs, u as c, n as disposeMdItInstance, v as clearCache, l as init, b as build, o as serve, w as version, q as createServer } from './chunk-BGE1nmDJ.js';
 import { createLogger } from 'vite';
 import 'path';
-import 'shiki';
-import '@shikijs/transformers';
 import 'url';
 import 'crypto';
 import 'module';
@@ -33,6 +31,11 @@ import 'tty';
 import 'constants';
 import 'assert';
 import 'node:crypto';
+import '@shikijs/transformers';
+import 'node:module';
+import 'shiki';
+import './chunk-DQlKmeN_.js';
+import 'node:worker_threads';
 import 'minisearch';
 
 var minimist$1;
@@ -357,6 +360,7 @@ const SHORTCUTS = [
         clear: true,
         timestamp: true
       });
+      disposeMdItInstance();
       clearCache();
       await server.close();
       await createDevServer();

package/dist/node/index.d.ts

@@ -2164,7 +2164,7 @@ interface MarkdownOptions extends Options$2 {
      */
     container?: ContainerOptions;
     /**
-     * Math support (experimental)
+     * Math support
      *
      * You need to install `markdown-it-mathjax3` and set `math` to `true` to enable it.
      * You can also pass options to `markdown-it-mathjax3` here.
@@ -2181,7 +2181,11 @@ interface MarkdownOptions extends Options$2 {
     gfmAlerts?: boolean;
 }
 type MarkdownRenderer = MarkdownIt;
-declare const createMarkdownRenderer: (srcDir: string, options?: MarkdownOptions, base?: string, logger?: Pick<Logger, "warn">) => Promise<MarkdownRenderer>;
+declare function disposeMdItInstance(): void;
+/**
+ * @experimental
+ */
+declare function createMarkdownRenderer(srcDir: string, options?: MarkdownOptions, base?: string, logger?: Pick<Logger, 'warn'>): Promise<MarkdownRenderer>;
 
 type RawConfigExports<ThemeConfig = any> = Awaitable<UserConfig<ThemeConfig>> | (() => Awaitable<UserConfig<ThemeConfig>>);
 interface TransformContext {
@@ -2608,4 +2612,4 @@ declare function createServer(root?: string, serverOptions?: ServerOptions & {
     base?: string;
 }, recreateServer?: () => Promise<void>): Promise<vite.ViteDevServer>;
 
-export { type ContentData, type ContentOptions, type LoaderModule, type MarkdownOptions, type MarkdownRenderer, type RawConfigExports, type ResolvedRouteConfig, type ScaffoldOptions, ScaffoldThemeType, type ServeOptions, type SiteConfig, type ThemeOptions, type TransformContext, type TransformPageContext, type UserConfig, type UserConfigExport, type UserConfigFn, build, createContentLoader, createMarkdownRenderer, createServer, defineConfig, defineConfigWithTheme, defineLoader, init, mergeConfig, postcssIsolateStyles, resolveConfig, resolvePages, resolveSiteData, resolveUserConfig, scaffold, serve };
+export { type ContentData, type ContentOptions, type LoaderModule, type MarkdownOptions, type MarkdownRenderer, type RawConfigExports, type ResolvedRouteConfig, type ScaffoldOptions, ScaffoldThemeType, type ServeOptions, type SiteConfig, type ThemeOptions, type TransformContext, type TransformPageContext, type UserConfig, type UserConfigExport, type UserConfigFn, build, createContentLoader, createMarkdownRenderer, createServer, defineConfig, defineConfigWithTheme, defineLoader, disposeMdItInstance, init, mergeConfig, postcssIsolateStyles, resolveConfig, resolvePages, resolveSiteData, resolveUserConfig, scaffold, serve };

package/dist/node/index.js

@@ -1,7 +1,7 @@
 import { normalizePath } from 'vite';
 export { loadEnv } from 'vite';
-import { g as glob, c as createMarkdownRenderer, f as fs, m as matter, p as postcssPrefixSelector } from './serve-4DnZ8_Si.js';
-export { S as ScaffoldThemeType, b as build, o as createServer, a as defineConfig, e as defineConfigWithTheme, d as defineLoader, l as init, i as mergeConfig, r as resolveConfig, k as resolvePages, j as resolveSiteData, h as resolveUserConfig, s as scaffold, n as serve } from './serve-4DnZ8_Si.js';
+import { g as glob, c as createMarkdownRenderer, f as fs, m as matter, p as postcssPrefixSelector } from './chunk-BGE1nmDJ.js';
+export { S as ScaffoldThemeType, b as build, q as createServer, a as defineConfig, e as defineConfigWithTheme, d as defineLoader, n as disposeMdItInstance, l as init, i as mergeConfig, r as resolveConfig, k as resolvePages, j as resolveSiteData, h as resolveUserConfig, s as scaffold, o as serve } from './chunk-BGE1nmDJ.js';
 import path from 'path';
 import 'crypto';
 import 'module';
@@ -33,8 +33,11 @@ import 'tty';
 import 'constants';
 import 'assert';
 import 'node:crypto';
-import 'shiki';
 import '@shikijs/transformers';
+import 'node:module';
+import 'shiki';
+import './chunk-DQlKmeN_.js';
+import 'node:worker_threads';
 import 'minisearch';
 
 function createContentLoader(pattern, {
@@ -52,7 +55,6 @@ function createContentLoader(pattern, {
   }
   if (typeof pattern === "string") pattern = [pattern];
   pattern = pattern.map((p) => normalizePath(path.join(config.srcDir, p)));
-  let md;
   const cache = /* @__PURE__ */ new Map();
   return {
     watch: pattern,
@@ -64,7 +66,7 @@ function createContentLoader(pattern, {
           ...globOptions
         })).sort();
       }
-      md = md || await createMarkdownRenderer(
+      const md = await createMarkdownRenderer(
         config.srcDir,
         config.markdown,
         config.site.base,

package/dist/node/worker_shikiResolveLang.js

@@ -0,0 +1,13 @@
+import { bundledLanguages } from 'shiki';
+import { r as runAsWorker } from './chunk-DQlKmeN_.js';
+import 'node:crypto';
+import 'node:fs';
+import 'node:module';
+import 'node:path';
+import 'node:url';
+import 'node:worker_threads';
+
+async function resolveLang(lang) {
+  return bundledLanguages[lang]?.().then((m) => m.default) || [];
+}
+runAsWorker(resolveLang);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitepress",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Vite & Vue powered static site generator",
   "keywords": [
     "vite",
@@ -62,20 +62,20 @@
   "dependencies": {
     "@docsearch/css": "^3.6.2",
     "@docsearch/js": "^3.6.2",
-    "@shikijs/core": "^1.22.0",
-    "@shikijs/transformers": "^1.22.0",
-    "@shikijs/types": "^1.22.0",
+    "@shikijs/core": "^1.22.2",
+    "@shikijs/transformers": "^1.22.2",
+    "@shikijs/types": "^1.22.2",
     "@types/markdown-it": "^14.1.2",
     "@vitejs/plugin-vue": "^5.1.4",
-    "@vue/devtools-api": "^7.4.6",
+    "@vue/devtools-api": "^7.5.4",
     "@vue/shared": "^3.5.12",
     "@vueuse/core": "^11.1.0",
     "@vueuse/integrations": "^11.1.0",
     "focus-trap": "^7.6.0",
     "mark.js": "8.11.1",
     "minisearch": "^7.1.0",
-    "shiki": "^1.22.0",
-    "vite": "^5.4.8",
+    "shiki": "^1.22.2",
+    "vite": "^5.4.10",
     "vue": "^3.5.12"
   },
   "devDependencies": {
@@ -89,7 +89,7 @@
     "@mdit-vue/shared": "^2.1.3",
     "@polka/compression": "^1.0.0-next.28",
     "@rollup/plugin-alias": "^5.1.1",
-    "@rollup/plugin-commonjs": "^28.0.0",
+    "@rollup/plugin-commonjs": "^28.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.3.0",
     "@rollup/plugin-replace": "^6.0.1",
@@ -103,7 +103,7 @@
     "@types/markdown-it-emoji": "^3.0.1",
     "@types/micromatch": "^4.0.9",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^22.7.5",
+    "@types/node": "^22.8.2",
     "@types/postcss-prefix-selector": "^1.16.3",
     "@types/prompts": "^2.4.9",
     "chokidar": "^3.6.0",
@@ -111,7 +111,7 @@
     "cross-spawn": "^7.0.3",
     "debug": "^4.3.7",
     "esbuild": "^0.24.0",
-    "execa": "^9.4.0",
+    "execa": "^9.5.1",
     "fs-extra": "^11.2.0",
     "get-port": "^7.1.0",
     "gray-matter": "^4.0.3",
@@ -126,20 +126,20 @@
     "markdown-it-mathjax3": "^4.3.2",
     "micromatch": "^4.0.8",
     "minimist": "^1.2.8",
-    "nanoid": "^5.0.7",
+    "nanoid": "^5.0.8",
     "ora": "^8.1.0",
     "p-map": "^7.0.2",
     "path-to-regexp": "^6.3.0",
-    "picocolors": "^1.1.0",
+    "picocolors": "^1.1.1",
     "pkg-dir": "^8.0.0",
-    "playwright-chromium": "^1.48.0",
+    "playwright-chromium": "^1.48.2",
     "polka": "^1.0.0-next.28",
     "postcss-prefix-selector": "^2.1.0",
     "prettier": "^3.3.3",
     "prompts": "^2.4.2",
     "punycode": "^2.3.1",
     "rimraf": "^6.0.1",
-    "rollup": "^4.24.0",
+    "rollup": "^4.24.2",
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-esbuild": "^6.1.1",
     "semver": "^7.6.3",
@@ -147,10 +147,11 @@
     "sirv": "^3.0.0",
     "sitemap": "^8.0.0",
     "supports-color": "^9.4.0",
-    "tinyglobby": "^0.2.9",
+    "synckit": "^0.9.2",
+    "tinyglobby": "^0.2.10",
     "typescript": "^5.6.3",
-    "vitest": "^2.1.2",
-    "vue-tsc": "^2.1.6",
+    "vitest": "^2.1.4",
+    "vue-tsc": "^2.1.8",
     "wait-on": "^8.0.1"
   },
   "peerDependencies": {