@vivliostyle/cli 10.3.1 → 10.4.0

package/dist/{chunk-C4HQHRXQ.js → chunk-P33ELNYE.js}

@@ -2,42 +2,44 @@ import {
   importNodeModule
 } from "./chunk-ECEGM36O.js";
 import {
-  DetailError,
   GlobMatcher,
+  getAssetMatcher,
+  getWebPubResourceMatcher,
+  loadVivliostyleConfig,
+  locateVivliostyleConfig,
+  setupConfigFromFlags
+} from "./chunk-Q4EIXB5V.js";
+import {
+  DetailError,
   Logger,
   assertPubManifestSchema,
+  cliVersion,
   cwd,
   debounce,
   detectBrowserPlatform,
-  getAssetMatcher,
   getCacheDir,
   getDefaultBrowserTag,
   getDefaultEpubOpfPath,
   getEpubRootDir,
   getFormattedError,
   getOsLocale,
-  getWebPubResourceMatcher,
   isInContainer,
   isRunningOnWSL,
   isValidUri,
   openEpub,
-  parseJsonc,
   pathContains,
   pathEquals,
-  prettifySchemaError,
   readJSON,
   registerExitHandler,
   runExitHandlers,
-  setupConfigFromFlags,
   statFileSync,
   touchTmpFile,
   useTmpDirectory,
+  viewerRoot,
   writeFileIfChanged
-} from "./chunk-DBK27BAR.js";
-import {
-  VivliostyleConfigSchema
-} from "./chunk-7GIJVX4M.js";
+} from "./chunk-VAPIKX4A.js";
 import {
+  CMYK_RESERVE_MAP_FILENAME,
   CONTAINER_LOCAL_HOSTNAME,
   CONTAINER_URL,
   COVER_HTML_FILENAME,
@@ -54,122 +56,13 @@ import {
   TOC_FILENAME,
   TOC_TITLE,
   VIEWER_ROOT_PATH,
-  XML_DECLARATION,
-  cliVersion,
-  viewerRoot
-} from "./chunk-OAFXM4ES.js";
+  XML_DECLARATION
+} from "./chunk-DK3HFVHX.js";
 import {
   __callDispose,
   __using
 } from "./chunk-I7BWSAN6.js";
 
-// src/config/load.ts
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import upath from "upath";
-import * as v from "valibot";
-var require2 = createRequire(import.meta.url);
-function locateVivliostyleConfig({
-  config,
-  cwd: cwd2 = cwd
-}) {
-  if (config) {
-    return upath.resolve(cwd2, config);
-  }
-  return [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts", ".json"].map((ext) => upath.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs.existsSync(p));
-}
-async function loadVivliostyleConfig({
-  config,
-  configData,
-  cwd: cwd2
-}) {
-  if (configData) {
-    return v.parse(VivliostyleConfigSchema, configData);
-  }
-  const absPath = locateVivliostyleConfig({ config, cwd: cwd2 });
-  if (!absPath) {
-    return;
-  }
-  let parsedConfig;
-  let jsonRaw;
-  try {
-    if (upath.extname(absPath) === ".json") {
-      jsonRaw = fs.readFileSync(absPath, "utf8");
-      parsedConfig = parseJsonc(jsonRaw);
-    } else {
-      delete require2.cache[require2.resolve(absPath)];
-      const url = pathToFileURL(absPath);
-      url.search = `version=${Date.now()}`;
-      parsedConfig = (await import(
-        /* @vite-ignore */
-        url.href
-      )).default;
-      jsonRaw = JSON.stringify(parsedConfig, null, 2);
-    }
-  } catch (error) {
-    const thrownError = error;
-    throw new DetailError(
-      `An error occurred on loading a config file: ${absPath}`,
-      thrownError.stack ?? thrownError.message
-    );
-  }
-  const result = v.safeParse(VivliostyleConfigSchema, parsedConfig);
-  if (result.success) {
-    const { tasks, inlineOptions } = result.output;
-    return {
-      tasks,
-      inlineOptions: {
-        ...inlineOptions,
-        cwd: cwd2 ?? cwd,
-        config: absPath
-      }
-    };
-  } else {
-    const errorString = prettifySchemaError(jsonRaw, result.issues);
-    throw new DetailError(
-      `Validation of vivliostyle config failed. Please check the schema: ${config}`,
-      errorString
-    );
-  }
-}
-function warnDeprecatedConfig(config) {
-  if (config.tasks.some((task) => task.includeAssets)) {
-    Logger.logWarn(
-      "'includeAssets' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'copyAsset.includes' property instead."
-    );
-  }
-  if (config.tasks.some((task) => task.tocTitle)) {
-    Logger.logWarn(
-      "'tocTitle' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'toc.title' property instead."
-    );
-  }
-  if (config.tasks.some((task) => task.http)) {
-    Logger.logWarn(
-      "'http' property of Vivliostyle config was deprecated and will be removed in a future release. This option is enabled by default, and the file protocol is no longer supported."
-    );
-  }
-  if (config.tasks.some((task) => task.pressReady !== void 0)) {
-    Logger.logWarn(
-      `'pressReady' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflight: "press-ready"' property instead.`
-    );
-  }
-  if (config.tasks.some(
-    (task) => task.output && [task.output].flat().some((o) => o.preflight)
-  )) {
-    Logger.logWarn(
-      "'preflight' property of output config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflight' property instead."
-    );
-  }
-  if (config.tasks.some(
-    (task) => task.output && [task.output].flat().some((o) => o.preflightOption)
-  )) {
-    Logger.logWarn(
-      "'preflightOption' property of output config was deprecated and will be removed in a future release. Please use 'pdfPostprocess.preflightOption' property instead."
-    );
-  }
-}
-
 // src/config/merge.ts
 var pruneObject = (obj) => {
   const ret = { ...obj };
@@ -265,17 +158,17 @@ import {
   VFM
 } from "@vivliostyle/vfm";
 import { lookup as mime } from "mime-types";
-import fs3 from "node:fs";
-import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
+import fs2 from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import npa from "npm-package-arg";
 import { globSync } from "tinyglobby";
-import upath2 from "upath";
+import upath from "upath";
 
 // src/processor/markdown.ts
-import fs2 from "node:fs";
+import fs from "node:fs";
 import vfile from "vfile";
 async function processMarkdown(documentProcessorFactory, documentMetadataReader, filepath, options = {}) {
-  const markdownString = fs2.readFileSync(filepath, "utf8");
+  const markdownString = fs.readFileSync(filepath, "utf8");
   const processor = documentProcessorFactory(
     options,
     documentMetadataReader(markdownString)
@@ -286,7 +179,7 @@ async function processMarkdown(documentProcessorFactory, documentMetadataReader,
   return processed;
 }
 function readMarkdownMetadata(filepath, documentMetadataReader) {
-  return documentMetadataReader(fs2.readFileSync(filepath, "utf8"));
+  return documentMetadataReader(fs.readFileSync(filepath, "utf8"));
 }
 
 // src/config/resolve.ts
@@ -298,6 +191,29 @@ var manuscriptMediaTypes = [
   // a special MIME type indicates that a custom processor is used
   "text/x-vivliostyle-custom"
 ];
+function parseHexColor(hex) {
+  let r, g, b;
+  if (hex.length === 4 || hex.length === 5) {
+    r = parseInt(hex[1] + hex[1], 16);
+    g = parseInt(hex[2] + hex[2], 16);
+    b = parseInt(hex[3] + hex[3], 16);
+  } else {
+    r = parseInt(hex.slice(1, 3), 16);
+    g = parseInt(hex.slice(3, 5), 16);
+    b = parseInt(hex.slice(5, 7), 16);
+  }
+  return {
+    r: Math.round(r / 255 * 1e4),
+    g: Math.round(g / 255 * 1e4),
+    b: Math.round(b / 255 * 1e4)
+  };
+}
+function resolveMapEntries(entries) {
+  return entries.map(([rgb, cmyk]) => {
+    const resolvedRgb = typeof rgb === "string" ? parseHexColor(rgb) : rgb;
+    return [resolvedRgb, cmyk];
+  });
+}
 var UseTemporaryServerRoot = Symbol("UseTemporaryServerRoot");
 var DEFAULT_ASSET_EXTENSIONS = [
   "css",
@@ -319,7 +235,7 @@ function isManuscriptMediaType(mediaType) {
 }
 var htmlExtensions = [".html", ".htm", ".xhtml", ".xht"];
 function toHtmlExtension(filename) {
-  const ext = upath2.extname(filename).toLowerCase();
+  const ext = upath.extname(filename).toLowerCase();
   if (htmlExtensions.includes(
     // @ts-expect-error check membership
     ext
@@ -355,18 +271,18 @@ function parseTheme({
   if (isValidUri(specifier)) {
     return {
       type: "uri",
-      name: upath2.basename(specifier),
+      name: upath.basename(specifier),
       location: specifier
     };
   }
-  const stylePath = upath2.resolve(context, specifier);
-  if (fs3.existsSync(stylePath) && stylePath.endsWith(".css")) {
-    const sourceRelPath = upath2.relative(context, stylePath);
+  const stylePath = upath.resolve(context, specifier);
+  if (fs2.existsSync(stylePath) && stylePath.endsWith(".css")) {
+    const sourceRelPath = upath.relative(context, stylePath);
     return {
       type: "file",
-      name: upath2.basename(specifier),
+      name: upath.basename(specifier),
       source: stylePath,
-      location: upath2.resolve(workspaceDir, sourceRelPath)
+      location: upath.resolve(workspaceDir, sourceRelPath)
     };
   }
   const parsed = parsePackageName(specifier, context);
@@ -379,9 +295,9 @@ function parseTheme({
   let name = parsed.name;
   let resolvedSpecifier = specifier;
   if (parsed.type === "directory" && parsed.fetchSpec) {
-    const pkgJsonPath = upath2.join(parsed.fetchSpec, "package.json");
-    if (fs3.existsSync(pkgJsonPath)) {
-      const packageJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
+    const pkgJsonPath = upath.join(parsed.fetchSpec, "package.json");
+    if (fs2.existsSync(pkgJsonPath)) {
+      const packageJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf8"));
       name = packageJson.name;
       resolvedSpecifier = parsed.fetchSpec;
     }
@@ -393,7 +309,7 @@ function parseTheme({
     type: "package",
     name,
     specifier: resolvedSpecifier,
-    location: upath2.join(themesDir, "node_modules", name),
+    location: upath.join(themesDir, "node_modules", name),
     registry: Boolean(parsed.registry),
     importPath
   };
@@ -420,7 +336,7 @@ function parseFileMetadata({
   themesDir,
   documentMetadataReader
 }) {
-  const sourceDir = upath2.dirname(sourcePath);
+  const sourceDir = upath.dirname(sourcePath);
   let title;
   let themes;
   if (documentMetadataReader) {
@@ -439,7 +355,7 @@ function parseFileMetadata({
       );
     }
   } else if (contentType === "text/html" || contentType === "application/xhtml+xml") {
-    const content = fs3.readFileSync(sourcePath, "utf8");
+    const content = fs2.readFileSync(sourcePath, "utf8");
     title = content.match(/<title>([^<]*)<\/title>/)?.[1] || void 0;
   }
   return { title, themes };
@@ -451,23 +367,23 @@ function parseCustomStyle({
   if (isValidUri(customStyle)) {
     return customStyle;
   }
-  const stylePath = upath2.resolve(entryContextDir, customStyle);
+  const stylePath = upath.resolve(entryContextDir, customStyle);
   if (!pathContains(entryContextDir, stylePath)) {
     throw Error(
       `Custom style file ${customStyle} is not in ${entryContextDir}. Make sure the file is located in the context directory or a subdirectory.`
     );
   }
-  if (!fs3.existsSync(stylePath)) {
+  if (!fs2.existsSync(stylePath)) {
     throw new Error(`Custom style file not found: ${customStyle}`);
   }
-  return pathToFileURL2(stylePath).href.slice(
-    pathToFileURL2(entryContextDir).href.replace(/\/$/, "").length + 1
+  return pathToFileURL(stylePath).href.slice(
+    pathToFileURL(entryContextDir).href.replace(/\/$/, "").length + 1
   );
 }
 function resolveTaskConfig(config, options) {
   const context = options.cwd ?? cwd;
   Logger.debug("resolveTaskConfig > context %s", context);
-  const entryContextDir = config.entryContext ? upath2.resolve(context, config.entryContext) : context;
+  const entryContextDir = config.entryContext ? upath.resolve(context, config.entryContext) : context;
   const language = config.language;
   const readingProgression = config.readingProgression;
   const size = config.size ? parsePageSize(config.size) : void 0;
@@ -517,12 +433,18 @@ function resolveTaskConfig(config, options) {
       if (cmykOption && typeof cmykOption === "object") {
         return {
           warnUnmapped: cmykOption.warnUnmapped ?? true,
-          overrideMap: cmykOption.overrideMap ?? [],
-          mapOutput: cmykOption.mapOutput ? upath2.resolve(context, cmykOption.mapOutput) : void 0
+          overrideMap: resolveMapEntries(cmykOption.overrideMap ?? []),
+          reserveMap: resolveMapEntries(cmykOption.reserveMap ?? []),
+          mapOutput: cmykOption.mapOutput ? upath.resolve(context, cmykOption.mapOutput) : void 0
         };
       }
       if (options.cmyk || cmykOption === true) {
-        return { warnUnmapped: true, overrideMap: [], mapOutput: void 0 };
+        return {
+          warnUnmapped: true,
+          overrideMap: [],
+          reserveMap: [],
+          mapOutput: void 0
+        };
       }
       return false;
     };
@@ -537,16 +459,16 @@ function resolveTaskConfig(config, options) {
       return replaceImageOption.flatMap(({ source, replacement }) => {
         if (source instanceof RegExp) {
           return allFiles.filter((file) => source.test(file)).map((file) => ({
-            source: upath2.resolve(entryContextDir, file),
-            replacement: upath2.resolve(
+            source: upath.resolve(entryContextDir, file),
+            replacement: upath.resolve(
               entryContextDir,
               file.replace(source, replacement)
             )
           }));
         }
         return {
-          source: upath2.resolve(entryContextDir, source),
-          replacement: upath2.resolve(entryContextDir, replacement)
+          source: upath.resolve(entryContextDir, source),
+          replacement: upath.resolve(entryContextDir, replacement)
         };
       });
     };
@@ -581,7 +503,7 @@ function resolveTaskConfig(config, options) {
     };
     if (config.output) {
       return config.output.map((target) => {
-        const outputPath = upath2.resolve(context, target.path);
+        const outputPath = upath.resolve(context, target.path);
         const format = target.format;
         switch (format) {
           case "pdf": {
@@ -634,7 +556,7 @@ function resolveTaskConfig(config, options) {
     return [
       {
         ...defaultPdfOptions,
-        path: upath2.resolve(context, filename)
+        path: upath.resolve(context, filename)
       }
     ];
   })();
@@ -662,7 +584,7 @@ function resolveTaskConfig(config, options) {
     };
   })();
   const cover = config.cover && {
-    src: upath2.resolve(entryContextDir, config.cover.src),
+    src: upath.resolve(entryContextDir, config.cover.src),
     name: config.cover.name || COVER_HTML_IMAGE_ALT
   };
   const copyAsset = {
@@ -695,7 +617,7 @@ function resolveTaskConfig(config, options) {
     cover
   });
   for (const output of outputs) {
-    const relPath = upath2.relative(context, output.path);
+    const relPath = upath.relative(context, output.path);
     if (pathContains(output.path, entryContextDir) || pathEquals(output.path, entryContextDir)) {
       throw new Error(
         `The output path is set to "${relPath}", but this will overwrite the original manuscript file. Please specify a different path.`
@@ -716,7 +638,7 @@ function resolveTaskConfig(config, options) {
       (entry) => entry.target === duplicatedTarget && entry.source?.type === "file"
     )?.source;
     throw new Error(
-      `The output path "${upath2.relative(workspaceDir, duplicatedTarget)}" will overwrite existing content.` + (sourceFile ? ` Please choose a different name for the source file: ${sourceFile.pathname}` : "")
+      `The output path "${upath.relative(workspaceDir, duplicatedTarget)}" will overwrite existing content.` + (sourceFile ? ` Please choose a different name for the source file: ${sourceFile.pathname}` : "")
     );
   }
   const resolvedConfig = {
@@ -784,7 +706,7 @@ function resolveSingleInputConfig({
       sourcePath = input.entry;
     }
   } else {
-    sourcePath = upath2.resolve(context, input.entry);
+    sourcePath = upath.resolve(context, input.entry);
   }
   if (isLocalResource) {
     statFileSync(sourcePath);
@@ -793,7 +715,7 @@ function resolveSingleInputConfig({
       case "markdown":
       case "pub-manifest":
       case "epub":
-        workspaceDir = upath2.dirname(sourcePath);
+        workspaceDir = upath.dirname(sourcePath);
         break;
       case "epub-opf": {
         const rootDir = getEpubRootDir(sourcePath);
@@ -813,7 +735,7 @@ function resolveSingleInputConfig({
     serverRootDir = UseTemporaryServerRoot;
     workspaceDir = context;
   }
-  const themesDir = upath2.resolve(workspaceDir, "themes");
+  const themesDir = upath.resolve(workspaceDir, "themes");
   if (input.format === "markdown") {
     const contentType = "text/markdown";
     const documentProcessor = {
@@ -827,9 +749,9 @@ function resolveSingleInputConfig({
       documentMetadataReader: documentProcessor.metadataReader
     });
     const target = toHtmlExtension(
-      upath2.resolve(
+      upath.resolve(
         workspaceDir,
-        `${temporaryFilePrefix}${upath2.basename(sourcePath)}`
+        `${temporaryFilePrefix}${upath.basename(sourcePath)}`
       )
     );
     touchTmpFile(target);
@@ -856,25 +778,25 @@ function resolveSingleInputConfig({
     });
     exportAliases.push({
       source: target,
-      target: upath2.resolve(
-        upath2.dirname(target),
-        toHtmlExtension(upath2.basename(sourcePath))
+      target: upath.resolve(
+        upath.dirname(target),
+        toHtmlExtension(upath.basename(sourcePath))
       )
     });
   }
   let fallbackTitle;
   let viewerInput;
   if (inputFormat === "markdown") {
-    const manifestPath = upath2.resolve(
+    const manifestPath = upath.resolve(
       workspaceDir,
       `${temporaryFilePrefix}${MANIFEST_FILENAME}`
     );
     touchTmpFile(manifestPath);
     exportAliases.push({
       source: manifestPath,
-      target: upath2.resolve(workspaceDir, MANIFEST_FILENAME)
+      target: upath.resolve(workspaceDir, MANIFEST_FILENAME)
     });
-    fallbackTitle = entries.length === 1 && entries[0].title ? entries[0].title : upath2.basename(sourcePath);
+    fallbackTitle = entries.length === 1 && entries[0].title ? entries[0].title : upath.basename(sourcePath);
     viewerInput = {
       type: "webpub",
       manifestPath,
@@ -887,8 +809,8 @@ function resolveSingleInputConfig({
       const url = new URL(sourcePath);
       webbookEntryUrl = url.href;
     } else {
-      const rootFileUrl = pathToFileURL2(workspaceDir).href;
-      const urlPath = pathToFileURL2(sourcePath).href.slice(rootFileUrl.length);
+      const rootFileUrl = pathToFileURL(workspaceDir).href;
+      const urlPath = pathToFileURL(sourcePath).href.slice(rootFileUrl.length);
       webbookEntryUrl = `${base}${urlPath}`;
       webbookPath = sourcePath;
     }
@@ -905,9 +827,9 @@ function resolveSingleInputConfig({
     viewerInput = {
       type: "epub",
       epubPath: sourcePath,
-      epubTmpOutputDir: upath2.join(
+      epubTmpOutputDir: upath.join(
         sourcePath,
-        `../${temporaryFilePrefix}${upath2.basename(sourcePath)}`
+        `../${temporaryFilePrefix}${upath.basename(sourcePath)}`
       )
     };
   } else {
@@ -938,13 +860,13 @@ function resolveComposedProjectConfig({
   cover
 }) {
   Logger.debug("entering composed project config mode");
-  const workspaceDir = upath2.resolve(
+  const workspaceDir = upath.resolve(
     context,
     config.workspaceDir ?? ".vivliostyle"
   );
-  const themesDir = upath2.resolve(workspaceDir, "themes");
-  const pkgJsonPath = upath2.resolve(context, "package.json");
-  const pkgJson = fs3.existsSync(pkgJsonPath) ? readJSON(pkgJsonPath) : void 0;
+  const themesDir = upath.resolve(workspaceDir, "themes");
+  const pkgJsonPath = upath.resolve(context, "package.json");
+  const pkgJson = fs2.existsSync(pkgJsonPath) ? readJSON(pkgJsonPath) : void 0;
   if (pkgJson) {
     Logger.debug("located package.json path", pkgJsonPath);
   }
@@ -960,19 +882,19 @@ function resolveComposedProjectConfig({
   rootThemes.forEach((t) => themeIndexes.add(t));
   const tocConfig = {
     tocTitle: config.toc?.title ?? config?.tocTitle ?? TOC_TITLE,
-    target: upath2.resolve(workspaceDir, config.toc?.htmlPath ?? TOC_FILENAME),
+    target: upath.resolve(workspaceDir, config.toc?.htmlPath ?? TOC_FILENAME),
     sectionDepth: config.toc?.sectionDepth ?? 0,
     transform: {
       transformDocumentList: config.toc?.transformDocumentList,
       transformSectionList: config.toc?.transformSectionList
     }
   };
-  const coverHtml = config.cover && ("htmlPath" in config.cover && !config.cover.htmlPath ? void 0 : upath2.resolve(
+  const coverHtml = config.cover && ("htmlPath" in config.cover && !config.cover.htmlPath ? void 0 : upath.resolve(
     workspaceDir,
     config.cover?.htmlPath || COVER_HTML_FILENAME
   ));
   const ensureCoverImage = (src) => {
-    const absPath = src && upath2.resolve(entryContextDir, src);
+    const absPath = src && upath.resolve(entryContextDir, src);
     if (absPath) {
       statFileSync(absPath, {
         errorMessage: "Specified cover image does not exist"
@@ -995,16 +917,16 @@ function resolveComposedProjectConfig({
         return {
           type: "uri",
           href: entryPath,
-          rootDir: upath2.join(workspaceDir, new URL(entryPath).host)
+          rootDir: upath.join(workspaceDir, new URL(entryPath).host)
         };
       } else if (entryPath.startsWith("/")) {
         return {
           type: "uri",
           href: entryPath,
-          rootDir: upath2.join(workspaceDir, "localhost")
+          rootDir: upath.join(workspaceDir, "localhost")
         };
       }
-      const pathname = upath2.resolve(entryContextDir, entryPath);
+      const pathname = upath.resolve(entryContextDir, entryPath);
       statFileSync(pathname);
       const rawContentType = mime(pathname);
       const documentProcessor = {
@@ -1036,9 +958,9 @@ function resolveComposedProjectConfig({
     const getTargetPath = (source) => {
       switch (source.type) {
         case "file":
-          return upath2.resolve(
+          return upath.resolve(
             workspaceDir,
-            toHtmlExtension(upath2.relative(entryContextDir, source.pathname))
+            toHtmlExtension(upath.relative(entryContextDir, source.pathname))
           );
         case "uri": {
           const url = new URL(source.href, "a://dummy");
@@ -1046,14 +968,14 @@ function resolveComposedProjectConfig({
           if (!/\.\w+$/.test(pathname)) {
             pathname = `${pathname.replace(/\/$/, "")}/index.html`;
           }
-          return upath2.join(source.rootDir, pathname);
+          return upath.join(source.rootDir, pathname);
         }
         default:
           return source;
       }
     };
     if ((isContentsEntry(entry) || isCoverEntry(entry)) && entry.path) {
-      const source = upath2.resolve(entryContextDir, entry.path);
+      const source = upath.resolve(entryContextDir, entry.path);
       try {
         statFileSync(source);
       } catch (error) {
@@ -1068,7 +990,7 @@ Maybe you want to set the "output" field instead.`
     if (isContentsEntry(entry)) {
       const inputInfo = entry.path ? getInputInfo(entry.path) : void 0;
       const { metadata, ...template } = inputInfo || {};
-      let target = entry.output ? upath2.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
+      let target = entry.output ? upath.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({
           theme,
@@ -1080,9 +1002,9 @@ Maybe you want to set the "output" field instead.`
       themes.forEach((t) => themeIndexes.add(t));
       target ??= tocConfig.target;
       if (inputInfo?.type === "file" && pathEquals(inputInfo.pathname, target)) {
-        const tmpPath = upath2.resolve(
-          upath2.dirname(target),
-          `${temporaryFilePrefix}${upath2.basename(target)}`
+        const tmpPath = upath.resolve(
+          upath.dirname(target),
+          `${temporaryFilePrefix}${upath.basename(target)}`
         );
         exportAliases.push({ source: tmpPath, target });
         touchTmpFile(tmpPath);
@@ -1103,7 +1025,7 @@ Maybe you want to set the "output" field instead.`
     if (isCoverEntry(entry)) {
       const inputInfo = entry.path ? getInputInfo(entry.path) : void 0;
       const { metadata, ...template } = inputInfo || {};
-      let target = entry.output ? upath2.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
+      let target = entry.output ? upath.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({
           theme,
@@ -1119,14 +1041,14 @@ Maybe you want to set the "output" field instead.`
           `A CoverEntryConfig is set in the entry list but a location of cover file is not set. Please set 'cover' property in your config file.`
         );
       }
-      target ??= upath2.resolve(
+      target ??= upath.resolve(
         workspaceDir,
         entry.path || coverHtml || COVER_HTML_FILENAME
       );
       if (inputInfo?.type === "file" && pathEquals(inputInfo.pathname, target)) {
-        const tmpPath = upath2.resolve(
-          upath2.dirname(target),
-          `${temporaryFilePrefix}${upath2.basename(target)}`
+        const tmpPath = upath.resolve(
+          upath.dirname(target),
+          `${temporaryFilePrefix}${upath.basename(target)}`
         );
         exportAliases.push({ source: tmpPath, target });
         touchTmpFile(tmpPath);
@@ -1147,7 +1069,7 @@ Maybe you want to set the "output" field instead.`
     if (isArticleEntry(entry)) {
       const inputInfo = getInputInfo(entry.path);
       const { metadata, ...source } = inputInfo;
-      const target = entry.output ? upath2.resolve(workspaceDir, entry.output) : getTargetPath(inputInfo);
+      const target = entry.output ? upath.resolve(workspaceDir, entry.output) : getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({ theme, context, workspaceDir, themesDir })
       ) : metadata?.themes ?? [...rootThemes];
@@ -1170,7 +1092,7 @@ Maybe you want to set the "output" field instead.`
     if (entries.length === 1 && entries[0].title) {
       fallbackProjectTitle = entries[0].title;
     } else {
-      fallbackProjectTitle = upath2.basename(outputs[0].path);
+      fallbackProjectTitle = upath.basename(outputs[0].path);
     }
   }
   if (!!config?.toc && !entries.find(({ rel }) => rel === "contents")) {
@@ -1198,11 +1120,11 @@ Maybe you want to set the "output" field instead.`
     entries,
     input: {
       format: "pub-manifest",
-      entry: upath2.join(workspaceDir, MANIFEST_FILENAME)
+      entry: upath.join(workspaceDir, MANIFEST_FILENAME)
     },
     viewerInput: {
       type: "webpub",
-      manifestPath: upath2.join(workspaceDir, MANIFEST_FILENAME),
+      manifestPath: upath.join(workspaceDir, MANIFEST_FILENAME),
       needToGenerateManifest: true
     },
     exportAliases,
@@ -1215,8 +1137,8 @@ Maybe you want to set the "output" field instead.`
 import "vite";
 
 // src/browser.ts
-import fs4 from "node:fs";
-import upath3 from "upath";
+import fs3 from "node:fs";
+import upath2 from "upath";
 var browserEnumMap = {
   chrome: "chrome",
   chromium: "chromium",
@@ -1317,20 +1239,20 @@ function getPuppeteerCacheDir() {
   if (isInContainer()) {
     return "/opt/puppeteer";
   }
-  return upath3.join(getCacheDir(), "browsers");
+  return upath2.join(getCacheDir(), "browsers");
 }
 async function resolveBuildId({
   type,
   tag,
   browsers
 }) {
-  const cacheDataFilename = upath3.join(
+  const cacheDataFilename = upath2.join(
     getPuppeteerCacheDir(),
     "build-ids.json"
   );
   let cacheData;
   try {
-    cacheData = JSON.parse(fs4.readFileSync(cacheDataFilename, "utf-8"));
+    cacheData = JSON.parse(fs3.readFileSync(cacheDataFilename, "utf-8"));
     if (Date.now() - cacheData.createdAt > 24 * 60 * 60 * 1e3) {
       cacheData = { createdAt: Date.now(), buildIds: {} };
     }
@@ -1350,23 +1272,23 @@ async function resolveBuildId({
     tag
   );
   (cacheData.buildIds[type] ??= {})[tag] = buildId;
-  fs4.mkdirSync(upath3.dirname(cacheDataFilename), { recursive: true });
-  fs4.writeFileSync(cacheDataFilename, JSON.stringify(cacheData));
+  fs3.mkdirSync(upath2.dirname(cacheDataFilename), { recursive: true });
+  fs3.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)) {
+    const browsersDir = upath2.join(getPuppeteerCacheDir(), browser);
+    if (!fs3.existsSync(browsersDir)) {
       continue;
     }
-    const entries = fs4.readdirSync(browsersDir);
+    const entries = fs3.readdirSync(browsersDir);
     for (const entry of entries) {
-      const entryPath = upath3.join(browsersDir, entry);
-      const stat = fs4.statSync(entryPath);
+      const entryPath = upath2.join(browsersDir, entry);
+      const stat = fs3.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 });
+        await fs3.promises.rm(entryPath, { recursive: true, force: true });
       }
     }
   }
@@ -1384,7 +1306,7 @@ async function getExecutableBrowserPath({
   });
 }
 function checkBrowserAvailability(path) {
-  return fs4.existsSync(path);
+  return fs3.existsSync(path);
 }
 async function downloadBrowser({
   type,
@@ -1486,9 +1408,9 @@ async function launchPreview({
 }
 
 // src/server.ts
-import fs10 from "node:fs";
+import fs9 from "node:fs";
 import { URL as URL2 } from "node:url";
-import upath12 from "upath";
+import upath11 from "upath";
 import {
   createServer,
   preview
@@ -1496,26 +1418,26 @@ import {
 
 // src/vite/vite-plugin-dev-server.ts
 import escapeRe from "escape-string-regexp";
-import { pathToFileURL as pathToFileURL6 } from "node:url";
+import { pathToFileURL as pathToFileURL5 } from "node:url";
 import sirv from "sirv";
-import upath9 from "upath";
+import upath8 from "upath";
 import "vite";
 
 // src/processor/compile.ts
 import "@vivliostyle/jsdom";
 import { copy as copy3, move } from "fs-extra/esm";
-import fs8 from "node:fs";
-import upath8 from "upath";
+import fs7 from "node:fs";
+import upath7 from "upath";
 import serializeToXml2 from "w3c-xmlserializer";
 import MIMEType2 from "whatwg-mimetype";
 
 // src/output/webbook.ts
 import { copy as copy2 } from "fs-extra/esm";
 import { lookup as mime3 } from "mime-types";
-import fs6 from "node:fs";
-import { pathToFileURL as pathToFileURL5 } from "node:url";
+import fs5 from "node:fs";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
 import { glob } from "tinyglobby";
-import upath6 from "upath";
+import upath5 from "upath";
 
 // src/processor/html.tsx
 import jsdom, {
@@ -1524,8 +1446,8 @@ import jsdom, {
 } from "@vivliostyle/jsdom";
 import DOMPurify from "dompurify";
 import { toHtml } from "hast-util-to-html";
-import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
-import upath4 from "upath";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+import upath3 from "upath";
 import MIMEType from "whatwg-mimetype";
 import { jsx, jsxs } from "hastscript/jsx-runtime";
 var createVirtualConsole = (onError) => {
@@ -1558,10 +1480,7 @@ var createVirtualConsole = (onError) => {
   });
   return virtualConsole;
 };
-var htmlPurify = DOMPurify(
-  // @ts-expect-error: jsdom.DOMWindow should have trustedTypes property
-  new JSDOM("").window
-);
+var htmlPurify = DOMPurify(new JSDOM("").window);
 var ResourceLoader = class _ResourceLoader extends BaseResourceLoader {
   static dataUrlOrigin = "http://localhost/";
   fetcherMap = /* @__PURE__ */ new Map();
@@ -1586,7 +1505,7 @@ var ResourceLoader = class _ResourceLoader extends BaseResourceLoader {
       if (mimeType === "text/html" && !/\.html?$/.test(url.pathname)) {
         url.pathname = `${url.pathname.replace(/\/$/, "")}/index.html`;
       }
-      let relTarget = upath4.relative(rootHref, url.href);
+      let relTarget = upath3.relative(rootHref, url.href);
       return decodeURI(relTarget);
     };
     const fetchedResources = [];
@@ -1605,7 +1524,7 @@ var ResourceLoader = class _ResourceLoader extends BaseResourceLoader {
           } catch (e) {
           }
           const relTarget = normalizeToLocalPath(url, encodingFormat);
-          const target = upath4.join(outputDir, relTarget);
+          const target = upath3.join(outputDir, relTarget);
           fetchedResources.push({ url: relTarget, encodingFormat });
           writeFileIfChanged(target, buffer);
         }).catch(onError);
@@ -1621,7 +1540,7 @@ async function getJsdomFromUrlOrFile({
     throw error;
   })
 }) {
-  const url = isValidUri(src) ? new URL(src) : pathToFileURL3(src);
+  const url = isValidUri(src) ? new URL(src) : pathToFileURL2(src);
   let dom;
   if (url.protocol === "http:" || url.protocol === "https:") {
     dom = await JSDOM.fromURL(src, {
@@ -1802,11 +1721,11 @@ async function generateTocListSection({
   } = transform;
   const structure = await Promise.all(
     entries.map(async (entry) => {
-      const href = encodeURI(upath4.relative(distDir, entry.target));
+      const href = encodeURI(upath3.relative(distDir, entry.target));
       const sections = sectionDepth >= 1 ? await getStructuredSectionFromHtml(entry.target, href) : [];
       return {
-        title: entry.title || upath4.basename(entry.target, ".html"),
-        href: encodeURI(upath4.relative(distDir, entry.target)),
+        title: entry.title || upath3.basename(entry.target, ".html"),
+        href: encodeURI(upath3.relative(distDir, entry.target)),
         sections,
         children: []
         // TODO
@@ -1854,7 +1773,7 @@ async function processTocHtml(dom, {
     const l = document2.createElement("link");
     l.setAttribute("rel", "publication");
     l.setAttribute("type", "application/ld+json");
-    l.setAttribute("href", encodeURI(upath4.relative(distDir, manifestPath)));
+    l.setAttribute("href", encodeURI(upath3.relative(distDir, manifestPath)));
     document2.head.appendChild(l);
   }
   const style = document2.querySelector("style[data-vv-style]");
@@ -2112,13 +2031,13 @@ function parsePageListDocument(dom) {
 // src/output/epub.ts
 import archiver from "archiver";
 import { lookup as lookupLanguage } from "bcp-47-match";
-import { XMLBuilder } from "fast-xml-parser";
+import XMLBuilder from "fast-xml-builder";
 import { copy } from "fs-extra/esm";
 import GithubSlugger from "github-slugger";
 import { lookup as mime2 } from "mime-types";
-import fs5 from "node:fs";
-import { pathToFileURL as pathToFileURL4 } from "node:url";
-import upath5 from "upath";
+import fs4 from "node:fs";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+import upath4 from "upath";
 import { v4 as uuid } from "uuid";
 import serializeToXml from "w3c-xmlserializer";
 var TOC_ID = "toc";
@@ -2132,21 +2051,21 @@ var COVER_IMAGE_MIMETYPES = [
   "image/webp"
 ];
 var changeExtname = (filepath, newExt) => {
-  let ext = upath5.extname(filepath);
+  let ext = upath4.extname(filepath);
   return `${filepath.slice(0, -ext.length)}${newExt}`;
 };
 var getRelativeHref = (target, baseUrl, rootUrl) => {
-  const absBasePath = upath5.join("/", baseUrl);
-  const absRootPath = upath5.join("/", rootUrl);
-  const hrefUrl = new URL(encodeURI(target), pathToFileURL4(absBasePath));
+  const absBasePath = upath4.join("/", baseUrl);
+  const absRootPath = upath4.join("/", rootUrl);
+  const hrefUrl = new URL(encodeURI(target), pathToFileURL3(absBasePath));
   if (hrefUrl.protocol !== "file:") {
     return target;
   }
   if (/\.html?$/.test(hrefUrl.pathname)) {
     hrefUrl.pathname = changeExtname(hrefUrl.pathname, ".xhtml");
   }
-  const pathname = upath5.posix.relative(
-    pathToFileURL4(upath5.dirname(absRootPath)).pathname,
+  const pathname = upath4.posix.relative(
+    pathToFileURL3(upath4.dirname(absRootPath)).pathname,
     hrefUrl.pathname
   );
   return `${pathname}${hrefUrl.search}${hrefUrl.hash}`;
@@ -2157,16 +2076,16 @@ var normalizeLocalizableString = (value, availableLanguages) => {
   }
   const values = [value].flat().map((value2) => typeof value2 === "string" ? { value: value2 } : value2);
   const localizedValues = values.filter(
-    (v2) => !!v2.language
+    (v) => !!v.language
   );
   const preferredLang = lookupLanguage(
-    localizedValues.map((v2) => v2.language),
+    localizedValues.map((v) => v.language),
     availableLanguages
   );
   if (preferredLang) {
-    return localizedValues[localizedValues.findIndex((v2) => v2.language === preferredLang)].value;
+    return localizedValues[localizedValues.findIndex((v) => v.language === preferredLang)].value;
   }
-  return values.find((v2) => !v2.language)?.value;
+  return values.find((v) => !v.language)?.value;
 };
 var appendManifestProperty = (entry, newProperty) => {
   entry.properties = entry.properties ? Array.from(/* @__PURE__ */ new Set([...entry.properties.split(" "), newProperty])).join(
@@ -2189,10 +2108,10 @@ async function exportEpub({
     epubVersion
   });
   const [tmpDir] = await useTmpDirectory();
-  fs5.mkdirSync(upath5.join(tmpDir, "META-INF"), { recursive: true });
-  await copy(webpubDir, upath5.join(tmpDir, "EPUB"));
+  fs4.mkdirSync(upath4.join(tmpDir, "META-INF"), { recursive: true });
+  await copy(webpubDir, upath4.join(tmpDir, "EPUB"));
   const uid = `urn:uuid:${uuid()}`;
-  const entryHtmlRelPath = entryHtmlFile && upath5.relative(webpubDir, upath5.resolve(webpubDir, entryHtmlFile));
+  const entryHtmlRelPath = entryHtmlFile && upath4.relative(webpubDir, upath4.resolve(webpubDir, entryHtmlFile));
   const findPublicationLink = (relType, list, filter) => [list].flat().find(
     (e) => typeof e === "object" && e.rel === relType && (!filter || filter(e))
   );
@@ -2229,7 +2148,7 @@ async function exportEpub({
         return acc;
       } catch (e) {
       }
-      if (!fs5.existsSync(upath5.join(tmpDir, "EPUB", url))) {
+      if (!fs4.existsSync(upath4.join(tmpDir, "EPUB", url))) {
         return acc;
       }
       const mediaType = encodingFormat || mime2(url) || "text/plain";
@@ -2252,7 +2171,7 @@ async function exportEpub({
     (url) => /\.html?$/.test(url)
   );
   let tocHtml = htmlFiles.find((f) => f === tocResource?.url);
-  const readingOrder = [manifest.readingOrder || entryHtmlRelPath].flat().flatMap((v2) => v2 ? typeof v2 === "string" ? { url: v2 } : v2 : []);
+  const readingOrder = [manifest.readingOrder || entryHtmlRelPath].flat().flatMap((v) => v ? typeof v === "string" ? { url: v } : v : []);
   if (!tocHtml) {
     Logger.logWarn(
       "No table of contents document was found. for EPUB output, we recommend to enable `toc` option in your Vivliostyle config file to generate a table of contents document."
@@ -2283,7 +2202,7 @@ async function exportEpub({
       text: EPUB_LANDMARKS_COVER_ENTRY
     });
   }
-  const contextDir = upath5.join(tmpDir, "EPUB");
+  const contextDir = upath4.join(tmpDir, "EPUB");
   const processHtml = async (target2) => {
     let parseResult;
     try {
@@ -2320,7 +2239,7 @@ async function exportEpub({
     processResult[target2] = await processHtml(target2);
   }
   const { document: entryDocument } = processResult[tocHtml].dom.window;
-  const docLanguages = [manifest.inLanguage].flat().filter((v2) => Boolean(v2));
+  const docLanguages = [manifest.inLanguage].flat().filter((v) => Boolean(v));
   if (docLanguages.length === 0) {
     docLanguages.push(entryDocument.documentElement.lang || "en");
   }
@@ -2345,20 +2264,20 @@ async function exportEpub({
     });
   }
   if (relManifestPath) {
-    await fs5.promises.rm(upath5.join(tmpDir, "EPUB", relManifestPath), {
+    await fs4.promises.rm(upath4.join(tmpDir, "EPUB", relManifestPath), {
       force: true,
       recursive: true
     });
     delete manifestItem[relManifestPath];
   }
-  fs5.writeFileSync(
-    upath5.join(tmpDir, "META-INF/container.xml"),
+  fs4.writeFileSync(
+    upath4.join(tmpDir, "META-INF/container.xml"),
     EPUB_CONTAINER_XML,
     "utf8"
   );
   Logger.debug(`Generating content.opf`);
-  fs5.writeFileSync(
-    upath5.join(tmpDir, "EPUB/content.opf"),
+  fs4.writeFileSync(
+    upath4.join(tmpDir, "EPUB/content.opf"),
     buildEpubPackageDocument({
       epubVersion,
       uid,
@@ -2375,13 +2294,13 @@ async function exportEpub({
 async function writeAsXhtml(dom, absPath) {
   const xhtml = `${XML_DECLARATION}
 ${serializeToXml(dom.window.document)}`;
-  await fs5.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
+  await fs4.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
 }
 async function transpileHtmlToXhtml({
   target,
   contextDir
 }) {
-  const absPath = upath5.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   const dom = await getJsdomFromUrlOrFile({ src: absPath });
   const { document: document2 } = dom.window;
   document2.documentElement.removeAttribute("xmlns");
@@ -2391,7 +2310,7 @@ async function transpileHtmlToXhtml({
     el.setAttribute("href", getRelativeHref(href, target, target));
   });
   await writeAsXhtml(dom, absPath);
-  await fs5.promises.unlink(absPath);
+  await fs4.promises.unlink(absPath);
   return {
     dom,
     // FIXME: Yes, I recognize this implementation is inadequate.
@@ -2449,7 +2368,7 @@ async function processTocDocument({
         let name = normalizeLocalizableString(content.name, docLanguages);
         if (!name) {
           const dom2 = await getJsdomFromUrlOrFile({
-            src: upath5.join(contextDir, changeExtname(content.url, ".xhtml"))
+            src: upath4.join(contextDir, changeExtname(content.url, ".xhtml"))
           });
           name = dom2.window.document.title;
         }
@@ -2502,7 +2421,7 @@ async function processTocDocument({
     }
     publicationLinkEl.parentNode?.removeChild(publicationLinkEl);
   }
-  const absPath = upath5.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { tocResourceTree };
 }
@@ -2517,7 +2436,7 @@ async function processPagelistDocument({
     nav.setAttribute("id", PAGELIST_ID);
     nav.setAttribute("epub:type", "page-list");
   }
-  const absPath = upath5.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { pageListResourceTree };
 }
@@ -2534,7 +2453,7 @@ function buildEpubPackageDocument({
   slugger.reset();
   const bookIdentifier = slugger.slug("bookid");
   const normalizeDate = (value) => value && `${new Date(value).toISOString().split(".")[0]}Z`;
-  const transformToGenericTextNode = (value, attributes) => [value].flat().filter(Boolean).map((v2) => ({ ...attributes || {}, "#text": `${value}` }));
+  const transformToGenericTextNode = (value, attributes) => [value].flat().filter(Boolean).map((v) => ({ ...attributes || {}, "#text": `${value}` }));
   const transformContributor = (contributorMap) => Object.entries(contributorMap).flatMap(
     ([type, contributor]) => contributor ? [contributor].flat().map((entry, index) => ({
       _id: slugger.slug(`${type}-${index + 1}`),
@@ -2636,7 +2555,7 @@ async function compressEpub({
   sourceDir
 }) {
   Logger.debug(`Compressing EPUB: ${target}`);
-  const output = fs5.createWriteStream(target);
+  const output = fs4.createWriteStream(target);
   const archive = archiver("zip", {
     zlib: { level: 9 }
     // Compression level
@@ -2656,8 +2575,8 @@ async function compressEpub({
       // https://www.w3.org/TR/epub-33/#sec-zip-container-mime
       store: true
     });
-    archive.directory(upath5.join(sourceDir, "META-INF"), "META-INF");
-    archive.directory(upath5.join(sourceDir, "EPUB"), "EPUB");
+    archive.directory(upath4.join(sourceDir, "META-INF"), "META-INF");
+    archive.directory(upath4.join(sourceDir, "EPUB"), "EPUB");
     archive.finalize();
   });
 }
@@ -2674,11 +2593,11 @@ function sortManifestResources(manifest) {
 async function prepareWebPublicationDirectory({
   outputDir
 }) {
-  if (fs6.existsSync(outputDir)) {
+  if (fs5.existsSync(outputDir)) {
     Logger.debug("going to remove existing webpub", outputDir);
-    await fs6.promises.rm(outputDir, { force: true, recursive: true });
+    await fs5.promises.rm(outputDir, { force: true, recursive: true });
   }
-  fs6.mkdirSync(outputDir, { recursive: true });
+  fs5.mkdirSync(outputDir, { recursive: true });
 }
 function transformPublicationManifest(entity, transformer) {
   const { url: transformUrl } = transformer;
@@ -2775,15 +2694,15 @@ function writePublicationManifest(output, options) {
       typeof thrownError === "string" ? thrownError : thrownError.stack ?? thrownError.message
     );
   }
-  fs6.mkdirSync(upath6.dirname(output), { recursive: true });
-  fs6.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
+  fs5.mkdirSync(upath5.dirname(output), { recursive: true });
+  fs5.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
   return publication;
 }
 async function retrieveWebbookEntry({
   viewerInput,
   outputDir
 }) {
-  const webbookEntryUrl = viewerInput.webbookPath ? pathToFileURL5(viewerInput.webbookPath).href : viewerInput.webbookEntryUrl;
+  const webbookEntryUrl = viewerInput.webbookPath ? pathToFileURL4(viewerInput.webbookPath).href : viewerInput.webbookEntryUrl;
   if (/^https?:/i.test(webbookEntryUrl)) {
     Logger.logUpdate("Fetching remote contents");
   }
@@ -2792,7 +2711,7 @@ async function retrieveWebbookEntry({
     src: webbookEntryUrl,
     resourceLoader
   });
-  const entryHtml = viewerInput.webbookPath ? upath6.basename(viewerInput.webbookPath) : decodeURI(dom.window.location.pathname);
+  const entryHtml = viewerInput.webbookPath ? upath5.basename(viewerInput.webbookPath) : decodeURI(dom.window.location.pathname);
   const { manifest, manifestUrl } = await fetchLinkedPublicationManifest({
     dom,
     resourceLoader,
@@ -2803,12 +2722,12 @@ async function retrieveWebbookEntry({
     pathContains2 = (url) => false;
   } else {
     const rootUrl = /^https?:/i.test(webbookEntryUrl) ? new URL("/", webbookEntryUrl).href : new URL(".", webbookEntryUrl).href;
-    pathContains2 = (url) => !upath6.relative(rootUrl, url).startsWith("..");
+    pathContains2 = (url) => !upath5.relative(rootUrl, url).startsWith("..");
   }
   const retriever = new Map(resourceLoader.fetcherMap);
   if (manifest && manifestUrl) {
-    [manifest.resources || []].flat().forEach((v2) => {
-      const url = typeof v2 === "string" ? v2 : v2.url;
+    [manifest.resources || []].flat().forEach((v) => {
+      const url = typeof v === "string" ? v : v.url;
       const fullUrl = new URL(encodeURI(url), manifestUrl).href;
       if (!pathContains2(fullUrl) || retriever.has(fullUrl)) {
         return;
@@ -2818,9 +2737,9 @@ async function retrieveWebbookEntry({
         retriever.set(fullUrl, fetchPromise);
       }
     });
-    for (const v2 of [manifest.readingOrder || []].flat()) {
-      const url = typeof v2 === "string" ? v2 : v2.url;
-      if (!/\.html?$/.test(url) && !(typeof v2 === "string" || v2.encodingFormat === "text/html")) {
+    for (const v of [manifest.readingOrder || []].flat()) {
+      const url = typeof v === "string" ? v : v.url;
+      if (!/\.html?$/.test(url) && !(typeof v === "string" || v.encodingFormat === "text/html")) {
         continue;
       }
       const fullUrl = new URL(encodeURI(url), manifestUrl).href;
@@ -2836,7 +2755,7 @@ async function retrieveWebbookEntry({
         })
       });
       subpathResourceLoader.fetcherMap.forEach(
-        (v3, k) => !retriever.has(k) && retriever.set(k, v3)
+        (v2, k) => !retriever.has(k) && retriever.set(k, v2)
       );
     }
   }
@@ -2854,7 +2773,7 @@ async function retrieveWebbookEntry({
     const referencedContents = [
       ...[manifest.readingOrder || []].flat(),
       ...[manifest.resources || []].flat()
-    ].map((v2) => typeof v2 === "string" ? v2 : v2.url);
+    ].map((v) => typeof v === "string" ? v : v.url);
     manifest.resources = [
       ...[manifest.resources || []].flat(),
       ...fetchedResources.filter(
@@ -2865,17 +2784,17 @@ async function retrieveWebbookEntry({
   }
   Logger.debug(
     "Saved webbook resources",
-    fetchedResources.map((v2) => v2.url)
+    fetchedResources.map((v) => v.url)
   );
   Logger.debug(
     "Publication manifest from webbook",
     manifest && JSON.stringify(manifest, null, 2)
   );
   return {
-    entryHtmlFile: upath6.join(
+    entryHtmlFile: upath5.join(
       outputDir,
       entryHtml,
-      ...upath6.extname(entryHtml) ? [] : ["index.html"]
+      ...upath5.extname(entryHtml) ? [] : ["index.html"]
     ),
     manifest
   };
@@ -2891,12 +2810,12 @@ async function supplyWebPublicationManifestForWebbook({
   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 entry = upath5.relative(outputDir, entryHtmlFile);
   const allFiles = await glob("**", {
     cwd: outputDir
   });
   const manifest = writePublicationManifest(
-    upath6.join(outputDir, MANIFEST_FILENAME),
+    upath5.join(outputDir, MANIFEST_FILENAME),
     {
       title,
       author,
@@ -2913,13 +2832,13 @@ async function supplyWebPublicationManifestForWebbook({
   link.setAttribute("type", "application/ld+json");
   link.setAttribute(
     "href",
-    upath6.relative(
-      upath6.dirname(entryHtmlFile),
-      upath6.join(outputDir, MANIFEST_FILENAME)
+    upath5.relative(
+      upath5.dirname(entryHtmlFile),
+      upath5.join(outputDir, MANIFEST_FILENAME)
     )
   );
   document2.head.appendChild(link);
-  await fs6.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
+  await fs5.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
   Logger.debug(
     "Generated publication manifest from HTML",
     JSON.stringify(manifest, null, 2)
@@ -2937,8 +2856,8 @@ async function copyWebPublicationAssets({
   entries
 }) {
   const relExportAliases = exportAliases.map(({ source, target }) => ({
-    source: upath6.relative(input, source),
-    target: upath6.relative(input, target)
+    source: upath5.relative(input, source),
+    target: upath5.relative(input, target)
   })).filter(({ source }) => !source.startsWith(".."));
   const assetMatcher = getAssetMatcher({
     copyAsset,
@@ -2977,24 +2896,24 @@ async function copyWebPublicationAssets({
     )
   );
   const resources = [];
-  let actualManifestPath = upath6.join(
+  let actualManifestPath = upath5.join(
     outputDir,
-    upath6.relative(input, manifestPath)
+    upath5.relative(input, manifestPath)
   );
   for (const file of allFiles) {
     const alias = relExportAliases.find(({ source }) => source === file);
     const relTarget = alias?.target || file;
     resources.push(relTarget);
-    const target = upath6.join(outputDir, relTarget);
-    fs6.mkdirSync(upath6.dirname(target), { recursive: true });
-    await copy2(upath6.join(input, file), target);
-    if (alias && pathEquals(upath6.join(input, alias.source), manifestPath)) {
+    const target = upath5.join(outputDir, relTarget);
+    fs5.mkdirSync(upath5.dirname(target), { recursive: true });
+    await copy2(upath5.join(input, file), target);
+    if (alias && pathEquals(upath5.join(input, alias.source), manifestPath)) {
       actualManifestPath = target;
     }
   }
   Logger.debug("webbook publication.json", actualManifestPath);
   const manifest = decodePublicationManifest(
-    JSON.parse(fs6.readFileSync(actualManifestPath, "utf8"))
+    JSON.parse(fs5.readFileSync(actualManifestPath, "utf8"))
   );
   for (const entry of relExportAliases) {
     const rewriteAliasPath = (e) => {
@@ -3026,14 +2945,14 @@ async function copyWebPublicationAssets({
     ...[manifest.resources || []].flat(),
     ...resources.flatMap((file) => {
       if (preDefinedResources.includes(file) || // Omit publication.json itself
-      pathEquals(file, upath6.relative(outputDir, actualManifestPath))) {
+      pathEquals(file, upath5.relative(outputDir, actualManifestPath))) {
         return [];
       }
       return file;
     })
   ];
   sortManifestResources(manifest);
-  fs6.writeFileSync(
+  fs5.writeFileSync(
     actualManifestPath,
     JSON.stringify(encodePublicationManifest(manifest), null, 2)
   );
@@ -3065,7 +2984,7 @@ async function buildWebPublication({
     if (config.input.format === "markdown") {
       const entry = [manifest.readingOrder].flat()[0];
       if (entry) {
-        entryHtmlFile = upath6.join(
+        entryHtmlFile = upath5.join(
           outputDir,
           typeof entry === "string" ? entry : entry.url
         );
@@ -3090,7 +3009,7 @@ async function buildWebPublication({
       webpubDir: outputDir,
       entryHtmlFile,
       manifest,
-      relManifestPath: actualManifestPath && upath6.relative(outputDir, actualManifestPath),
+      relManifestPath: actualManifestPath && upath5.relative(outputDir, actualManifestPath),
       target: target.path,
       epubVersion: target.version
     });
@@ -3100,29 +3019,29 @@ async function buildWebPublication({
 
 // src/processor/theme.ts
 import Arborist from "@npmcli/arborist";
-import fs7 from "node:fs";
-import upath7 from "upath";
+import fs6 from "node:fs";
+import upath6 from "upath";
 function* iterateSymlinksInThemesNodeModules(themesDir) {
-  if (!fs7.existsSync(themesDir)) {
+  if (!fs6.existsSync(themesDir)) {
     return;
   }
-  const nodeModulesDir = upath7.join(themesDir, "node_modules");
-  if (!fs7.existsSync(nodeModulesDir)) {
+  const nodeModulesDir = upath6.join(themesDir, "node_modules");
+  if (!fs6.existsSync(nodeModulesDir)) {
     return;
   }
-  for (const entry of fs7.readdirSync(nodeModulesDir, { withFileTypes: true })) {
+  for (const entry of fs6.readdirSync(nodeModulesDir, { withFileTypes: true })) {
     if (!entry.isSymbolicLink()) {
       continue;
     }
-    const linkPath = upath7.join(nodeModulesDir, entry.name);
-    const target = fs7.readlinkSync(linkPath);
-    yield upath7.resolve(nodeModulesDir, target);
+    const linkPath = upath6.join(nodeModulesDir, entry.name);
+    const target = fs6.readlinkSync(linkPath);
+    yield upath6.resolve(nodeModulesDir, target);
   }
 }
 function removeThemesDirIfBrokenSymlinks(themesDir) {
   for (const target of iterateSymlinksInThemesNodeModules(themesDir)) {
-    if (!fs7.existsSync(target)) {
-      fs7.rmSync(themesDir, { recursive: true });
+    if (!fs6.existsSync(target)) {
+      fs6.rmSync(themesDir, { recursive: true });
       return;
     }
   }
@@ -3132,7 +3051,7 @@ async function checkThemeInstallationNecessity({
   themeIndexes
 }) {
   removeThemesDirIfBrokenSymlinks(themesDir);
-  if (!fs7.existsSync(themesDir)) {
+  if (!fs6.existsSync(themesDir)) {
     return [...themeIndexes].some((theme) => theme.type === "package");
   }
   const commonOpt = {
@@ -3156,7 +3075,7 @@ async function installThemeDependencies({
   themesDir,
   themeIndexes
 }) {
-  fs7.mkdirSync(themesDir, { recursive: true });
+  fs6.mkdirSync(themesDir, { recursive: true });
   removeThemesDirIfBrokenSymlinks(themesDir);
   try {
     const commonOpt = {
@@ -3173,18 +3092,18 @@ async function installThemeDependencies({
         )
       )
     ];
-    const rm = existing.filter((v2) => !add.includes(v2));
+    const rm = existing.filter((v) => !add.includes(v));
     const opt = { ...commonOpt, rm, add };
     const arb = new Arborist(opt);
     const actualTree = await arb.reify(opt);
     for (const child of actualTree.children.values()) {
       if (child.resolved?.startsWith("file:")) {
-        const sourcePath = upath7.resolve(themesDir, child.resolved.slice(5));
-        if (fs7.existsSync(child.path)) {
-          fs7.rmSync(child.path, { recursive: true });
+        const sourcePath = upath6.resolve(themesDir, child.resolved.slice(5));
+        if (fs6.existsSync(child.path)) {
+          fs6.rmSync(child.path, { recursive: true });
         }
-        const relPath = upath7.relative(upath7.dirname(child.path), sourcePath);
-        fs7.symlinkSync(relPath, child.path, "junction");
+        const relPath = upath6.relative(upath6.dirname(child.path), sourcePath);
+        fs6.symlinkSync(relPath, child.path, "junction");
       }
     }
   } catch (error) {
@@ -3202,21 +3121,21 @@ function locateThemePath(theme, from) {
     return theme.location;
   }
   if (theme.type === "file") {
-    return upath8.relative(from, theme.location);
+    return upath7.relative(from, theme.location);
   }
   if (theme.importPath) {
     return [theme.importPath].flat().map((locator) => {
-      const resolvedPath = upath8.resolve(theme.location, locator);
-      if (!pathContains(theme.location, resolvedPath) || !fs8.existsSync(resolvedPath)) {
+      const resolvedPath = upath7.resolve(theme.location, locator);
+      if (!pathContains(theme.location, resolvedPath) || !fs7.existsSync(resolvedPath)) {
         throw new Error(
           `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
         );
       }
-      return upath8.relative(from, resolvedPath);
+      return upath7.relative(from, resolvedPath);
     });
   } else {
-    const pkgJsonPath = upath8.join(theme.location, "package.json");
-    const packageJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf8"));
+    const pkgJsonPath = upath7.join(theme.location, "package.json");
+    const packageJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf8"));
     const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
     if (!maybeStyle) {
       throw new DetailError(
@@ -3224,7 +3143,7 @@ function locateThemePath(theme, from) {
         "Please ensure this package satisfies a `vivliostyle.theme.style` property."
       );
     }
-    return upath8.relative(from, upath8.join(theme.location, maybeStyle));
+    return upath7.relative(from, upath7.join(theme.location, maybeStyle));
   }
 }
 async function cleanupWorkspace({
@@ -3240,27 +3159,27 @@ async function cleanupWorkspace({
   }
   Logger.debug("cleanup workspace files", workspaceDir);
   let movedWorkspacePath;
-  if (pathContains(workspaceDir, themesDir) && fs8.existsSync(themesDir)) {
-    movedWorkspacePath = upath8.join(
-      upath8.dirname(workspaceDir),
+  if (pathContains(workspaceDir, themesDir) && fs7.existsSync(themesDir)) {
+    movedWorkspacePath = upath7.join(
+      upath7.dirname(workspaceDir),
       `.vs-${Date.now()}`
     );
-    const movedThemePath = upath8.join(
+    const movedThemePath = upath7.join(
       movedWorkspacePath,
-      upath8.relative(workspaceDir, themesDir)
+      upath7.relative(workspaceDir, themesDir)
     );
-    fs8.mkdirSync(upath8.dirname(movedThemePath), { recursive: true });
+    fs7.mkdirSync(upath7.dirname(movedThemePath), { recursive: true });
     registerExitHandler(
       `Removing the moved workspace directory: ${movedWorkspacePath}`,
       () => {
-        if (movedWorkspacePath && fs8.existsSync(movedWorkspacePath)) {
-          fs8.rmSync(movedWorkspacePath, { recursive: true, force: true });
+        if (movedWorkspacePath && fs7.existsSync(movedWorkspacePath)) {
+          fs7.rmSync(movedWorkspacePath, { recursive: true, force: true });
         }
       }
     );
     await move(themesDir, movedThemePath);
   }
-  await fs8.promises.rm(workspaceDir, { recursive: true, force: true });
+  await fs7.promises.rm(workspaceDir, { recursive: true, force: true });
   if (movedWorkspacePath) {
     await move(movedWorkspacePath, workspaceDir);
   }
@@ -3269,10 +3188,10 @@ async function prepareThemeDirectory({
   themesDir,
   themeIndexes
 }) {
-  if (fs8.existsSync(upath8.join(themesDir, "packages")) && !fs8.existsSync(upath8.join(themesDir, "node_modules"))) {
-    fs8.renameSync(
-      upath8.join(themesDir, "packages"),
-      upath8.join(themesDir, "node_modules")
+  if (fs7.existsSync(upath7.join(themesDir, "packages")) && !fs7.existsSync(upath7.join(themesDir, "node_modules"))) {
+    fs7.renameSync(
+      upath7.join(themesDir, "packages"),
+      upath7.join(themesDir, "node_modules")
     );
   }
   if (await checkThemeInstallationNecessity({ themesDir, themeIndexes })) {
@@ -3281,7 +3200,7 @@ async function prepareThemeDirectory({
   }
   for (const theme of themeIndexes) {
     if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
-      fs8.mkdirSync(upath8.dirname(theme.location), { recursive: true });
+      fs7.mkdirSync(upath7.dirname(theme.location), { recursive: true });
       await copy3(theme.source, theme.location);
     }
   }
@@ -3302,7 +3221,7 @@ async function transformManuscript(entry, {
   let resourceLoader;
   let resourceUrl;
   const style = entry.themes.flatMap(
-    (theme) => locateThemePath(theme, upath8.dirname(entry.target))
+    (theme) => locateThemePath(theme, upath7.dirname(entry.target))
   );
   if (source?.type === "file") {
     if (source.documentProcessor) {
@@ -3398,7 +3317,7 @@ async function transformManuscript(entry, {
     content = await processTocHtml(content, {
       entries: manuscriptEntries,
       manifestPath,
-      distDir: upath8.dirname(contentsEntry.target),
+      distDir: upath7.dirname(contentsEntry.target),
       tocTitle: contentsEntry.tocTitle,
       sectionDepth: contentsEntry.sectionDepth,
       styleOptions: contentsEntry,
@@ -3408,10 +3327,10 @@ async function transformManuscript(entry, {
   if (entry.rel === "cover") {
     const coverEntry = entry;
     content = await processCoverHtml(content, {
-      imageSrc: upath8.relative(
-        upath8.join(
+      imageSrc: upath7.relative(
+        upath7.join(
           entryContextDir,
-          upath8.relative(workspaceDir, coverEntry.target),
+          upath7.relative(workspaceDir, coverEntry.target),
           ".."
         ),
         coverEntry.coverImageSrc
@@ -3461,7 +3380,7 @@ async function generateManifest({
 }) {
   const manifestEntries = entries.map((entry) => ({
     title: entry.rel === "contents" && entry.tocTitle || entry.title,
-    path: upath8.relative(workspaceDir, entry.target),
+    path: upath7.relative(workspaceDir, entry.target),
     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
   }));
@@ -3471,7 +3390,7 @@ async function generateManifest({
     language,
     readingProgression,
     cover: cover && {
-      url: upath8.relative(entryContextDir, cover.src),
+      url: upath7.relative(entryContextDir, cover.src),
       name: cover.name
     },
     entries: manifestEntries,
@@ -3527,7 +3446,7 @@ function createEntriesRouteLookup(entries, cwd2) {
     return arr;
   };
   const cache = entries.reduce((acc, e) => {
-    acc[`/${upath9.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
+    acc[`/${upath8.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
     return acc;
   }, {});
   return (uri) => {
@@ -3546,6 +3465,9 @@ function getWorkspaceMatcher({
   outputs,
   copyAsset
 }) {
+  const hasCmykReserveMap = outputs.some(
+    (o) => o.format === "pdf" && o.cmyk && o.cmyk.reserveMap.length > 0
+  );
   if (viewerInput.type === "webpub") {
     return getWebPubResourceMatcher({
       outputs,
@@ -3553,15 +3475,16 @@ function getWorkspaceMatcher({
       entries,
       cwd: workspaceDir,
       manifestPath: viewerInput.manifestPath,
-      copyAsset
+      copyAsset,
+      additionalPatterns: hasCmykReserveMap ? [CMYK_RESERVE_MAP_FILENAME] : []
     });
   }
   let entryFiles = [];
   switch (viewerInput.type) {
     case "epub":
       entryFiles = [
-        upath9.join(
-          upath9.relative(workspaceDir, viewerInput.epubTmpOutputDir),
+        upath8.join(
+          upath8.relative(workspaceDir, viewerInput.epubTmpOutputDir),
           "**"
         )
       ];
@@ -3600,6 +3523,7 @@ function vsDevServerPlugin({
     if (isWebPubConfig(config) && config.viewerInput.needToGenerateManifest && needToUpdateManifest) {
       await generateManifest(config);
     }
+    generateCmykReserveMap(config);
     const localThemePaths = await prepareThemeDirectory(config);
     const entriesLookup = createEntriesRouteLookup(
       config.entries,
@@ -3714,8 +3638,8 @@ function vsDevServerPlugin({
     }
   }
   async function invalidate(entry) {
-    const cwd2 = pathToFileURL6(config.workspaceDir);
-    const target = pathToFileURL6(entry.target);
+    const cwd2 = pathToFileURL5(config.workspaceDir);
+    const target = pathToFileURL5(entry.target);
     if (target.href.indexOf(cwd2.href) !== 0) {
       return;
     }
@@ -3882,7 +3806,7 @@ function vsDevServerPlugin({
 
 // src/vite/vite-plugin-static-serve.ts
 import sirv2 from "sirv";
-import upath10 from "upath";
+import upath9 from "upath";
 import "vite";
 function vsStaticServePlugin({
   config: _config,
@@ -3897,7 +3821,7 @@ function vsStaticServePlugin({
       ([base, dirs]) => dirs.map(
         (dir) => [
           base,
-          sirv2(upath10.resolve(config.serverRootDir, dir), {
+          sirv2(upath9.resolve(config.serverRootDir, dir), {
             dev: true,
             etag: false
           })
@@ -3926,9 +3850,9 @@ function vsStaticServePlugin({
 }
 
 // src/vite/vite-plugin-viewer.ts
-import fs9 from "node:fs";
+import fs8 from "node:fs";
 import sirv3 from "sirv";
-import upath11 from "upath";
+import upath10 from "upath";
 import "vite";
 var viewerClientId = "@vivliostyle:viewer:client";
 var viewerClientRequestPath = `/${viewerClientId}`;
@@ -3942,13 +3866,13 @@ if (import.meta.hot) {
 }`
 );
 function vsViewerPlugin(_) {
-  const serveRootDir = upath11.join(viewerRoot, "lib");
+  const serveRootDir = upath10.join(viewerRoot, "lib");
   const serve = sirv3(serveRootDir, { dev: false, etag: true });
   let cachedIndexHtml;
   const middleware = async function vivliostyleViewerMiddleware(req, res, next) {
     if (req.url === "/" || req.url === "/index.html") {
       cachedIndexHtml ??= prependToHead(
-        fs9.readFileSync(upath11.join(serveRootDir, "index.html"), "utf-8"),
+        fs8.readFileSync(upath10.join(serveRootDir, "index.html"), "utf-8"),
         `<script type="module" src="${viewerClientRequestPath}"></script>`
       );
       res.statusCode = 200;
@@ -3983,6 +3907,18 @@ function vsViewerPlugin(_) {
 }
 
 // src/server.ts
+function generateCmykReserveMap({
+  outputs,
+  workspaceDir
+}) {
+  const pdfOutput = outputs.find((o) => o.format === "pdf");
+  if (pdfOutput && "cmyk" in pdfOutput && pdfOutput.cmyk && pdfOutput.cmyk.reserveMap.length) {
+    fs9.writeFileSync(
+      upath11.join(workspaceDir, CMYK_RESERVE_MAP_FILENAME),
+      JSON.stringify(pdfOutput.cmyk.reserveMap)
+    );
+  }
+}
 function getViewerParams(src, {
   size,
   cropMarks,
@@ -3994,8 +3930,9 @@ function getViewerParams(src, {
   singleDoc,
   quick,
   viewerParam,
-  base
-}) {
+  base,
+  rootUrl
+}, { cmykReserveMapUrl } = {}) {
   const pageSizeValue = size && ("format" in size ? size.format : `${size.width} ${size.height}`);
   function escapeParam(url) {
     return url.replace(/&/g, "%26");
@@ -4003,11 +3940,11 @@ function getViewerParams(src, {
   let viewerParams = src ? `src=${escapeParam(src)}` : "";
   viewerParams += `&bookMode=${!singleDoc}&renderAllPages=${!quick}`;
   if (customStyle) {
-    const param = isValidUri(customStyle) ? customStyle : upath12.posix.join(base, customStyle);
+    const param = isValidUri(customStyle) ? customStyle : new URL2(upath11.posix.join(base, customStyle), rootUrl).href;
     viewerParams += `&style=${escapeParam(param)}`;
   }
   if (customUserStyle) {
-    const param = isValidUri(customUserStyle) ? customUserStyle : upath12.posix.join(base, customUserStyle);
+    const param = isValidUri(customUserStyle) ? customUserStyle : new URL2(upath11.posix.join(base, customUserStyle), rootUrl).href;
     viewerParams += `&userStyle=${escapeParam(param)}`;
   }
   if (pageSizeValue || cropMarks || bleed || cropOffset || css) {
@@ -4029,6 +3966,9 @@ function getViewerParams(src, {
       pageStyle
     )}/*</viewer>*/${encodeURIComponent(css ?? "")}`;
   }
+  if (cmykReserveMapUrl) {
+    viewerParams += `&cmykReserveMap=${escapeParam(cmykReserveMapUrl)}`;
+  }
   if (viewerParam) {
     viewerParams += `&${viewerParam}`;
   }
@@ -4052,7 +3992,7 @@ async function getSourceUrl({
       input = viewerInput.epubOpfPath;
       break;
     case "epub": {
-      if (!fs10.existsSync(viewerInput.epubTmpOutputDir)) {
+      if (!fs9.existsSync(viewerInput.epubTmpOutputDir)) {
         await openEpub(viewerInput.epubPath, viewerInput.epubTmpOutputDir);
       }
       input = getDefaultEpubOpfPath(viewerInput.epubTmpOutputDir);
@@ -4062,7 +4002,7 @@ async function getSourceUrl({
       input = viewerInput;
   }
   return (isValidUri(input) ? new URL2(input) : new URL2(
-    upath12.posix.join(base, upath12.relative(workspaceDir, input)),
+    upath11.posix.join(base, upath11.relative(workspaceDir, input)),
     rootUrl
   )).href;
 }
@@ -4081,9 +4021,14 @@ async function getViewerFullUrl({
     workspaceDir,
     rootUrl
   });
+  const cmykOutput = config.outputs.find(
+    (o) => o.format === "pdf" && o.cmyk && o.cmyk.reserveMap.length
+  );
+  const cmykReserveMapUrl = cmykOutput ? new URL2(upath11.posix.join(base, CMYK_RESERVE_MAP_FILENAME), rootUrl).href : void 0;
   const viewerParams = getViewerParams(
     sourceUrl === EMPTY_DATA_URI ? void 0 : sourceUrl,
-    { base, ...config }
+    { base, rootUrl, ...config },
+    { cmykReserveMapUrl }
   );
   viewerUrl.hash = "";
   return `${viewerUrl.href}#${viewerParams}`;
@@ -4114,8 +4059,8 @@ async function createViteServer({
   if (config.serverRootDir === config.workspaceDir) {
     const { cacheDir } = viteInlineConfig;
     registerExitHandler("Removing the Vite cacheDir", () => {
-      if (fs10.existsSync(cacheDir)) {
-        fs10.rmSync(cacheDir, { recursive: true });
+      if (fs9.existsSync(cacheDir)) {
+        fs9.rmSync(cacheDir, { recursive: true });
       }
     });
   }
@@ -4186,8 +4131,6 @@ function vsBrowserPlugin({
 }
 
 export {
-  loadVivliostyleConfig,
-  warnDeprecatedConfig,
   mergeConfig,
   mergeInlineConfig,
   isWebPubConfig,
@@ -4201,8 +4144,9 @@ export {
   vsDevServerPlugin,
   vsStaticServePlugin,
   vsViewerPlugin,
+  generateCmykReserveMap,
   getSourceUrl,
   getViewerFullUrl,
   createViteServer
 };
-//# sourceMappingURL=chunk-C4HQHRXQ.js.map
+//# sourceMappingURL=chunk-P33ELNYE.js.map