vitepress 1.2.3 → 1.3.1

package/dist/node/cli.js

@@ -1,4 +1,4 @@
-import { a as getDefaultExportFromCjs, q as c, t as clearCache, n as init, b as build, o as serve, v as version, p as createServer } from './serve-CEEKiiuH.js';
+import { a as getDefaultExportFromCjs, q as c, t as clearCache, n as init, b as build, o as serve, v as version, p as createServer } from './serve-oY-f4fXJ.js';
 import { createLogger } from 'vite';
 import 'path';
 import 'shiki';
@@ -401,7 +401,7 @@ if (!command || command === "dev") {
     delete argv.force;
     argv.optimizeDeps = { force: true };
   }
-  const createDevServer = async () => {
+  const createDevServer = async (isRestart = true) => {
     const server = await createServer(root, argv, async () => {
       if (!restartPromise) {
         restartPromise = (async () => {
@@ -413,12 +413,12 @@ if (!command || command === "dev") {
       }
       return restartPromise;
     });
-    await server.listen();
+    await server.listen(void 0, isRestart);
     logVersion(server.config.logger);
     server.printUrls();
     bindShortcuts(server, createDevServer);
   };
-  createDevServer().catch((err) => {
+  createDevServer(false).catch((err) => {
     createLogger().error(
       `${c.red(`failed to start server. error:`)}
 ${err.message}
@@ -428,7 +428,7 @@ ${err.stack}`
   });
 } else if (command === "init") {
   createLogger().info("", { clear: true });
-  init();
+  init(argv.root);
 } else {
   logVersion();
   if (command === "build") {

package/dist/node/index.d.ts

@@ -2179,7 +2179,7 @@ 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 const 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 {
@@ -2227,7 +2227,7 @@ interface UserConfig<ThemeConfig = any> extends LocaleSpecificConfig<ThemeConfig
     router?: {
         prefetchLinks?: boolean;
     };
-    appearance?: boolean | 'dark' | 'force-dark' | (Omit<UseDarkOptions, 'initialValue'> & {
+    appearance?: boolean | 'dark' | 'force-dark' | 'force-auto' | (Omit<UseDarkOptions, 'initialValue'> & {
         initialValue?: 'dark';
     });
     lastUpdated?: boolean;
@@ -2464,7 +2464,7 @@ interface ScaffoldOptions {
     useTs: boolean;
     injectNpmScripts: boolean;
 }
-declare function init(): Promise<void>;
+declare function init(root: string | undefined): Promise<void>;
 declare function scaffold({ root, title, description, theme, useTs, injectNpmScripts }: ScaffoldOptions): string;
 
 interface LoaderModule {

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, a as getDefaultExportFromCjs } from './serve-CEEKiiuH.js';
-export { S as ScaffoldThemeType, b as build, p as createServer, e as defineConfig, h as defineConfigWithTheme, d as defineLoader, n as init, j as mergeConfig, r as resolveConfig, l as resolvePages, k as resolveSiteData, i as resolveUserConfig, s as scaffold, o as serve } from './serve-CEEKiiuH.js';
+import { g as glob, c as createMarkdownRenderer, f as fs, m as matter, a as getDefaultExportFromCjs } from './serve-oY-f4fXJ.js';
+export { S as ScaffoldThemeType, b as build, p as createServer, e as defineConfig, h as defineConfigWithTheme, d as defineLoader, n as init, j as mergeConfig, r as resolveConfig, l as resolvePages, k as resolveSiteData, i as resolveUserConfig, s as scaffold, o as serve } from './serve-oY-f4fXJ.js';
 import path from 'path';
 import 'crypto';
 import 'module';

package/dist/node/{serve-CEEKiiuH.js → serve-oY-f4fXJ.js}

@@ -4268,10 +4268,11 @@ class Minimatch {
         for (let i = 0; i < globParts.length - 1; i++) {
             for (let j = i + 1; j < globParts.length; j++) {
                 const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-                if (!matched)
-                    continue;
-                globParts[i] = matched;
-                globParts[j] = [];
+                if (matched) {
+                    globParts[i] = [];
+                    globParts[j] = matched;
+                    break;
+                }
             }
         }
         return globParts.filter(gs => gs.length);
@@ -4871,21 +4872,26 @@ class Stack {
 /**
  * Default export, the thing you're using this module to get.
  *
- * All properties from the options object (with the exception of
- * {@link OptionsBase.max} and {@link OptionsBase.maxSize}) are added as
- * normal public members. (`max` and `maxBase` are read-only getters.)
- * Changing any of these will alter the defaults for subsequent method calls,
- * but is otherwise safe.
+ * The `K` and `V` types define the key and value types, respectively. The
+ * optional `FC` type defines the type of the `context` object passed to
+ * `cache.fetch()` and `cache.memo()`.
+ *
+ * Keys and values **must not** be `null` or `undefined`.
+ *
+ * All properties from the options object (with the exception of `max`,
+ * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are
+ * added as normal public members. (The listed options are read-only getters.)
+ *
+ * Changing any of these will alter the defaults for subsequent method calls.
  */
 class LRUCache {
-    // properties coming in from the options of these, only max and maxSize
-    // really *need* to be protected. The rest can be modified, as they just
-    // set defaults for various methods.
+    // options that cannot be changed without disaster
     #max;
     #maxSize;
     #dispose;
     #disposeAfter;
     #fetchMethod;
+    #memoMethod;
     /**
      * {@link LRUCache.OptionsBase.ttl}
      */
@@ -5031,6 +5037,9 @@ class LRUCache {
     get fetchMethod() {
         return this.#fetchMethod;
     }
+    get memoMethod() {
+        return this.#memoMethod;
+    }
     /**
      * {@link LRUCache.OptionsBase.dispose} (read-only)
      */
@@ -5044,7 +5053,7 @@ class LRUCache {
         return this.#disposeAfter;
     }
     constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
         if (max !== 0 && !isPosInt(max)) {
             throw new TypeError('max option must be a nonnegative integer');
         }
@@ -5064,6 +5073,11 @@ class LRUCache {
                 throw new TypeError('sizeCalculation set to non-function');
             }
         }
+        if (memoMethod !== undefined &&
+            typeof memoMethod !== 'function') {
+            throw new TypeError('memoMethod must be a function if defined');
+        }
+        this.#memoMethod = memoMethod;
         if (fetchMethod !== undefined &&
             typeof fetchMethod !== 'function') {
             throw new TypeError('fetchMethod must be a function if specified');
@@ -5142,7 +5156,8 @@ class LRUCache {
         }
     }
     /**
-     * Return the remaining TTL time for a given entry key
+     * Return the number of ms left in the item's TTL. If item is not in cache,
+     * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
      */
     getRemainingTTL(key) {
         return this.#keyMap.has(key) ? Infinity : 0;
@@ -5158,7 +5173,7 @@ class LRUCache {
             if (ttl !== 0 && this.ttlAutopurge) {
                 const t = setTimeout(() => {
                     if (this.#isStale(index)) {
-                        this.delete(this.#keyList[index]);
+                        this.#delete(this.#keyList[index], 'expire');
                     }
                 }, ttl + 1);
                 // unref() not supported on all platforms
@@ -5415,13 +5430,14 @@ class LRUCache {
         return this.entries();
     }
     /**
-     * A String value that is used in the creation of the default string description of an object.
-     * Called by the built-in method Object.prototype.toString.
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
      */
     [Symbol.toStringTag] = 'LRUCache';
     /**
      * Find a value for which the supplied fn method returns a truthy value,
-     * similar to Array.find().  fn is called as fn(value, key, cache).
+     * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
      */
     find(fn, getOptions = {}) {
         for (const i of this.#indexes()) {
@@ -5437,10 +5453,15 @@ class LRUCache {
         }
     }
     /**
-     * Call the supplied function on each item in the cache, in order from
-     * most recently used to least recently used.  fn is called as
-     * fn(value, key, cache).  Does not update age or recenty of use.
-     * Does not iterate over stale values.
+     * Call the supplied function on each item in the cache, in order from most
+     * recently used to least recently used.
+     *
+     * `fn` is called as `fn(value, key, cache)`.
+     *
+     * If `thisp` is provided, function will be called in the `this`-context of
+     * the provided object, or the cache if no `thisp` object is provided.
+     *
+     * Does not update age or recenty of use, or iterate over stale values.
      */
     forEach(fn, thisp = this) {
         for (const i of this.#indexes()) {
@@ -5476,7 +5497,7 @@ class LRUCache {
         let deleted = false;
         for (const i of this.#rindexes({ allowStale: true })) {
             if (this.#isStale(i)) {
-                this.delete(this.#keyList[i]);
+                this.#delete(this.#keyList[i], 'expire');
                 deleted = true;
             }
         }
@@ -5484,9 +5505,15 @@ class LRUCache {
     }
     /**
      * Get the extended info about a given entry, to get its value, size, and
-     * TTL info simultaneously. Like {@link LRUCache#dump}, but just for a
-     * single key. Always returns stale values, if their info is found in the
-     * cache, so be sure to check for expired TTLs if relevant.
+     * TTL info simultaneously. Returns `undefined` if the key is not present.
+     *
+     * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+     * serialization, the `start` value is always the current timestamp, and the
+     * `ttl` is a calculated remaining time to live (negative if expired).
+     *
+     * Always returns stale values, if their info is found in the cache, so be
+     * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+     * if relevant.
      */
     info(key) {
         const i = this.#keyMap.get(key);
@@ -5515,7 +5542,16 @@ class LRUCache {
     }
     /**
      * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-     * passed to cache.load()
+     * passed to {@link LRLUCache#load}.
+     *
+     * The `start` fields are calculated relative to a portable `Date.now()`
+     * timestamp, even if `performance.now()` is available.
+     *
+     * Stale entries are always included in the `dump`, even if
+     * {@link LRUCache.OptionsBase.allowStale} is false.
+     *
+     * Note: this returns an actual array, not a generator, so it can be more
+     * easily passed around.
      */
     dump() {
         const arr = [];
@@ -5544,8 +5580,12 @@ class LRUCache {
     }
     /**
      * Reset the cache and load in the items in entries in the order listed.
-     * Note that the shape of the resulting cache may be different if the
-     * same options are not used in both caches.
+     *
+     * The shape of the resulting cache may be different if the same options are
+     * not used in both caches.
+     *
+     * The `start` fields are assumed to be calculated relative to a portable
+     * `Date.now()` timestamp, even if `performance.now()` is available.
      */
     load(arr) {
         this.clear();
@@ -5568,6 +5608,30 @@ class LRUCache {
      *
      * Note: if `undefined` is specified as a value, this is an alias for
      * {@link LRUCache#delete}
+     *
+     * Fields on the {@link LRUCache.SetOptions} options param will override
+     * their corresponding values in the constructor options for the scope
+     * of this single `set()` operation.
+     *
+     * If `start` is provided, then that will set the effective start
+     * time for the TTL calculation. Note that this must be a previous
+     * value of `performance.now()` if supported, or a previous value of
+     * `Date.now()` if not.
+     *
+     * Options object may also include `size`, which will prevent
+     * calling the `sizeCalculation` function and just use the specified
+     * number if it is a positive integer, and `noDisposeOnSet` which
+     * will prevent calling a `dispose` function in the case of
+     * overwrites.
+     *
+     * If the `size` (or return value of `sizeCalculation`) for a given
+     * entry is greater than `maxEntrySize`, then the item will not be
+     * added to the cache.
+     *
+     * Will update the recency of the entry.
+     *
+     * If the value is `undefined`, then this is an alias for
+     * `cache.delete(key)`. `undefined` is never stored in the cache.
      */
     set(k, v, setOptions = {}) {
         if (v === undefined) {
@@ -5585,7 +5649,7 @@ class LRUCache {
                 status.maxEntrySizeExceeded = true;
             }
             // have to delete, in case something is there already.
-            this.delete(k);
+            this.#delete(k, 'set');
             return this;
         }
         let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
@@ -5737,6 +5801,14 @@ class LRUCache {
      * Will return false if the item is stale, even though it is technically
      * in the cache.
      *
+     * Check if a key is in the cache, without updating the recency of
+     * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+     * to `true` in either the options or the constructor.
+     *
+     * Will return `false` if the item is stale, even though it is technically in
+     * the cache. The difference can be determined (if it matters) by using a
+     * `status` argument, and inspecting the `has` field.
+     *
      * Will not update item age unless
      * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
      */
@@ -5828,7 +5900,7 @@ class LRUCache {
                         this.#valList[index] = bf.__staleWhileFetching;
                     }
                     else {
-                        this.delete(k);
+                        this.#delete(k, 'fetch');
                     }
                 }
                 else {
@@ -5857,7 +5929,7 @@ class LRUCache {
                 // the stale value is not removed from the cache when the fetch fails.
                 const del = !noDelete || bf.__staleWhileFetching === undefined;
                 if (del) {
-                    this.delete(k);
+                    this.#delete(k, 'fetch');
                 }
                 else if (!allowStaleAborted) {
                     // still replace the *promise* with the stale value,
@@ -6003,6 +6075,28 @@ class LRUCache {
             return staleVal ? p.__staleWhileFetching : (p.__returned = p);
         }
     }
+    async forceFetch(k, fetchOptions = {}) {
+        const v = await this.fetch(k, fetchOptions);
+        if (v === undefined)
+            throw new Error('fetch() returned undefined');
+        return v;
+    }
+    memo(k, memoOptions = {}) {
+        const memoMethod = this.#memoMethod;
+        if (!memoMethod) {
+            throw new Error('no memoMethod provided to constructor');
+        }
+        const { context, forceRefresh, ...options } = memoOptions;
+        const v = this.get(k, options);
+        if (!forceRefresh && v !== undefined)
+            return v;
+        const vv = memoMethod(k, v, {
+            options,
+            context,
+        });
+        this.set(k, vv, options);
+        return vv;
+    }
     /**
      * Return a value from the cache. Will update the recency of the cache
      * entry found.
@@ -6023,7 +6117,7 @@ class LRUCache {
                 // delete only if not an in-flight background fetch
                 if (!fetching) {
                     if (!noDeleteOnStaleGet) {
-                        this.delete(k);
+                        this.#delete(k, 'expire');
                     }
                     if (status && allowStale)
                         status.returnedStale = true;
@@ -6086,16 +6180,20 @@ class LRUCache {
     }
     /**
      * Deletes a key out of the cache.
+     *
      * Returns true if the key was deleted, false otherwise.
      */
     delete(k) {
+        return this.#delete(k, 'delete');
+    }
+    #delete(k, reason) {
         let deleted = false;
         if (this.#size !== 0) {
             const index = this.#keyMap.get(k);
             if (index !== undefined) {
                 deleted = true;
                 if (this.#size === 1) {
-                    this.clear();
+                    this.#clear(reason);
                 }
                 else {
                     this.#removeItemSize(index);
@@ -6105,10 +6203,10 @@ class LRUCache {
                     }
                     else if (this.#hasDispose || this.#hasDisposeAfter) {
                         if (this.#hasDispose) {
-                            this.#dispose?.(v, k, 'delete');
+                            this.#dispose?.(v, k, reason);
                         }
                         if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([v, k, 'delete']);
+                            this.#disposed?.push([v, k, reason]);
                         }
                     }
                     this.#keyMap.delete(k);
@@ -6144,6 +6242,9 @@ class LRUCache {
      * Clear the cache entirely, throwing away all values.
      */
     clear() {
+        return this.#clear('delete');
+    }
+    #clear(reason) {
         for (const index of this.#rindexes({ allowStale: true })) {
             const v = this.#valList[index];
             if (this.#isBackgroundFetch(v)) {
@@ -6152,10 +6253,10 @@ class LRUCache {
             else {
                 const k = this.#keyList[index];
                 if (this.#hasDispose) {
-                    this.#dispose?.(v, k, 'delete');
+                    this.#dispose?.(v, k, reason);
                 }
                 if (this.#hasDisposeAfter) {
-                    this.#disposed?.push([v, k, 'delete']);
+                    this.#disposed?.push([v, k, reason]);
                 }
             }
         }
@@ -7466,6 +7567,8 @@ class PathBase {
     /**
      * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
      * this property refers to the *parent* path, not the path object itself.
+     *
+     * @deprecated
      */
     get path() {
         return this.parentPath;
@@ -20142,12 +20245,15 @@ function resolveSiteDataHead(userConfig) {
     head.push([
       "script",
       { id: "check-dark-mode" },
-      fallbackPreference === "force-dark" ? `document.documentElement.classList.add('dark')` : `;(() => {
-            const preference = localStorage.getItem('${APPEARANCE_KEY}') || '${fallbackPreference}'
-            const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches
-            if (!preference || preference === 'auto' ? prefersDark : preference === 'dark')
-              document.documentElement.classList.add('dark')
-          })()`
+      fallbackPreference === "force-dark" ? `document.documentElement.classList.add('dark')` : fallbackPreference === "force-auto" ? `;(() => {
+               if (window.matchMedia('(prefers-color-scheme: dark)').matches)
+                 document.documentElement.classList.add('dark')
+             })()` : `;(() => {
+               const preference = localStorage.getItem('${APPEARANCE_KEY}') || '${fallbackPreference}'
+               const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches
+               if (!preference || preference === 'auto' ? prefersDark : preference === 'dark')
+                 document.documentElement.classList.add('dark')
+             })()`
     ]);
   }
   head.push([
@@ -37325,7 +37431,9 @@ const linkPlugin = (md, externalAttrs, base) => {
   md.renderer.rules.link_open = (tokens, idx, options, env, self) => {
     const token = tokens[idx];
     const hrefIndex = token.attrIndex("href");
-    if (hrefIndex >= 0) {
+    const targetIndex = token.attrIndex("target");
+    const downloadIndex = token.attrIndex("download");
+    if (hrefIndex >= 0 && targetIndex < 0 && downloadIndex < 0) {
       const hrefAttr = token.attrs[hrefIndex];
       const url = hrefAttr[1];
       if (isExternal(url)) {
@@ -38260,13 +38368,13 @@ const cache$2 = /* @__PURE__ */ new Map();
 function getGitTimestamp(file) {
   const cached = cache$2.get(file);
   if (cached) return cached;
+  if (!fs$a.existsSync(file)) return 0;
   return new Promise((resolve, reject) => {
-    const cwd = dirname(file);
-    if (!fs$a.existsSync(cwd)) return resolve(0);
-    const fileName = basename(file);
-    const child = spawn_1("git", ["log", "-1", '--pretty="%ai"', fileName], {
-      cwd
-    });
+    const child = spawn_1(
+      "git",
+      ["log", "-1", '--pretty="%ai"', basename(file)],
+      { cwd: dirname(file) }
+    );
     let output = "";
     child.stdout.on("data", (d) => output += String(d));
     child.on("close", () => {
@@ -38280,15 +38388,27 @@ function getGitTimestamp(file) {
 
 function processIncludes(srcDir, src, file, includes) {
   const includesRE = /<!--\s*@include:\s*(.*?)\s*-->/g;
+  const regionRE = /(#[\w-]+)/;
   const rangeRE = /\{(\d*),(\d*)\}$/;
   return src.replace(includesRE, (m, m1) => {
     if (!m1.length) return m;
     const range = m1.match(rangeRE);
-    range && (m1 = m1.slice(0, -range[0].length));
+    const region = m1.match(regionRE);
+    const hasMeta = !!(region || range);
+    if (hasMeta) {
+      const len = (region?.[0].length || 0) + (range?.[0].length || 0);
+      m1 = m1.slice(0, -len);
+    }
     const atPresent = m1[0] === "@";
     try {
       const includePath = atPresent ? path$q.join(srcDir, m1.slice(m1[1] === "/" ? 2 : 1)) : path$q.join(path$q.dirname(file), m1);
       let content = fs$a.readFileSync(includePath, "utf-8");
+      if (region) {
+        const [regionName] = region;
+        const lines = content.split(/\r?\n/);
+        const regionLines = findRegion(lines, regionName.slice(1));
+        content = lines.slice(regionLines?.start, regionLines?.end).join("\n");
+      }
       if (range) {
         const [, startLine, endLine] = range;
         const lines = content.split(/\r?\n/);
@@ -38296,12 +38416,17 @@ function processIncludes(srcDir, src, file, includes) {
           startLine ? parseInt(startLine, 10) - 1 : void 0,
           endLine ? parseInt(endLine, 10) : void 0
         ).join("\n");
-      } else {
+      }
+      if (!hasMeta && path$q.extname(includePath) === ".md") {
         content = matter$1(content).content;
       }
       includes.push(slash(includePath));
       return processIncludes(srcDir, content, includePath, includes);
     } catch (error) {
+      if (process.env.DEBUG) {
+        process.stderr.write(c$1.yellow(`
+Include file not found: ${m1}`));
+      }
       return m;
     }
   });
@@ -38422,8 +38547,12 @@ async function createMarkdownToVueRenderFn(srcDir, options = {}, pages, isBuild
       relativePath,
       filePath: slash(path$q.relative(srcDir, fileOrig))
     };
-    if (includeLastUpdatedData) {
-      pageData.lastUpdated = await getGitTimestamp(fileOrig);
+    if (includeLastUpdatedData && frontmatter.lastUpdated !== false) {
+      if (frontmatter.lastUpdated instanceof Date) {
+        pageData.lastUpdated = +frontmatter.lastUpdated;
+      } else {
+        pageData.lastUpdated = await getGitTimestamp(fileOrig);
+      }
     }
     if (siteConfig?.transformPageData) {
       const dataToMerge = await siteConfig.transformPageData(pageData, {
@@ -42789,7 +42918,11 @@ async function bundle(config, options) {
       clientResult = await buildMPAClient(clientJSMap, config);
     }
   }
-  return { clientResult, serverResult, pageToHashMap };
+  const sortedPageToHashMap = /* @__PURE__ */ Object.create(null);
+  Object.keys(pageToHashMap).sort().forEach((key) => {
+    sortedPageToHashMap[key] = pageToHashMap[key];
+  });
+  return { clientResult, serverResult, pageToHashMap: sortedPageToHashMap };
 }
 const cache = /* @__PURE__ */ new Map();
 const cacheTheme = /* @__PURE__ */ new Map();
@@ -46656,6 +46789,10 @@ async function generateSitemap(siteConfig) {
     file = file.replace(/(\.html)?$/, ".md");
     file = siteConfig.rewrites.inv[file] || file;
     file = path$q.join(siteConfig.srcDir, file);
+    if (!fs$a.existsSync(file)) return void 0;
+    const { data } = matter$1.read(file);
+    if (data.lastUpdated === false) return void 0;
+    if (data.lastUpdated instanceof Date) return +data.lastUpdated;
     return await getGitTimestamp(file) || void 0;
   };
   await task("generating sitemap", async () => {
@@ -46699,7 +46836,7 @@ async function generateSitemap(siteConfig) {
   });
 }
 
-var version = "1.2.3";
+var version = "1.3.1";
 
 async function renderPage(render, config, page, result, appChunk, cssChunk, assets, pageToHashMap, metadataScript, additionalHeadTags) {
   const routePath = `/${page.replace(/\.md$/, "")}`;
@@ -49192,16 +49329,19 @@ const getPackageManger = () => {
   const name = process.env?.npm_config_user_agent || "npm";
   return name.split("/")[0];
 };
-async function init() {
+async function init(root) {
   oe(picocolorsExports.bold(picocolorsExports.cyan("Welcome to VitePress!")));
   const options = await he(
     {
-      root: () => te({
-        message: "Where should VitePress initialize the config?",
-        initialValue: "./",
-        validate(value) {
-        }
-      }),
+      root: async () => {
+        if (root) return root;
+        return te({
+          message: "Where should VitePress initialize the config?",
+          initialValue: "./",
+          validate(value) {
+          }
+        });
+      },
       title: () => te({
         message: "Site title:",
         placeholder: "My Awesome Project"