@vivliostyle/cli 9.8.4 → 10.0.0

package/dist/{chunk-PPI5DA75.js → chunk-YN3JNBNT.js}

@@ -1,15 +1,19 @@
-import {
-  importNodeModule
-} from "./chunk-FXUEYQRY.js";
 import {
   DetailError,
+  GlobMatcher,
   Logger,
   assertPubManifestSchema,
   cwd,
   debounce,
+  detectBrowserPlatform,
+  getAssetMatcher,
+  getCacheDir,
+  getDefaultBrowserTag,
   getDefaultEpubOpfPath,
   getEpubRootDir,
   getFormattedError,
+  getOsLocale,
+  getWebPubResourceMatcher,
   isInContainer,
   isRunningOnWSL,
   isValidUri,
@@ -26,15 +30,16 @@ import {
   touchTmpFile,
   useTmpDirectory,
   writeFileIfChanged
-} from "./chunk-MDTA37GZ.js";
+} from "./chunk-MQYXBSRJ.js";
 import {
   VivliostyleConfigSchema
-} from "./chunk-YUYXQJDY.js";
+} from "./chunk-IIKRNYAM.js";
 import {
   CONTAINER_LOCAL_HOSTNAME,
   CONTAINER_URL,
   COVER_HTML_FILENAME,
   COVER_HTML_IMAGE_ALT,
+  DEFAULT_BROWSER_VERSIONS,
   EMPTY_DATA_URI,
   EPUB_CONTAINER_XML,
   EPUB_LANDMARKS_COVER_ENTRY,
@@ -49,7 +54,10 @@ import {
   XML_DECLARATION,
   cliVersion,
   viewerRoot
-} from "./chunk-4IIM6RSG.js";
+} from "./chunk-ZKEIYNLT.js";
+import {
+  importNodeModule
+} from "./chunk-ZIK6DINS.js";
 import {
   __callDispose,
   __using
@@ -180,7 +188,7 @@ function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
     renderMode,
     preflight,
     preflightOption,
-    vite,
+    vite: vite5,
     viteConfigFile,
     host,
     port,
@@ -202,7 +210,7 @@ function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
         viewer,
         viewerParam,
         browser,
-        vite,
+        vite: vite5,
         viteConfigFile
       }),
       output: (output?.length ? output : task.output)?.map((o) => ({
@@ -220,6 +228,11 @@ function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
     })),
     inlineOptions: {
       ...pruneObject(inlineOptions),
+      ...pruneObject({
+        renderMode,
+        preflight,
+        preflightOption
+      }),
       ...pruneObject(
         overrideInlineOptions
       )
@@ -228,7 +241,10 @@ function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
 }
 
 // src/config/resolve.ts
-import { VFM } from "@vivliostyle/vfm";
+import {
+  readMetadata,
+  VFM
+} from "@vivliostyle/vfm";
 import { lookup as mime } from "mime-types";
 import fs3 from "node:fs";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
@@ -236,38 +252,31 @@ import npa from "npm-package-arg";
 import upath2 from "upath";
 
 // src/processor/markdown.ts
-import {
-  readMetadata
-} from "@vivliostyle/vfm";
 import fs2 from "node:fs";
 import vfile from "vfile";
-function safeReadMetadata(content) {
-  try {
-    return readMetadata(content);
-  } catch {
-    return {};
-  }
-}
-async function processMarkdown(documentProcessorFactory, filepath, options = {}) {
+async function processMarkdown(documentProcessorFactory, documentMetadataReader, filepath, options = {}) {
   const markdownString = fs2.readFileSync(filepath, "utf8");
   const processor = documentProcessorFactory(
     options,
-    safeReadMetadata(markdownString)
+    documentMetadataReader(markdownString)
   );
   const processed = await processor.process(
     vfile({ path: filepath, contents: markdownString })
   );
   return processed;
 }
-function readMarkdownMetadata(filepath) {
-  return safeReadMetadata(fs2.readFileSync(filepath, "utf8"));
+function readMarkdownMetadata(filepath, documentMetadataReader) {
+  return documentMetadataReader(fs2.readFileSync(filepath, "utf8"));
 }
 
 // src/config/resolve.ts
 var manuscriptMediaTypes = [
   "text/markdown",
   "text/html",
-  "application/xhtml+xml"
+  "text/plain",
+  "application/xhtml+xml",
+  // a special MIME type indicates that a custom processor is used
+  "text/x-vivliostyle-custom"
 ];
 var UseTemporaryServerRoot = Symbol("UseTemporaryServerRoot");
 var DEFAULT_ASSET_EXTENSIONS = [
@@ -288,6 +297,17 @@ var DEFAULT_ASSET_EXTENSIONS = [
 function isManuscriptMediaType(mediaType) {
   return !!(mediaType && manuscriptMediaTypes.includes(mediaType));
 }
+var htmlExtensions = [".html", ".htm", ".xhtml", ".xht"];
+function toHtmlExtension(filename) {
+  const ext = upath2.extname(filename).toLowerCase();
+  if (htmlExtensions.includes(
+    // @ts-expect-error check membership
+    ext
+  )) {
+    return filename;
+  }
+  return `${filename.slice(0, -ext.length)}.html`;
+}
 function isWebPubConfig(config) {
   return config.viewerInput.type === "webpub";
 }
@@ -377,13 +397,14 @@ function parseFileMetadata({
   contentType,
   sourcePath,
   workspaceDir,
-  themesDir
+  themesDir,
+  documentMetadataReader
 }) {
   const sourceDir = upath2.dirname(sourcePath);
   let title;
   let themes;
-  if (contentType === "text/markdown") {
-    const metadata = readMarkdownMetadata(sourcePath);
+  if (documentMetadataReader) {
+    const metadata = readMarkdownMetadata(sourcePath, documentMetadataReader);
     title = metadata.title;
     if (metadata.vfm?.theme && themesDir) {
       themes = [metadata.vfm.theme].flat().filter(
@@ -397,7 +418,7 @@ function parseFileMetadata({
         })
       );
     }
-  } else {
+  } else if (contentType === "text/html" || contentType === "application/xhtml+xml") {
     const content = fs3.readFileSync(sourcePath, "utf8");
     title = content.match(/<title>([^<]*)<\/title>/)?.[1] || void 0;
   }
@@ -437,7 +458,6 @@ function resolveTaskConfig(config, options) {
   const singleDoc = options.singleDoc ?? false;
   const quick = options.quick ?? false;
   const temporaryFilePrefix = config.temporaryFilePrefix ?? `.vs-${Date.now()}.`;
-  const documentProcessorFactory = config?.documentProcessor ?? VFM;
   const vfmOptions = {
     ...config?.vfm,
     hardLineBreaks: config?.vfm?.hardLineBreaks ?? false,
@@ -445,10 +465,15 @@ function resolveTaskConfig(config, options) {
   };
   const timeout = config.timeout ?? 3e5;
   const sandbox = options.sandbox ?? false;
-  const browser = {
-    type: config.browser ?? "chromium",
-    executablePath: options.executableBrowser
-  };
+  const browser = (() => {
+    const type = config.browser?.type ?? "chrome";
+    const platform = detectBrowserPlatform();
+    return {
+      type,
+      tag: config.browser?.tag ?? (platform ? DEFAULT_BROWSER_VERSIONS[type][platform] : "latest"),
+      executablePath: options.executableBrowser
+    };
+  })();
   const proxyServer = options.proxyServer ?? process.env.HTTP_PROXY ?? void 0;
   const proxy = proxyServer ? {
     server: proxyServer,
@@ -611,7 +636,6 @@ function resolveTaskConfig(config, options) {
     quick,
     language,
     readingProgression,
-    documentProcessorFactory,
     vfmOptions,
     cover,
     timeout,
@@ -691,15 +715,22 @@ function resolveSingleInputConfig({
   const themesDir = upath2.resolve(workspaceDir, "themes");
   if (input.format === "markdown") {
     const contentType = "text/markdown";
+    const documentProcessor = {
+      processorFactory: config.documentProcessor ?? VFM,
+      metadataReader: config.documentMetadataReader ?? readMetadata
+    };
     const metadata = parseFileMetadata({
       contentType,
       sourcePath,
-      workspaceDir
-    });
-    const target = upath2.resolve(
       workspaceDir,
-      `${temporaryFilePrefix}${upath2.basename(sourcePath)}`
-    ).replace(/\.md$/, ".html");
+      documentMetadataReader: documentProcessor.metadataReader
+    });
+    const target = toHtmlExtension(
+      upath2.resolve(
+        workspaceDir,
+        `${temporaryFilePrefix}${upath2.basename(sourcePath)}`
+      )
+    );
     touchTmpFile(target);
     const themes = metadata.themes ?? config.theme?.map(
       (theme) => parseTheme({
@@ -715,7 +746,8 @@ function resolveSingleInputConfig({
       source: {
         type: "file",
         pathname: sourcePath,
-        contentType
+        contentType,
+        documentProcessor
       },
       target,
       title: metadata.title,
@@ -725,7 +757,7 @@ function resolveSingleInputConfig({
       source: target,
       target: upath2.resolve(
         upath2.dirname(target),
-        upath2.basename(sourcePath).replace(/\.md$/, ".html")
+        toHtmlExtension(upath2.basename(sourcePath))
       )
     });
   }
@@ -849,6 +881,10 @@ function resolveComposedProjectConfig({
   };
   const projectTitle = config?.title ?? pkgJson?.name;
   const projectAuthor = config?.author ?? pkgJson?.author;
+  const rootDocumentProcessor = {
+    processorFactory: config.documentProcessor ?? VFM,
+    metadataReader: config.documentMetadataReader ?? readMetadata
+  };
   const isContentsEntry = (entry) => entry.rel === "contents";
   const isCoverEntry = (entry) => entry.rel === "cover";
   const isArticleEntry = (entry) => !isContentsEntry(entry) && !isCoverEntry(entry);
@@ -869,12 +905,19 @@ function resolveComposedProjectConfig({
       }
       const pathname = upath2.resolve(entryContextDir, entryPath);
       statFileSync(pathname);
-      const contentType = mime(pathname);
-      if (!isManuscriptMediaType(contentType)) {
+      const rawContentType = mime(pathname);
+      const documentProcessor = {
+        processorFactory: "documentProcessor" in entry && entry.documentProcessor || rootDocumentProcessor.processorFactory,
+        metadataReader: "documentMetadataReader" in entry && entry.documentMetadataReader || rootDocumentProcessor.metadataReader
+      };
+      const hasCustomProcessor = !!(documentProcessor.processorFactory !== VFM || documentProcessor.metadataReader !== readMetadata);
+      const contentType = hasCustomProcessor && rawContentType !== "text/markdown" ? "text/x-vivliostyle-custom" : rawContentType;
+      if (!isManuscriptMediaType(contentType) || contentType === "text/plain") {
         throw new Error(
-          `Invalid manuscript type ${contentType} detected: ${entry}`
+          `Invalid manuscript type ${rawContentType} detected: ${entry}`
         );
       }
+      const useDocumentProcessor = contentType === "text/markdown" || contentType === "text/x-vivliostyle-custom";
       return {
         type: "file",
         pathname,
@@ -883,8 +926,10 @@ function resolveComposedProjectConfig({
           contentType,
           sourcePath: pathname,
           workspaceDir,
-          themesDir
-        })
+          themesDir,
+          documentMetadataReader: useDocumentProcessor ? documentProcessor.metadataReader : void 0
+        }),
+        ...useDocumentProcessor && { documentProcessor }
       };
     };
     const getTargetPath = (source) => {
@@ -892,7 +937,7 @@ function resolveComposedProjectConfig({
         case "file":
           return upath2.resolve(
             workspaceDir,
-            upath2.relative(entryContextDir, source.pathname).replace(/\.md$/, ".html")
+            toHtmlExtension(upath2.relative(entryContextDir, source.pathname))
           );
         case "uri": {
           const url = new URL(source.href, "a://dummy");
@@ -1065,77 +1110,211 @@ Maybe you want to set the "output" field instead.`
   };
 }
 
+// src/vite/vite-plugin-browser.ts
+import "vite";
+
 // src/browser.ts
 import fs4 from "node:fs";
+import upath3 from "upath";
+var browserEnumMap = {
+  chrome: "chrome",
+  chromium: "chromium",
+  firefox: "firefox"
+};
 async function launchBrowser({
   browserType,
   proxy,
   executablePath,
   headless,
   noSandbox,
-  disableDevShmUsage
+  disableDevShmUsage,
+  ignoreHttpsErrors
 }) {
-  const playwright = await importNodeModule("playwright-core");
-  playwright.firefox.executablePath;
-  const options = browserType === "chromium" ? {
+  const puppeteer = await importNodeModule("puppeteer-core");
+  const args = [];
+  if (browserType === "chrome" || browserType === "chromium") {
+    args.push(
+      "--disable-field-trial-config",
+      "--disable-back-forward-cache",
+      "--disable-component-update",
+      "--no-default-browser-check",
+      "--disable-features=AcceptCHFrame,AvoidUnnecessaryBeforeUnloadCheckSync,DestroyProfileOnBrowserClose,DialMediaRouteProvider,GlobalMediaControls,HttpsUpgrades,LensOverlay,MediaRouter,PaintHolding,ThirdPartyStoragePartitioning,Translate,AutoDeElevate,RenderDocument",
+      "--enable-features=CDPScreenshotNewSurface",
+      "--no-service-autorun",
+      "--unsafely-disable-devtools-self-xss-warnings",
+      "--edge-skip-compat-layer-relaunch"
+    );
+    if (process.platform === "darwin") {
+      args.push("--enable-unsafe-swiftshader");
+    }
+    if (noSandbox) {
+      args.push("--no-sandbox");
+    }
+    if (headless) {
+      args.push(
+        "--hide-scrollbars",
+        "--mute-audio",
+        "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4"
+      );
+    }
+    if (proxy?.server) {
+      const proxyURL = new URL(proxy.server);
+      const isSocks = proxyURL.protocol === "socks5:";
+      if (isSocks) {
+        args.push(
+          `--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE ${proxyURL.hostname}"`
+        );
+      }
+      args.push(`--proxy-server=${proxy.server}`);
+      const proxyBypassRules = [];
+      if (proxy.bypass) {
+        proxyBypassRules.push(
+          ...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t)
+        );
+      }
+      proxyBypassRules.push("<-loopback>");
+      args.push(`--proxy-bypass-list=${proxyBypassRules.join(";")}`);
+    }
+    args.push("--disable-web-security");
+    if (disableDevShmUsage) {
+      args.push("--disable-dev-shm-usage");
+    }
+    if (headless) {
+      args.push("--force-device-scale-factor=1");
+    }
+    if (isRunningOnWSL()) {
+      args.push("--disable-gpu");
+    }
+    args.push("--lang=en");
+    if (!headless && process.platform === "darwin") {
+      args.push("-AppleLanguages", "(en)");
+    }
+    args.push("--no-startup-window");
+  }
+  const launchOptions = {
     executablePath,
-    chromiumSandbox: !noSandbox,
+    args,
+    browser: browserType === "chromium" ? "chrome" : browserType,
     headless,
-    args: [
-      // #579: disable web security to allow cross-origin requests
-      "--disable-web-security",
-      ...disableDevShmUsage ? ["--disable-dev-shm-usage"] : [],
-      // #357: Set devicePixelRatio=1 otherwise it causes layout issues in HiDPI displays
-      ...headless ? ["--force-device-scale-factor=1"] : [],
-      // #565: Add --disable-gpu option when running on WSL
-      ...isRunningOnWSL() ? ["--disable-gpu"] : [],
-      // set Chromium language to English to avoid locale-dependent issues
-      "--lang=en",
-      ...!headless && process.platform === "darwin" ? ["", "-AppleLanguages", "(en)"] : []
-    ],
-    env: { ...process.env, LANG: "en.UTF-8" },
-    proxy
-  } : (
-    // TODO: Investigate appropriate settings on Firefox & Webkit
-    { executablePath, headless }
-  );
-  const browser = await playwright[browserType].launch(options);
+    acceptInsecureCerts: ignoreHttpsErrors,
+    waitForInitialPage: false
+  };
+  Logger.debug("launchOptions %O", launchOptions);
+  const browser = await puppeteer.launch({
+    ...launchOptions,
+    env: { ...process.env, LANG: "en.UTF-8" }
+  });
   registerExitHandler("Closing browser", () => {
     browser.close();
   });
-  return browser;
+  const [browserContext] = browser.browserContexts();
+  return { browser, browserContext };
 }
-async function getExecutableBrowserPath(browserType) {
-  const playwright = await importNodeModule("playwright-core");
-  return playwright[browserType].executablePath();
+function getPuppeteerCacheDir() {
+  if (isInContainer()) {
+    return "/opt/puppeteer";
+  }
+  return upath3.join(getCacheDir(), "browsers");
 }
-function getFullBrowserName(browserType) {
-  return {
-    chromium: "Chromium",
-    firefox: "Firefox",
-    webkit: "Webkit"
-  }[browserType];
+async function resolveBuildId({
+  type,
+  tag,
+  browsers
+}) {
+  const cacheDataFilename = upath3.join(
+    getPuppeteerCacheDir(),
+    "build-ids.json"
+  );
+  let cacheData;
+  try {
+    cacheData = JSON.parse(fs4.readFileSync(cacheDataFilename, "utf-8"));
+    if (Date.now() - cacheData.createdAt > 24 * 60 * 60 * 1e3) {
+      cacheData = { createdAt: Date.now(), buildIds: {} };
+    }
+  } catch (_) {
+    cacheData = { createdAt: Date.now(), buildIds: {} };
+  }
+  if (cacheData.buildIds[type]?.[tag]) {
+    return cacheData.buildIds[type][tag];
+  }
+  const platform = detectBrowserPlatform();
+  if (!platform) {
+    throw new Error("The current platform is not supported.");
+  }
+  const buildId = await browsers.resolveBuildId(
+    browserEnumMap[type],
+    platform,
+    tag
+  );
+  (cacheData.buildIds[type] ??= {})[tag] = buildId;
+  fs4.mkdirSync(upath3.dirname(cacheDataFilename), { recursive: true });
+  fs4.writeFileSync(cacheDataFilename, JSON.stringify(cacheData));
+  return buildId;
+}
+async function cleanupOutdatedBrowsers() {
+  for (const browser of Object.values(browserEnumMap)) {
+    const browsersDir = upath3.join(getPuppeteerCacheDir(), browser);
+    if (!fs4.existsSync(browsersDir)) {
+      continue;
+    }
+    const entries = fs4.readdirSync(browsersDir);
+    for (const entry of entries) {
+      const entryPath = upath3.join(browsersDir, entry);
+      const stat = fs4.statSync(entryPath);
+      if (!stat.isDirectory() || Date.now() - stat.mtimeMs > 7 * 24 * 60 * 60 * 1e3) {
+        Logger.debug(`Removing outdated browser at ${entryPath}`);
+        await fs4.promises.rm(entryPath, { recursive: true, force: true });
+      }
+    }
+  }
+}
+async function getExecutableBrowserPath({
+  type,
+  tag
+}) {
+  const browsers = await importNodeModule("@puppeteer/browsers");
+  const buildId = await resolveBuildId({ type, tag, browsers });
+  return browsers.computeExecutablePath({
+    cacheDir: getPuppeteerCacheDir(),
+    browser: browserEnumMap[type],
+    buildId
+  });
 }
 function checkBrowserAvailability(path) {
   return fs4.existsSync(path);
 }
-async function downloadBrowser(browserType) {
-  const { registry } = await importNodeModule("playwright-core/lib/server");
-  const executable = registry.findExecutable(browserType);
+async function downloadBrowser({
+  type,
+  tag
+}) {
+  const browsers = await importNodeModule("@puppeteer/browsers");
+  const buildId = await resolveBuildId({ type, tag, browsers });
+  let installedBrowser;
+  if (isInContainer()) {
+    const defaultBrowserVersion = getDefaultBrowserTag("chrome");
+    Logger.logWarn(
+      `The container you are using already includes a browser (chrome@${defaultBrowserVersion}); however, the specified browser ${type}@${tag} was not found. Downloading the browser inside the container may take a long time. Consider using a container image that includes the required browser version.`
+    );
+  }
   {
     var _stack = [];
     try {
       const _2 = __using(_stack, Logger.suspendLogging(
         "Rendering browser is not installed yet. Downloading now."
       ));
-      await registry.install([executable], false);
+      installedBrowser = await browsers.install({
+        cacheDir: getPuppeteerCacheDir(),
+        browser: browserEnumMap[type],
+        buildId,
+        downloadProgressCallback: "default"
+      });
     } catch (_) {
       var _error = _, _hasError = true;
     } finally {
       __callDispose(_stack, _error, _hasError);
     }
   }
-  return executable.executablePath();
+  return installedBrowser.executablePath;
 }
 async function launchPreview({
   mode,
@@ -1145,48 +1324,59 @@ async function launchPreview({
   config: { browser: browserConfig, proxy, sandbox, ignoreHttpsErrors }
 }) {
   let executableBrowser = browserConfig.executablePath;
+  Logger.debug(`Specified browser path: ${executableBrowser}`);
   if (executableBrowser) {
     if (!checkBrowserAvailability(executableBrowser)) {
       throw new Error(
         `Cannot find the browser. Please check the executable browser path: ${executableBrowser}`
       );
     }
+  } else if (detectBrowserPlatform() === "linux_arm" && (browserConfig.type === "chrome" || browserConfig.type === "chromium")) {
+    Logger.logInfo(
+      "The official Chrome/Chromium binaries are not available for ARM64 Linux. Using the system-installed Chromium browser instead."
+    );
+    executableBrowser = "/usr/bin/chromium";
   } else {
-    executableBrowser = await getExecutableBrowserPath(browserConfig.type);
+    executableBrowser = await getExecutableBrowserPath(browserConfig);
+    Logger.debug(`Using default browser: ${executableBrowser}`);
     if (!checkBrowserAvailability(executableBrowser)) {
-      await downloadBrowser(browserConfig.type);
+      await cleanupOutdatedBrowsers();
+      await downloadBrowser(browserConfig);
     }
   }
-  Logger.debug(`Executing browser path: ${executableBrowser}`);
-  const browser = await launchBrowser({
+  const { browser, browserContext } = await launchBrowser({
     browserType: browserConfig.type,
     proxy,
     executablePath: executableBrowser,
     headless: mode === "build",
     noSandbox: !sandbox,
-    disableDevShmUsage: isInContainer()
+    disableDevShmUsage: isInContainer(),
+    ignoreHttpsErrors
   });
   await onBrowserOpen?.(browser);
-  const page = await browser.newPage({
-    viewport: mode === "build" ? (
-      // This viewport size important to detect headless environment in Vivliostyle viewer
+  const page = (await browserContext.pages())[0] ?? await browserContext.newPage();
+  await page.setViewport(
+    mode === "build" ? (
+      // This viewport size is important to detect headless environment in Vivliostyle viewer
       // https://github.com/vivliostyle/vivliostyle.js/blob/73bcf323adcad80126b0175630609451ccd09d8a/packages/core/src/vivliostyle/vgen.ts#L2489-L2500
-      {
-        width: 800,
-        height: 600
-      }
-    ) : null,
-    ignoreHTTPSErrors: ignoreHttpsErrors
-  });
+      { width: 800, height: 600 }
+    ) : null
+  );
   await onPageOpen?.(page);
   page.on("dialog", () => {
   });
+  if (proxy?.username && proxy?.password) {
+    await page.authenticate({
+      username: proxy.username,
+      password: proxy.password
+    });
+  }
   await page.goto(url);
   return { browser, page };
 }
 
 // src/server.ts
-import fs11 from "node:fs";
+import fs10 from "node:fs";
 import { URL as URL2 } from "node:url";
 import upath11 from "upath";
 import {
@@ -1199,170 +1389,22 @@ import escapeRe from "escape-string-regexp";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
 import sirv from "sirv";
 import upath8 from "upath";
-
-// src/processor/asset.ts
-import { copy } from "fs-extra/esm";
-import fs5 from "node:fs";
-import picomatch from "picomatch";
-import { glob } from "tinyglobby";
-import upath3 from "upath";
-var GlobMatcher = class {
-  constructor(matcherConfig) {
-    this.matcherConfig = matcherConfig;
-    this.#_matchers = matcherConfig.map(
-      ({ patterns, ...options }) => picomatch(patterns, options)
-    );
-  }
-  #_matchers;
-  match(test) {
-    return this.#_matchers.some((matcher) => matcher(test));
-  }
-  async glob(globOptions = {}) {
-    return new Set(
-      (await Promise.all(
-        this.matcherConfig.map(
-          (config) => glob({ ...config, ...globOptions })
-        )
-      )).flat()
-    );
-  }
-};
-function getIgnoreThemeDirectoryPatterns({
-  themesDir,
-  cwd: cwd2
-}) {
-  return pathContains(cwd2, themesDir) ? [
-    `${upath3.relative(cwd2, themesDir)}/node_modules/*/example`,
-    `${upath3.relative(cwd2, themesDir)}/node_modules/*/*/example`
-  ] : [];
-}
-function getIgnoreAssetPatterns({
-  outputs,
-  entries,
-  cwd: cwd2
-}) {
-  return [
-    ...outputs.flatMap(
-      ({ format, path: p }) => !pathContains(cwd2, p) ? [] : format === "webpub" ? upath3.join(upath3.relative(cwd2, p), "**") : upath3.relative(cwd2, p)
-    ),
-    ...entries.flatMap(({ template }) => {
-      return template?.type === "file" && pathContains(cwd2, template.pathname) ? upath3.relative(cwd2, template.pathname) : [];
-    })
-  ];
-}
-function getWebPubResourceMatcher({
-  outputs,
-  themesDir,
-  entries,
-  cwd: cwd2,
-  manifestPath,
-  copyAsset: { fileExtensions }
-}) {
-  return new GlobMatcher([
-    {
-      patterns: [
-        `**/${upath3.relative(cwd2, manifestPath)}`,
-        "**/*.{html,htm,xhtml,xht}",
-        `**/*.{${fileExtensions.join(",")}}`
-      ],
-      ignore: [
-        ...getIgnoreAssetPatterns({
-          cwd: cwd2,
-          outputs,
-          entries
-        }),
-        ...getIgnoreThemeDirectoryPatterns({
-          cwd: cwd2,
-          themesDir
-        }),
-        // Ignore node_modules in the root directory
-        "node_modules/**",
-        // only include dotfiles starting with `.vs-`
-        "**/.!(vs-*)/**"
-      ],
-      dot: true,
-      cwd: cwd2
-    }
-  ]);
-}
-function getAssetMatcher({
-  copyAsset: { fileExtensions, includes, excludes },
-  outputs,
-  themesDir,
-  entries,
-  cwd: cwd2,
-  ignore = []
-}) {
-  const ignorePatterns = [
-    ...ignore,
-    ...excludes,
-    ...getIgnoreAssetPatterns({ outputs, entries, cwd: cwd2 })
-  ];
-  return new GlobMatcher([
-    // Step 1: Glob files with an extension in `fileExtension`
-    // Ignore files in node_modules directory, theme example files and files matched `excludes`
-    {
-      patterns: fileExtensions.map((ext) => `**/*.${ext}`),
-      ignore: [
-        "**/node_modules/**",
-        ...ignorePatterns,
-        ...getIgnoreThemeDirectoryPatterns({ themesDir, cwd: cwd2 })
-      ],
-      cwd: cwd2
-    },
-    // Step 2: Glob files matched with `includes`
-    // Ignore only files matched `excludes`
-    {
-      patterns: includes,
-      ignore: ignorePatterns,
-      cwd: cwd2
-    }
-  ]);
-}
-async function copyAssets({
-  entryContextDir,
-  workspaceDir,
-  copyAsset,
-  outputs,
-  themesDir,
-  entries
-}) {
-  if (pathEquals(entryContextDir, workspaceDir)) {
-    return;
-  }
-  const relWorkspaceDir = upath3.relative(entryContextDir, workspaceDir);
-  const assets = await getAssetMatcher({
-    copyAsset,
-    cwd: entryContextDir,
-    outputs,
-    themesDir,
-    entries,
-    ignore: [
-      // don't copy workspace itself
-      ...relWorkspaceDir ? [upath3.join(relWorkspaceDir, "**")] : []
-    ]
-  }).glob({ followSymbolicLinks: true });
-  Logger.debug("assets", assets);
-  for (const asset of assets) {
-    const target = upath3.join(workspaceDir, asset);
-    fs5.mkdirSync(upath3.dirname(target), { recursive: true });
-    await copy(upath3.resolve(entryContextDir, asset), target);
-  }
-}
+import "vite";
 
 // src/processor/compile.ts
-import { copy as copy4, move } from "fs-extra/esm";
-import fs9 from "node:fs";
+import "@vivliostyle/jsdom";
+import { copy as copy3, move } from "fs-extra/esm";
+import fs8 from "node:fs";
 import upath7 from "upath";
 import serializeToXml2 from "w3c-xmlserializer";
 import MIMEType2 from "whatwg-mimetype";
 
 // src/output/webbook.ts
-import { copy as copy3 } from "fs-extra/esm";
+import { copy as copy2 } from "fs-extra/esm";
 import { lookup as mime3 } from "mime-types";
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 import { pathToFileURL as pathToFileURL5 } from "node:url";
-import { glob as glob2 } from "tinyglobby";
+import { glob } from "tinyglobby";
 import upath6 from "upath";
 
 // src/processor/html.tsx
@@ -1529,8 +1571,8 @@ function getJsdomFromString({
 }
 async function getStructuredSectionFromHtml(htmlPath, href) {
   const dom = await getJsdomFromUrlOrFile({ src: htmlPath });
-  const { document } = dom.window;
-  const allHeadings = [...document.querySelectorAll("h1, h2, h3, h4, h5, h6")].filter((el) => {
+  const { document: document2 } = dom.window;
+  const allHeadings = [...document2.querySelectorAll("h1, h2, h3, h4, h5, h6")].filter((el) => {
     return !el.matches("blockquote *");
   }).sort((a, b) => {
     const position = a.compareDocumentPosition(b);
@@ -1695,17 +1737,17 @@ async function processTocHtml(dom, {
   sectionDepth,
   transform
 }) {
-  const { document } = dom.window;
-  if (!document.querySelector(
+  const { document: document2 } = dom.window;
+  if (!document2.querySelector(
     'link[rel="publication"][type="application/ld+json"]'
   )) {
-    const l = document.createElement("link");
+    const l = document2.createElement("link");
     l.setAttribute("rel", "publication");
     l.setAttribute("type", "application/ld+json");
     l.setAttribute("href", encodeURI(upath4.relative(distDir, manifestPath)));
-    document.head.appendChild(l);
+    document2.head.appendChild(l);
   }
-  const style = document.querySelector("style[data-vv-style]");
+  const style = document2.querySelector("style[data-vv-style]");
   if (style) {
     const textContent = getTocHtmlStyle(styleOptions);
     if (textContent) {
@@ -1714,9 +1756,9 @@ async function processTocHtml(dom, {
       style.remove();
     }
   }
-  const nav = document.querySelector('nav, [role="doc-toc"]');
+  const nav = document2.querySelector('nav, [role="doc-toc"]');
   if (nav && !nav.hasChildNodes()) {
-    const h2 = document.createElement("h2");
+    const h2 = document2.createElement("h2");
     h2.textContent = tocTitle;
     nav.appendChild(h2);
     nav.innerHTML += await generateTocListSection({
@@ -1769,8 +1811,8 @@ async function processCoverHtml(dom, {
   imageAlt,
   styleOptions = {}
 }) {
-  const { document } = dom.window;
-  const style = document.querySelector("style[data-vv-style]");
+  const { document: document2 } = dom.window;
+  const style = document2.querySelector("style[data-vv-style]");
   if (style) {
     const textContent = getCoverHtmlStyle(styleOptions);
     if (textContent) {
@@ -1779,7 +1821,7 @@ async function processCoverHtml(dom, {
       style.remove();
     }
   }
-  const cover = document.querySelector('img[role="doc-cover"]');
+  const cover = document2.querySelector('img[role="doc-cover"]');
   if (cover && !cover.hasAttribute("src")) {
     cover.setAttribute("src", encodeURI(imageSrc));
   }
@@ -1794,30 +1836,30 @@ async function processManuscriptHtml(dom, {
   contentType,
   language
 }) {
-  const { document } = dom.window;
+  const { document: document2 } = dom.window;
   if (title) {
-    if (!document.querySelector("title")) {
-      const t = document.createElement("title");
-      document.head.appendChild(t);
+    if (!document2.querySelector("title")) {
+      const t = document2.createElement("title");
+      document2.head.appendChild(t);
     }
-    document.title = title;
+    document2.title = title;
   }
   for (const s of style ?? []) {
-    const l = document.createElement("link");
+    const l = document2.createElement("link");
     l.setAttribute("rel", "stylesheet");
     l.setAttribute("type", "text/css");
     l.setAttribute("href", encodeURI(s));
-    document.head.appendChild(l);
+    document2.head.appendChild(l);
   }
   if (language) {
     if (contentType === "application/xhtml+xml") {
-      if (!document.documentElement.getAttribute("xml:lang")) {
-        document.documentElement.setAttribute("lang", language);
-        document.documentElement.setAttribute("xml:lang", language);
+      if (!document2.documentElement.getAttribute("xml:lang")) {
+        document2.documentElement.setAttribute("lang", language);
+        document2.documentElement.setAttribute("xml:lang", language);
       }
     } else {
-      if (!document.documentElement.getAttribute("lang")) {
-        document.documentElement.setAttribute("lang", language);
+      if (!document2.documentElement.getAttribute("lang")) {
+        document2.documentElement.setAttribute("lang", language);
       }
     }
   }
@@ -1828,8 +1870,8 @@ async function fetchLinkedPublicationManifest({
   resourceLoader,
   baseUrl
 }) {
-  const { document } = dom.window;
-  const linkEl = document.querySelector('link[href][rel="publication"]');
+  const { document: document2 } = dom.window;
+  const linkEl = document2.querySelector('link[href][rel="publication"]');
   if (!linkEl) {
     return null;
   }
@@ -1837,7 +1879,7 @@ async function fetchLinkedPublicationManifest({
   let manifest;
   let manifestUrl = baseUrl;
   if (href.startsWith("#")) {
-    const scriptEl = document.getElementById(href.slice(1));
+    const scriptEl = document2.getElementById(href.slice(1));
     if (scriptEl?.getAttribute("type") !== "application/ld+json") {
       return null;
     }
@@ -1884,8 +1926,8 @@ ${error}`
   };
 }
 function parseTocDocument(dom) {
-  const { document } = dom.window;
-  const docTocEl = document.querySelectorAll('[role="doc-toc"]');
+  const { document: document2 } = dom.window;
+  const docTocEl = document2.querySelectorAll('[role="doc-toc"]');
   if (docTocEl.length === 0) {
     return null;
   }
@@ -1935,8 +1977,8 @@ function parseTocDocument(dom) {
   return null;
 }
 function parsePageListDocument(dom) {
-  const { document } = dom.window;
-  const docPageListEl = document.querySelectorAll('[role="doc-pagelist"]');
+  const { document: document2 } = dom.window;
+  const docPageListEl = document2.querySelectorAll('[role="doc-pagelist"]');
   if (docPageListEl.length === 0) {
     return null;
   }
@@ -1961,10 +2003,10 @@ function parsePageListDocument(dom) {
 import archiver from "archiver";
 import { lookup as lookupLanguage } from "bcp-47-match";
 import { XMLBuilder } from "fast-xml-parser";
-import { copy as copy2 } from "fs-extra/esm";
+import { copy } from "fs-extra/esm";
 import GithubSlugger from "github-slugger";
 import { lookup as mime2 } from "mime-types";
-import fs6 from "node:fs";
+import fs5 from "node:fs";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 import upath5 from "upath";
 import { v4 as uuid } from "uuid";
@@ -2037,8 +2079,8 @@ async function exportEpub({
     epubVersion
   });
   const [tmpDir] = await useTmpDirectory();
-  fs6.mkdirSync(upath5.join(tmpDir, "META-INF"), { recursive: true });
-  await copy2(webpubDir, upath5.join(tmpDir, "EPUB"));
+  fs5.mkdirSync(upath5.join(tmpDir, "META-INF"), { recursive: true });
+  await copy(webpubDir, upath5.join(tmpDir, "EPUB"));
   const uid = `urn:uuid:${uuid()}`;
   const entryHtmlRelPath = entryHtmlFile && upath5.relative(webpubDir, upath5.resolve(webpubDir, entryHtmlFile));
   const findPublicationLink = (relType, list, filter) => [list].flat().find(
@@ -2077,7 +2119,7 @@ async function exportEpub({
         return acc;
       } catch (e) {
       }
-      if (!fs6.existsSync(upath5.join(tmpDir, "EPUB", url))) {
+      if (!fs5.existsSync(upath5.join(tmpDir, "EPUB", url))) {
         return acc;
       }
       const mediaType = encodingFormat || mime2(url) || "text/plain";
@@ -2193,19 +2235,19 @@ async function exportEpub({
     });
   }
   if (relManifestPath) {
-    await fs6.promises.rm(upath5.join(tmpDir, "EPUB", relManifestPath), {
+    await fs5.promises.rm(upath5.join(tmpDir, "EPUB", relManifestPath), {
       force: true,
       recursive: true
     });
     delete manifestItem[relManifestPath];
   }
-  fs6.writeFileSync(
+  fs5.writeFileSync(
     upath5.join(tmpDir, "META-INF/container.xml"),
     EPUB_CONTAINER_XML,
     "utf8"
   );
   Logger.debug(`Generating content.opf`);
-  fs6.writeFileSync(
+  fs5.writeFileSync(
     upath5.join(tmpDir, "EPUB/content.opf"),
     buildEpubPackageDocument({
       epubVersion,
@@ -2223,7 +2265,7 @@ async function exportEpub({
 async function writeAsXhtml(dom, absPath) {
   const xhtml = `${XML_DECLARATION}
 ${serializeToXml(dom.window.document)}`;
-  await fs6.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
+  await fs5.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
 }
 async function transpileHtmlToXhtml({
   target,
@@ -2231,24 +2273,24 @@ async function transpileHtmlToXhtml({
 }) {
   const absPath = upath5.join(contextDir, target);
   const dom = await getJsdomFromUrlOrFile({ src: absPath });
-  const { document } = dom.window;
-  document.documentElement.removeAttribute("xmlns");
-  document.documentElement.setAttribute("xmlns:epub", EPUB_NS);
-  document.querySelectorAll("a[href]").forEach((el) => {
+  const { document: document2 } = dom.window;
+  document2.documentElement.removeAttribute("xmlns");
+  document2.documentElement.setAttribute("xmlns:epub", EPUB_NS);
+  document2.querySelectorAll("a[href]").forEach((el) => {
     const href = decodeURI(el.getAttribute("href"));
     el.setAttribute("href", getRelativeHref(href, target, target));
   });
   await writeAsXhtml(dom, absPath);
-  await fs6.promises.unlink(absPath);
+  await fs5.promises.unlink(absPath);
   return {
     dom,
     // FIXME: Yes, I recognize this implementation is inadequate.
-    hasMathmlContent: !!document.querySelector("math"),
-    hasRemoteResources: !!document.querySelector(
+    hasMathmlContent: !!document2.querySelector("math"),
+    hasRemoteResources: !!document2.querySelector(
       '[src^="http://"], [src^="https://"]'
     ),
-    hasScriptedContent: !!document.querySelector("script, form"),
-    hasSvgContent: !!document.querySelector("svg")
+    hasScriptedContent: !!document2.querySelector("script, form"),
+    hasSvgContent: !!document2.querySelector("svg")
   };
 }
 function replaceWithNavElement(dom, el) {
@@ -2270,9 +2312,9 @@ async function processTocDocument({
   docLanguages,
   landmarks
 }) {
-  const { document } = dom.window;
+  const { document: document2 } = dom.window;
   let tocResourceTree = null;
-  if (!document.querySelector("nav[epub:type]")) {
+  if (!document2.querySelector("nav[epub:type]")) {
     tocResourceTree = parseTocDocument(dom);
     if (tocResourceTree) {
       const nav = replaceWithNavElement(dom, tocResourceTree.element);
@@ -2280,15 +2322,15 @@ async function processTocDocument({
       nav.setAttribute("epub:type", "toc");
     } else {
       Logger.debug(`Generating toc nav element: ${target}`);
-      const nav = document.createElement("nav");
+      const nav = document2.createElement("nav");
       nav.setAttribute("id", TOC_ID);
       nav.setAttribute("role", "doc-toc");
       nav.setAttribute("epub:type", "toc");
       nav.setAttribute("hidden", "");
-      const h2 = document.createElement("h2");
+      const h2 = document2.createElement("h2");
       h2.textContent = TOC_TITLE;
       nav.appendChild(h2);
-      const ol = document.createElement("ol");
+      const ol = document2.createElement("ol");
       tocResourceTree = {
         element: nav,
         children: []
@@ -2301,8 +2343,8 @@ async function processTocDocument({
           });
           name = dom2.window.document.title;
         }
-        const li = document.createElement("li");
-        const a = document.createElement("a");
+        const li = document2.createElement("li");
+        const a = document2.createElement("a");
         a.textContent = name;
         a.href = getRelativeHref(content.url, "", target);
         li.appendChild(a);
@@ -2310,22 +2352,22 @@ async function processTocDocument({
         tocResourceTree.children.push({ element: li, label: a });
       }
       nav.appendChild(ol);
-      document.body.appendChild(nav);
+      document2.body.appendChild(nav);
       Logger.debug("Generated toc nav element", nav.outerHTML);
     }
     if (landmarks.length > 0) {
       Logger.debug(`Generating landmark nav element: ${target}`);
-      const nav = document.createElement("nav");
+      const nav = document2.createElement("nav");
       nav.setAttribute("epub:type", "landmarks");
       nav.setAttribute("id", LANDMARKS_ID);
       nav.setAttribute("hidden", "");
-      const h2 = document.createElement("h2");
+      const h2 = document2.createElement("h2");
       h2.textContent = EPUB_LANDMARKS_TITLE;
       nav.appendChild(h2);
-      const ol = document.createElement("ol");
+      const ol = document2.createElement("ol");
       for (const { type, href, text } of landmarks) {
-        const li = document.createElement("li");
-        const a = document.createElement("a");
+        const li = document2.createElement("li");
+        const a = document2.createElement("a");
         a.setAttribute("epub:type", type);
         a.setAttribute("href", getRelativeHref(href, "", target));
         a.text = text;
@@ -2333,17 +2375,17 @@ async function processTocDocument({
         ol.appendChild(li);
       }
       nav.appendChild(ol);
-      document.body.appendChild(nav);
+      document2.body.appendChild(nav);
       Logger.debug("Generated landmark nav element", nav.outerHTML);
     }
   }
-  const publicationLinkEl = document.querySelector(
+  const publicationLinkEl = document2.querySelector(
     'link[href][rel="publication"]'
   );
   if (publicationLinkEl) {
     const href = publicationLinkEl.getAttribute("href").trim();
     if (href.startsWith("#")) {
-      const scriptEl = document.getElementById(href.slice(1));
+      const scriptEl = document2.getElementById(href.slice(1));
       if (scriptEl?.getAttribute("type") === "application/ld+json") {
         scriptEl.parentNode?.removeChild(scriptEl);
       }
@@ -2484,7 +2526,7 @@ async function compressEpub({
   sourceDir
 }) {
   Logger.debug(`Compressing EPUB: ${target}`);
-  const output = fs6.createWriteStream(target);
+  const output = fs5.createWriteStream(target);
   const archive = archiver("zip", {
     zlib: { level: 9 }
     // Compression level
@@ -2522,11 +2564,11 @@ function sortManifestResources(manifest) {
 async function prepareWebPublicationDirectory({
   outputDir
 }) {
-  if (fs7.existsSync(outputDir)) {
+  if (fs6.existsSync(outputDir)) {
     Logger.debug("going to remove existing webpub", outputDir);
-    await fs7.promises.rm(outputDir, { force: true, recursive: true });
+    await fs6.promises.rm(outputDir, { force: true, recursive: true });
   }
-  fs7.mkdirSync(outputDir, { recursive: true });
+  fs6.mkdirSync(outputDir, { recursive: true });
 }
 function transformPublicationManifest(entity, transformer) {
   const { url: transformUrl } = transformer;
@@ -2623,8 +2665,8 @@ function writePublicationManifest(output, options) {
       typeof thrownError === "string" ? thrownError : thrownError.stack ?? thrownError.message
     );
   }
-  fs7.mkdirSync(upath6.dirname(output), { recursive: true });
-  fs7.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
+  fs6.mkdirSync(upath6.dirname(output), { recursive: true });
+  fs6.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
   return publication;
 }
 async function retrieveWebbookEntry({
@@ -2735,12 +2777,12 @@ async function supplyWebPublicationManifestForWebbook({
 }) {
   Logger.debug(`Generating publication manifest from HTML: ${entryHtmlFile}`);
   const dom = await getJsdomFromUrlOrFile({ src: entryHtmlFile });
-  const { document } = dom.window;
-  const language = config.language || document.documentElement.lang || void 0;
-  const title = config.title || document.title || "";
-  const author = config.author || document.querySelector('meta[name="author"]')?.getAttribute("content") || "";
+  const { document: document2 } = dom.window;
+  const language = config.language || document2.documentElement.lang || void 0;
+  const title = config.title || document2.title || "";
+  const author = config.author || document2.querySelector('meta[name="author"]')?.getAttribute("content") || "";
   const entry = upath6.relative(outputDir, entryHtmlFile);
-  const allFiles = await glob2("**", {
+  const allFiles = await glob("**", {
     cwd: outputDir
   });
   const manifest = writePublicationManifest(
@@ -2756,7 +2798,7 @@ async function supplyWebPublicationManifestForWebbook({
     }
   );
   sortManifestResources(manifest);
-  const link = document.createElement("link");
+  const link = document2.createElement("link");
   link.setAttribute("rel", "publication");
   link.setAttribute("type", "application/ld+json");
   link.setAttribute(
@@ -2766,8 +2808,8 @@ async function supplyWebPublicationManifestForWebbook({
       upath6.join(outputDir, MANIFEST_FILENAME)
     )
   );
-  document.head.appendChild(link);
-  await fs7.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
+  document2.head.appendChild(link);
+  await fs6.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
   Logger.debug(
     "Generated publication manifest from HTML",
     JSON.stringify(manifest, null, 2)
@@ -2834,15 +2876,15 @@ async function copyWebPublicationAssets({
     const relTarget = alias?.target || file;
     resources.push(relTarget);
     const target = upath6.join(outputDir, relTarget);
-    fs7.mkdirSync(upath6.dirname(target), { recursive: true });
-    await copy3(upath6.join(input, file), target);
+    fs6.mkdirSync(upath6.dirname(target), { recursive: true });
+    await copy2(upath6.join(input, file), target);
     if (alias && pathEquals(upath6.join(input, alias.source), manifestPath)) {
       actualManifestPath = target;
     }
   }
   Logger.debug("webbook publication.json", actualManifestPath);
   const manifest = decodePublicationManifest(
-    JSON.parse(fs7.readFileSync(actualManifestPath, "utf8"))
+    JSON.parse(fs6.readFileSync(actualManifestPath, "utf8"))
   );
   for (const entry of relExportAliases) {
     const rewriteAliasPath = (e) => {
@@ -2881,7 +2923,7 @@ async function copyWebPublicationAssets({
     })
   ];
   sortManifestResources(manifest);
-  fs7.writeFileSync(
+  fs6.writeFileSync(
     actualManifestPath,
     JSON.stringify(encodePublicationManifest(manifest), null, 2)
   );
@@ -2948,17 +2990,18 @@ async function buildWebPublication({
 
 // src/processor/theme.ts
 import Arborist from "@npmcli/arborist";
-import fs8 from "node:fs";
+import fs7 from "node:fs";
 async function checkThemeInstallationNecessity({
   themesDir,
   themeIndexes
 }) {
-  if (!fs8.existsSync(themesDir)) {
+  if (!fs7.existsSync(themesDir)) {
     return [...themeIndexes].some((theme) => theme.type === "package");
   }
   const commonOpt = {
     path: themesDir,
-    lockfileVersion: 3
+    lockfileVersion: 3,
+    installLinks: true
   };
   const arb = new Arborist(commonOpt);
   const tree = await arb.loadActual();
@@ -2971,11 +3014,12 @@ async function installThemeDependencies({
   themesDir,
   themeIndexes
 }) {
-  fs8.mkdirSync(themesDir, { recursive: true });
+  fs7.mkdirSync(themesDir, { recursive: true });
   try {
     const commonOpt = {
       path: themesDir,
-      lockfileVersion: 3
+      lockfileVersion: 3,
+      installLinks: true
     };
     const tree = await new Arborist(commonOpt).buildIdealTree();
     const existing = Array.from(tree.children.keys());
@@ -3011,7 +3055,7 @@ function locateThemePath(theme, from) {
   if (theme.importPath) {
     return [theme.importPath].flat().map((locator) => {
       const resolvedPath = upath7.resolve(theme.location, locator);
-      if (!pathContains(theme.location, resolvedPath) || !fs9.existsSync(resolvedPath)) {
+      if (!pathContains(theme.location, resolvedPath) || !fs8.existsSync(resolvedPath)) {
         throw new Error(
           `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
         );
@@ -3020,7 +3064,7 @@ function locateThemePath(theme, from) {
     });
   } else {
     const pkgJsonPath = upath7.join(theme.location, "package.json");
-    const packageJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf8"));
+    const packageJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf8"));
     const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
     if (!maybeStyle) {
       throw new DetailError(
@@ -3044,7 +3088,7 @@ async function cleanupWorkspace({
   }
   Logger.debug("cleanup workspace files", workspaceDir);
   let movedWorkspacePath;
-  if (pathContains(workspaceDir, themesDir) && fs9.existsSync(themesDir)) {
+  if (pathContains(workspaceDir, themesDir) && fs8.existsSync(themesDir)) {
     movedWorkspacePath = upath7.join(
       upath7.dirname(workspaceDir),
       `.vs-${Date.now()}`
@@ -3053,18 +3097,18 @@ async function cleanupWorkspace({
       movedWorkspacePath,
       upath7.relative(workspaceDir, themesDir)
     );
-    fs9.mkdirSync(upath7.dirname(movedThemePath), { recursive: true });
+    fs8.mkdirSync(upath7.dirname(movedThemePath), { recursive: true });
     registerExitHandler(
       `Removing the moved workspace directory: ${movedWorkspacePath}`,
       () => {
-        if (movedWorkspacePath && fs9.existsSync(movedWorkspacePath)) {
-          fs9.rmSync(movedWorkspacePath, { recursive: true, force: true });
+        if (movedWorkspacePath && fs8.existsSync(movedWorkspacePath)) {
+          fs8.rmSync(movedWorkspacePath, { recursive: true, force: true });
         }
       }
     );
     await move(themesDir, movedThemePath);
   }
-  await fs9.promises.rm(workspaceDir, { recursive: true, force: true });
+  await fs8.promises.rm(workspaceDir, { recursive: true, force: true });
   if (movedWorkspacePath) {
     await move(movedWorkspacePath, workspaceDir);
   }
@@ -3073,8 +3117,8 @@ async function prepareThemeDirectory({
   themesDir,
   themeIndexes
 }) {
-  if (fs9.existsSync(upath7.join(themesDir, "packages")) && !fs9.existsSync(upath7.join(themesDir, "node_modules"))) {
-    fs9.renameSync(
+  if (fs8.existsSync(upath7.join(themesDir, "packages")) && !fs8.existsSync(upath7.join(themesDir, "node_modules"))) {
+    fs8.renameSync(
       upath7.join(themesDir, "packages"),
       upath7.join(themesDir, "node_modules")
     );
@@ -3085,8 +3129,8 @@ async function prepareThemeDirectory({
   }
   for (const theme of themeIndexes) {
     if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
-      fs9.mkdirSync(upath7.dirname(theme.location), { recursive: true });
-      await copy4(theme.source, theme.location);
+      fs8.mkdirSync(upath7.dirname(theme.location), { recursive: true });
+      await copy3(theme.source, theme.location);
     }
   }
 }
@@ -3097,7 +3141,6 @@ async function transformManuscript(entry, {
   title,
   entries,
   language,
-  documentProcessorFactory,
   vfmOptions,
   rootUrl
 }) {
@@ -3109,9 +3152,10 @@ async function transformManuscript(entry, {
     (theme) => locateThemePath(theme, upath7.dirname(entry.target))
   );
   if (source?.type === "file") {
-    if (source.contentType === "text/markdown") {
+    if (source.documentProcessor) {
       const vfile2 = await processMarkdown(
-        documentProcessorFactory,
+        source.documentProcessor.processorFactory,
+        source.documentProcessor.metadataReader,
         source.pathname,
         {
           ...vfmOptions,
@@ -3131,7 +3175,7 @@ async function transformManuscript(entry, {
       });
     } else {
       if (!pathEquals(source.pathname, entry.target)) {
-        await copy4(source.pathname, entry.target);
+        await copy3(source.pathname, entry.target);
       }
     }
   } else if (source?.type === "uri") {
@@ -3265,7 +3309,7 @@ async function generateManifest({
   const manifestEntries = entries.map((entry) => ({
     title: entry.rel === "contents" && entry.tocTitle || entry.title,
     path: upath7.relative(workspaceDir, entry.target),
-    encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/html" ? void 0 : entry.contentType,
+    encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/x-vivliostyle-custom" || entry.contentType === "text/html" ? void 0 : entry.contentType,
     rel: entry.rel
   }));
   writePublicationManifest(manifestPath, {
@@ -3670,6 +3714,7 @@ function vsDevServerPlugin({
 // src/vite/vite-plugin-static-serve.ts
 import sirv2 from "sirv";
 import upath9 from "upath";
+import "vite";
 function vsStaticServePlugin({
   config: _config,
   inlineConfig
@@ -3712,9 +3757,10 @@ function vsStaticServePlugin({
 }
 
 // src/vite/vite-plugin-viewer.ts
-import fs10 from "node:fs";
+import fs9 from "node:fs";
 import sirv3 from "sirv";
 import upath10 from "upath";
+import "vite";
 var viewerClientId = "@vivliostyle:viewer:client";
 var viewerClientRequestPath = `/${viewerClientId}`;
 var viewerClientContent = (
@@ -3733,7 +3779,7 @@ function vsViewerPlugin(_) {
   const middleware = async function vivliostyleViewerMiddleware(req, res, next) {
     if (req.url === "/" || req.url === "/index.html") {
       cachedIndexHtml ??= prependToHead(
-        fs10.readFileSync(upath10.join(serveRootDir, "index.html"), "utf-8"),
+        fs9.readFileSync(upath10.join(serveRootDir, "index.html"), "utf-8"),
         `<script type="module" src="${viewerClientRequestPath}"></script>`
       );
       res.statusCode = 200;
@@ -3837,7 +3883,7 @@ async function getSourceUrl({
       input = viewerInput.epubOpfPath;
       break;
     case "epub": {
-      if (!fs11.existsSync(viewerInput.epubTmpOutputDir)) {
+      if (!fs10.existsSync(viewerInput.epubTmpOutputDir)) {
         await openEpub(viewerInput.epubPath, viewerInput.epubTmpOutputDir);
       }
       input = getDefaultEpubOpfPath(viewerInput.epubTmpOutputDir);
@@ -3899,8 +3945,8 @@ async function createViteServer({
   if (config.serverRootDir === config.workspaceDir) {
     const { cacheDir } = viteInlineConfig;
     registerExitHandler("Removing the Vite cacheDir", () => {
-      if (fs11.existsSync(cacheDir)) {
-        fs11.rmSync(cacheDir, { recursive: true });
+      if (fs10.existsSync(cacheDir)) {
+        fs10.rmSync(cacheDir, { recursive: true });
       }
     });
   }
@@ -3924,21 +3970,28 @@ function vsBrowserPlugin({
     runExitHandlers();
   }
   async function openPreviewPage() {
+    const locale = await getOsLocale();
     const url = await getViewerFullUrl(config);
     const { page, browser } = await launchPreview({
       mode: "preview",
       url,
       config,
+      /* v8 ignore next 4 */
       onPageOpen: async (page2) => {
         page2.on("close", handlePageClose);
-        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
-        await page2.addInitScript(
-          `window.localStorage.setItem('i18nextLng', '${locale}');`
-        );
       }
     });
+    if (!import.meta.env?.VITEST) {
+      await page.evaluate((locale2) => {
+        window.localStorage.setItem("i18nextLng", locale2);
+      }, locale);
+    }
     await page.bringToFront();
-    await page.locator("#vivliostyle-input-url").focus({ timeout: 0 });
+    if (!import.meta.env?.VITEST) {
+      await page.evaluate(() => {
+        document.querySelector("#vivliostyle-input-url")?.focus();
+      });
+    }
     closeBrowser = () => {
       page.off("close", handlePageClose);
       browser.close();
@@ -3970,10 +4023,8 @@ export {
   mergeInlineConfig,
   isWebPubConfig,
   resolveTaskConfig,
-  getFullBrowserName,
   launchPreview,
   vsBrowserPlugin,
-  copyAssets,
   buildWebPublication,
   cleanupWorkspace,
   prepareThemeDirectory,
@@ -3985,4 +4036,4 @@ export {
   getViewerFullUrl,
   createViteServer
 };
-//# sourceMappingURL=chunk-PPI5DA75.js.map
+//# sourceMappingURL=chunk-YN3JNBNT.js.map