@vivliostyle/cli 9.3.1 → 9.3.2

package/dist/{chunk-XYOW6HSN.js → chunk-2E4GDR4I.js}

@@ -25,10 +25,10 @@ import {
   touchTmpFile,
   useTmpDirectory,
   writeFileIfChanged
-} from "./chunk-U63QI2TT.js";
+} from "./chunk-A7YURMH3.js";
 import {
   VivliostyleConfigSchema
-} from "./chunk-SEVGSYUZ.js";
+} from "./chunk-GKPT4TWW.js";
 import {
   CONTAINER_LOCAL_HOSTNAME,
   CONTAINER_URL,
@@ -270,6 +270,8 @@ var manuscriptMediaTypes = [
 ];
 var UseTemporaryServerRoot = Symbol("UseTemporaryServerRoot");
 var DEFAULT_ASSET_EXTENSIONS = [
+  "css",
+  "css.map",
   "png",
   "jpg",
   "jpeg",
@@ -1183,9 +1185,9 @@ async function launchPreview({
 }
 
 // src/server.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import { URL as URL2 } from "node:url";
-import upath10 from "upath";
+import upath11 from "upath";
 import {
   createServer,
   preview
@@ -1194,26 +1196,171 @@ import {
 // src/vite/vite-plugin-dev-server.ts
 import escapeRe from "escape-string-regexp";
 import { pathToFileURL as pathToFileURL6 } from "node:url";
-import picomatch2 from "picomatch";
 import sirv from "sirv";
-import upath7 from "upath";
+import upath8 from "upath";
 
-// src/processor/compile.ts
-import { copy as copy3, move } from "fs-extra/esm";
-import fs8 from "node:fs";
+// src/processor/asset.ts
+import { copy } from "fs-extra/esm";
+import fs5 from "node:fs";
 import picomatch from "picomatch";
-import { glob as glob2 } from "tinyglobby";
-import upath6 from "upath";
+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
+}) {
+  return new GlobMatcher([
+    {
+      patterns: [
+        `**/${upath3.relative(cwd2, manifestPath)}`,
+        "**/*.{html,htm,xhtml,xht,css}"
+      ],
+      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);
+  }
+}
+
+// src/processor/compile.ts
+import { copy as copy4, move } from "fs-extra/esm";
+import fs9 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 { copy as copy3 } from "fs-extra/esm";
 import { lookup as mime3 } from "mime-types";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import { pathToFileURL as pathToFileURL5 } from "node:url";
-import { glob } from "tinyglobby";
-import upath5 from "upath";
+import { glob as glob2 } from "tinyglobby";
+import upath6 from "upath";
 
 // src/processor/html.tsx
 import jsdom, {
@@ -1223,7 +1370,7 @@ import jsdom, {
 import DOMPurify from "dompurify";
 import { toHtml } from "hast-util-to-html";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "node:url";
-import upath3 from "upath";
+import upath4 from "upath";
 import MIMEType from "whatwg-mimetype";
 import { jsx, jsxs } from "hastscript/jsx-runtime";
 var createVirtualConsole = (onError) => {
@@ -1284,7 +1431,7 @@ var ResourceLoader = class _ResourceLoader extends BaseResourceLoader {
       if (mimeType === "text/html" && !/\.html?$/.test(url.pathname)) {
         url.pathname = `${url.pathname.replace(/\/$/, "")}/index.html`;
       }
-      let relTarget = upath3.relative(rootHref, url.href);
+      let relTarget = upath4.relative(rootHref, url.href);
       return decodeURI(relTarget);
     };
     const fetchedResources = [];
@@ -1303,7 +1450,7 @@ var ResourceLoader = class _ResourceLoader extends BaseResourceLoader {
           } catch (e) {
           }
           const relTarget = normalizeToLocalPath(url, encodingFormat);
-          const target = upath3.join(outputDir, relTarget);
+          const target = upath4.join(outputDir, relTarget);
           fetchedResources.push({ url: relTarget, encodingFormat });
           writeFileIfChanged(target, buffer);
         }).catch(onError);
@@ -1492,11 +1639,11 @@ async function generateTocListSection({
   } = transform;
   const structure = await Promise.all(
     entries.map(async (entry) => {
-      const href = encodeURI(upath3.relative(distDir, entry.target));
+      const href = encodeURI(upath4.relative(distDir, entry.target));
       const sections = sectionDepth >= 1 ? await getStructuredSectionFromHtml(entry.target, href) : [];
       return {
-        title: entry.title || upath3.basename(entry.target, ".html"),
-        href: encodeURI(upath3.relative(distDir, entry.target)),
+        title: entry.title || upath4.basename(entry.target, ".html"),
+        href: encodeURI(upath4.relative(distDir, entry.target)),
         sections,
         children: []
         // TODO
@@ -1544,7 +1691,7 @@ async function processTocHtml(dom, {
     const l = document.createElement("link");
     l.setAttribute("rel", "publication");
     l.setAttribute("type", "application/ld+json");
-    l.setAttribute("href", encodeURI(upath3.relative(distDir, manifestPath)));
+    l.setAttribute("href", encodeURI(upath4.relative(distDir, manifestPath)));
     document.head.appendChild(l);
   }
   const style = document.querySelector("style[data-vv-style]");
@@ -1803,12 +1950,12 @@ function parsePageListDocument(dom) {
 import archiver from "archiver";
 import { lookup as lookupLanguage } from "bcp-47-match";
 import { XMLBuilder } from "fast-xml-parser";
-import { copy } from "fs-extra/esm";
+import { copy as copy2 } from "fs-extra/esm";
 import GithubSlugger from "github-slugger";
 import { lookup as mime2 } from "mime-types";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
-import upath4 from "upath";
+import upath5 from "upath";
 import { v4 as uuid } from "uuid";
 import serializeToXml from "w3c-xmlserializer";
 var TOC_ID = "toc";
@@ -1822,12 +1969,12 @@ var COVER_IMAGE_MIMETYPES = [
   "image/webp"
 ];
 var changeExtname = (filepath, newExt) => {
-  let ext = upath4.extname(filepath);
+  let ext = upath5.extname(filepath);
   return `${filepath.slice(0, -ext.length)}${newExt}`;
 };
 var getRelativeHref = (target, baseUrl, rootUrl) => {
-  const absBasePath = upath4.join("/", baseUrl);
-  const absRootPath = upath4.join("/", rootUrl);
+  const absBasePath = upath5.join("/", baseUrl);
+  const absRootPath = upath5.join("/", rootUrl);
   const hrefUrl = new URL(encodeURI(target), pathToFileURL4(absBasePath));
   if (hrefUrl.protocol !== "file:") {
     return target;
@@ -1835,8 +1982,8 @@ var getRelativeHref = (target, baseUrl, rootUrl) => {
   if (/\.html?$/.test(hrefUrl.pathname)) {
     hrefUrl.pathname = changeExtname(hrefUrl.pathname, ".xhtml");
   }
-  const pathname = upath4.posix.relative(
-    pathToFileURL4(upath4.dirname(absRootPath)).pathname,
+  const pathname = upath5.posix.relative(
+    pathToFileURL4(upath5.dirname(absRootPath)).pathname,
     hrefUrl.pathname
   );
   return `${pathname}${hrefUrl.search}${hrefUrl.hash}`;
@@ -1879,10 +2026,10 @@ async function exportEpub({
     epubVersion
   });
   const [tmpDir] = await useTmpDirectory();
-  fs5.mkdirSync(upath4.join(tmpDir, "META-INF"), { recursive: true });
-  await copy(webpubDir, upath4.join(tmpDir, "EPUB"));
+  fs6.mkdirSync(upath5.join(tmpDir, "META-INF"), { recursive: true });
+  await copy2(webpubDir, upath5.join(tmpDir, "EPUB"));
   const uid = `urn:uuid:${uuid()}`;
-  const entryHtmlRelPath = entryHtmlFile && upath4.relative(webpubDir, upath4.resolve(webpubDir, entryHtmlFile));
+  const entryHtmlRelPath = entryHtmlFile && upath5.relative(webpubDir, upath5.resolve(webpubDir, entryHtmlFile));
   const findPublicationLink = (relType, list, filter) => [list].flat().find(
     (e) => typeof e === "object" && e.rel === relType && (!filter || filter(e))
   );
@@ -1919,7 +2066,7 @@ async function exportEpub({
         return acc;
       } catch (e) {
       }
-      if (!fs5.existsSync(upath4.join(tmpDir, "EPUB", url))) {
+      if (!fs6.existsSync(upath5.join(tmpDir, "EPUB", url))) {
         return acc;
       }
       const mediaType = encodingFormat || mime2(url) || "text/plain";
@@ -1973,7 +2120,7 @@ async function exportEpub({
       text: EPUB_LANDMARKS_COVER_ENTRY
     });
   }
-  const contextDir = upath4.join(tmpDir, "EPUB");
+  const contextDir = upath5.join(tmpDir, "EPUB");
   const processHtml = async (target2) => {
     let parseResult;
     try {
@@ -2035,20 +2182,20 @@ async function exportEpub({
     });
   }
   if (relManifestPath) {
-    await fs5.promises.rm(upath4.join(tmpDir, "EPUB", relManifestPath), {
+    await fs6.promises.rm(upath5.join(tmpDir, "EPUB", relManifestPath), {
       force: true,
       recursive: true
     });
     delete manifestItem[relManifestPath];
   }
-  fs5.writeFileSync(
-    upath4.join(tmpDir, "META-INF/container.xml"),
+  fs6.writeFileSync(
+    upath5.join(tmpDir, "META-INF/container.xml"),
     EPUB_CONTAINER_XML,
     "utf8"
   );
   Logger.debug(`Generating content.opf`);
-  fs5.writeFileSync(
-    upath4.join(tmpDir, "EPUB/content.opf"),
+  fs6.writeFileSync(
+    upath5.join(tmpDir, "EPUB/content.opf"),
     buildEpubPackageDocument({
       epubVersion,
       uid,
@@ -2065,13 +2212,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 fs6.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
 }
 async function transpileHtmlToXhtml({
   target,
   contextDir
 }) {
-  const absPath = upath4.join(contextDir, target);
+  const absPath = upath5.join(contextDir, target);
   const dom = await getJsdomFromUrlOrFile({ src: absPath });
   const { document } = dom.window;
   document.documentElement.removeAttribute("xmlns");
@@ -2081,7 +2228,7 @@ async function transpileHtmlToXhtml({
     el.setAttribute("href", getRelativeHref(href, target, target));
   });
   await writeAsXhtml(dom, absPath);
-  await fs5.promises.unlink(absPath);
+  await fs6.promises.unlink(absPath);
   return {
     dom,
     // FIXME: Yes, I recognize this implementation is inadequate.
@@ -2139,7 +2286,7 @@ async function processTocDocument({
         let name = normalizeLocalizableString(content.name, docLanguages);
         if (!name) {
           const dom2 = await getJsdomFromUrlOrFile({
-            src: upath4.join(contextDir, changeExtname(content.url, ".xhtml"))
+            src: upath5.join(contextDir, changeExtname(content.url, ".xhtml"))
           });
           name = dom2.window.document.title;
         }
@@ -2192,7 +2339,7 @@ async function processTocDocument({
     }
     publicationLinkEl.parentNode?.removeChild(publicationLinkEl);
   }
-  const absPath = upath4.join(contextDir, target);
+  const absPath = upath5.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { tocResourceTree };
 }
@@ -2207,7 +2354,7 @@ async function processPagelistDocument({
     nav.setAttribute("id", PAGELIST_ID);
     nav.setAttribute("epub:type", "page-list");
   }
-  const absPath = upath4.join(contextDir, target);
+  const absPath = upath5.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { pageListResourceTree };
 }
@@ -2326,7 +2473,7 @@ async function compressEpub({
   sourceDir
 }) {
   Logger.debug(`Compressing EPUB: ${target}`);
-  const output = fs5.createWriteStream(target);
+  const output = fs6.createWriteStream(target);
   const archive = archiver("zip", {
     zlib: { level: 9 }
     // Compression level
@@ -2346,8 +2493,8 @@ async function compressEpub({
       // https://www.w3.org/TR/epub-33/#sec-zip-container-mime
       store: true
     });
-    archive.directory(upath4.join(sourceDir, "META-INF"), "META-INF");
-    archive.directory(upath4.join(sourceDir, "EPUB"), "EPUB");
+    archive.directory(upath5.join(sourceDir, "META-INF"), "META-INF");
+    archive.directory(upath5.join(sourceDir, "EPUB"), "EPUB");
     archive.finalize();
   });
 }
@@ -2364,11 +2511,11 @@ function sortManifestResources(manifest) {
 async function prepareWebPublicationDirectory({
   outputDir
 }) {
-  if (fs6.existsSync(outputDir)) {
+  if (fs7.existsSync(outputDir)) {
     Logger.debug("going to remove existing webpub", outputDir);
-    await fs6.promises.rm(outputDir, { force: true, recursive: true });
+    await fs7.promises.rm(outputDir, { force: true, recursive: true });
   }
-  fs6.mkdirSync(outputDir, { recursive: true });
+  fs7.mkdirSync(outputDir, { recursive: true });
 }
 function transformPublicationManifest(entity, transformer) {
   const { url: transformUrl } = transformer;
@@ -2465,8 +2612,8 @@ function writePublicationManifest(output, options) {
       typeof thrownError === "string" ? thrownError : thrownError.stack ?? thrownError.message
     );
   }
-  fs6.mkdirSync(upath5.dirname(output), { recursive: true });
-  fs6.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
+  fs7.mkdirSync(upath6.dirname(output), { recursive: true });
+  fs7.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
   return publication;
 }
 async function retrieveWebbookEntry({
@@ -2482,7 +2629,7 @@ async function retrieveWebbookEntry({
     src: webbookEntryUrl,
     resourceLoader
   });
-  const entryHtml = viewerInput.webbookPath ? upath5.basename(viewerInput.webbookPath) : decodeURI(dom.window.location.pathname);
+  const entryHtml = viewerInput.webbookPath ? upath6.basename(viewerInput.webbookPath) : decodeURI(dom.window.location.pathname);
   const { manifest, manifestUrl } = await fetchLinkedPublicationManifest({
     dom,
     resourceLoader,
@@ -2493,7 +2640,7 @@ async function retrieveWebbookEntry({
     pathContains2 = (url) => false;
   } else {
     const rootUrl = /^https?:/i.test(webbookEntryUrl) ? new URL("/", webbookEntryUrl).href : new URL(".", webbookEntryUrl).href;
-    pathContains2 = (url) => !upath5.relative(rootUrl, url).startsWith("..");
+    pathContains2 = (url) => !upath6.relative(rootUrl, url).startsWith("..");
   }
   const retriever = new Map(resourceLoader.fetcherMap);
   if (manifest && manifestUrl) {
@@ -2562,10 +2709,10 @@ async function retrieveWebbookEntry({
     manifest && JSON.stringify(manifest, null, 2)
   );
   return {
-    entryHtmlFile: upath5.join(
+    entryHtmlFile: upath6.join(
       outputDir,
       entryHtml,
-      ...upath5.extname(entryHtml) ? [] : ["index.html"]
+      ...upath6.extname(entryHtml) ? [] : ["index.html"]
     ),
     manifest
   };
@@ -2581,12 +2728,12 @@ async function supplyWebPublicationManifestForWebbook({
   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 entry = upath5.relative(outputDir, entryHtmlFile);
-  const allFiles = await glob("**", {
+  const entry = upath6.relative(outputDir, entryHtmlFile);
+  const allFiles = await glob2("**", {
     cwd: outputDir
   });
   const manifest = writePublicationManifest(
-    upath5.join(outputDir, MANIFEST_FILENAME),
+    upath6.join(outputDir, MANIFEST_FILENAME),
     {
       title,
       author,
@@ -2603,13 +2750,13 @@ async function supplyWebPublicationManifestForWebbook({
   link.setAttribute("type", "application/ld+json");
   link.setAttribute(
     "href",
-    upath5.relative(
-      upath5.dirname(entryHtmlFile),
-      upath5.join(outputDir, MANIFEST_FILENAME)
+    upath6.relative(
+      upath6.dirname(entryHtmlFile),
+      upath6.join(outputDir, MANIFEST_FILENAME)
     )
   );
   document.head.appendChild(link);
-  await fs6.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
+  await fs7.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
   Logger.debug(
     "Generated publication manifest from HTML",
     JSON.stringify(manifest, null, 2)
@@ -2624,51 +2771,33 @@ async function copyWebPublicationAssets({
   manifestPath,
   input,
   outputDir,
-  entries,
-  customStyle,
-  customUserStyle
+  entries
 }) {
+  debugger;
   const relExportAliases = exportAliases.map(({ source, target }) => ({
-    source: upath5.relative(input, source),
-    target: upath5.relative(input, target)
+    source: upath6.relative(input, source),
+    target: upath6.relative(input, target)
   })).filter(({ source }) => !source.startsWith(".."));
+  const assetMatcher = getAssetMatcher({
+    copyAsset,
+    cwd: input,
+    outputs,
+    themesDir,
+    entries
+  });
+  const webResourceMatcher = getWebPubResourceMatcher({
+    cwd: input,
+    outputs,
+    themesDir,
+    entries,
+    manifestPath
+  });
   const allFiles = /* @__PURE__ */ new Set([
-    ...await globAssetFiles({
-      copyAsset,
-      cwd: input,
-      outputs,
-      themesDir,
-      entries,
-      customStyle,
-      customUserStyle
-    }),
-    ...await glob(
-      [
-        `**/${upath5.relative(input, manifestPath)}`,
-        "**/*.{html,htm,xhtml,xht,css}"
-      ],
-      {
-        cwd: input,
-        ignore: [
-          ...getIgnoreAssetPatterns({
-            cwd: input,
-            outputs,
-            entries
-          }),
-          ...getIgnoreThemeExamplePatterns({
-            cwd: input,
-            themesDir
-          }),
-          // Ignore node_modules in the root directory
-          "node_modules/**",
-          // only include dotfiles starting with `.vs-`
-          "**/.!(vs-*)/**"
-        ],
-        // follow symbolic links to copy local theme packages
-        followSymbolicLinks: true,
-        dot: true
-      }
-    )
+    ...await assetMatcher.glob(),
+    ...await webResourceMatcher.glob({
+      // follow symbolic links to copy local theme packages
+      followSymbolicLinks: true
+    })
   ]);
   for (const alias of relExportAliases) {
     allFiles.delete(alias.target);
@@ -2685,24 +2814,24 @@ async function copyWebPublicationAssets({
     )
   );
   const resources = [];
-  let actualManifestPath = upath5.join(
+  let actualManifestPath = upath6.join(
     outputDir,
-    upath5.relative(input, manifestPath)
+    upath6.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 = upath5.join(outputDir, relTarget);
-    fs6.mkdirSync(upath5.dirname(target), { recursive: true });
-    await copy2(upath5.join(input, file), target);
-    if (alias && pathEquals(upath5.join(input, alias.source), manifestPath)) {
+    const target = upath6.join(outputDir, relTarget);
+    fs7.mkdirSync(upath6.dirname(target), { recursive: true });
+    await copy3(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(fs6.readFileSync(actualManifestPath, "utf8"))
+    JSON.parse(fs7.readFileSync(actualManifestPath, "utf8"))
   );
   for (const entry of relExportAliases) {
     const rewriteAliasPath = (e) => {
@@ -2734,14 +2863,14 @@ async function copyWebPublicationAssets({
     ...[manifest.resources || []].flat(),
     ...resources.flatMap((file) => {
       if (preDefinedResources.includes(file) || // Omit publication.json itself
-      pathEquals(file, upath5.relative(outputDir, actualManifestPath))) {
+      pathEquals(file, upath6.relative(outputDir, actualManifestPath))) {
         return [];
       }
       return file;
     })
   ];
   sortManifestResources(manifest);
-  fs6.writeFileSync(
+  fs7.writeFileSync(
     actualManifestPath,
     JSON.stringify(encodePublicationManifest(manifest), null, 2)
   );
@@ -2773,7 +2902,7 @@ async function buildWebPublication({
     if (config.input.format === "markdown") {
       const entry = [manifest.readingOrder].flat()[0];
       if (entry) {
-        entryHtmlFile = upath5.join(
+        entryHtmlFile = upath6.join(
           outputDir,
           typeof entry === "string" ? entry : entry.url
         );
@@ -2798,7 +2927,7 @@ async function buildWebPublication({
       webpubDir: outputDir,
       entryHtmlFile,
       manifest,
-      relManifestPath: actualManifestPath && upath5.relative(outputDir, actualManifestPath),
+      relManifestPath: actualManifestPath && upath6.relative(outputDir, actualManifestPath),
       target: target.path,
       epubVersion: target.version
     });
@@ -2808,12 +2937,12 @@ async function buildWebPublication({
 
 // src/processor/theme.ts
 import Arborist from "@npmcli/arborist";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 async function checkThemeInstallationNecessity({
   themesDir,
   themeIndexes
 }) {
-  if (!fs7.existsSync(themesDir)) {
+  if (!fs8.existsSync(themesDir)) {
     return [...themeIndexes].some((theme) => theme.type === "package");
   }
   const commonOpt = {
@@ -2831,7 +2960,7 @@ async function installThemeDependencies({
   themesDir,
   themeIndexes
 }) {
-  fs7.mkdirSync(themesDir, { recursive: true });
+  fs8.mkdirSync(themesDir, { recursive: true });
   try {
     const commonOpt = {
       path: themesDir,
@@ -2866,21 +2995,21 @@ function locateThemePath(theme, from) {
     return theme.location;
   }
   if (theme.type === "file") {
-    return upath6.relative(from, theme.location);
+    return upath7.relative(from, theme.location);
   }
   if (theme.importPath) {
     return [theme.importPath].flat().map((locator) => {
-      const resolvedPath = upath6.resolve(theme.location, locator);
-      if (!pathContains(theme.location, resolvedPath) || !fs8.existsSync(resolvedPath)) {
+      const resolvedPath = upath7.resolve(theme.location, locator);
+      if (!pathContains(theme.location, resolvedPath) || !fs9.existsSync(resolvedPath)) {
         throw new Error(
           `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
         );
       }
-      return upath6.relative(from, resolvedPath);
+      return upath7.relative(from, resolvedPath);
     });
   } else {
-    const pkgJsonPath = upath6.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(fs9.readFileSync(pkgJsonPath, "utf8"));
     const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
     if (!maybeStyle) {
       throw new DetailError(
@@ -2888,7 +3017,7 @@ function locateThemePath(theme, from) {
         "Please ensure this package satisfies a `vivliostyle.theme.style` property."
       );
     }
-    return upath6.relative(from, upath6.join(theme.location, maybeStyle));
+    return upath7.relative(from, upath7.join(theme.location, maybeStyle));
   }
 }
 async function cleanupWorkspace({
@@ -2904,27 +3033,27 @@ async function cleanupWorkspace({
   }
   Logger.debug("cleanup workspace files", workspaceDir);
   let movedWorkspacePath;
-  if (pathContains(workspaceDir, themesDir) && fs8.existsSync(themesDir)) {
-    movedWorkspacePath = upath6.join(
-      upath6.dirname(workspaceDir),
+  if (pathContains(workspaceDir, themesDir) && fs9.existsSync(themesDir)) {
+    movedWorkspacePath = upath7.join(
+      upath7.dirname(workspaceDir),
       `.vs-${Date.now()}`
     );
-    const movedThemePath = upath6.join(
+    const movedThemePath = upath7.join(
       movedWorkspacePath,
-      upath6.relative(workspaceDir, themesDir)
+      upath7.relative(workspaceDir, themesDir)
     );
-    fs8.mkdirSync(upath6.dirname(movedThemePath), { recursive: true });
+    fs9.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 && fs9.existsSync(movedWorkspacePath)) {
+          fs9.rmSync(movedWorkspacePath, { recursive: true, force: true });
         }
       }
     );
     await move(themesDir, movedThemePath);
   }
-  await fs8.promises.rm(workspaceDir, { recursive: true, force: true });
+  await fs9.promises.rm(workspaceDir, { recursive: true, force: true });
   if (movedWorkspacePath) {
     await move(movedWorkspacePath, workspaceDir);
   }
@@ -2933,10 +3062,10 @@ async function prepareThemeDirectory({
   themesDir,
   themeIndexes
 }) {
-  if (fs8.existsSync(upath6.join(themesDir, "packages")) && !fs8.existsSync(upath6.join(themesDir, "node_modules"))) {
-    fs8.renameSync(
-      upath6.join(themesDir, "packages"),
-      upath6.join(themesDir, "node_modules")
+  if (fs9.existsSync(upath7.join(themesDir, "packages")) && !fs9.existsSync(upath7.join(themesDir, "node_modules"))) {
+    fs9.renameSync(
+      upath7.join(themesDir, "packages"),
+      upath7.join(themesDir, "node_modules")
     );
   }
   if (await checkThemeInstallationNecessity({ themesDir, themeIndexes })) {
@@ -2945,8 +3074,8 @@ async function prepareThemeDirectory({
   }
   for (const theme of themeIndexes) {
     if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
-      fs8.mkdirSync(upath6.dirname(theme.location), { recursive: true });
-      await copy3(theme.source, theme.location);
+      fs9.mkdirSync(upath7.dirname(theme.location), { recursive: true });
+      await copy4(theme.source, theme.location);
     }
   }
 }
@@ -2966,7 +3095,7 @@ async function transformManuscript(entry, {
   let resourceLoader;
   let resourceUrl;
   const style = entry.themes.flatMap(
-    (theme) => locateThemePath(theme, upath6.dirname(entry.target))
+    (theme) => locateThemePath(theme, upath7.dirname(entry.target))
   );
   if (source?.type === "file") {
     if (source.contentType === "text/markdown") {
@@ -2991,7 +3120,7 @@ async function transformManuscript(entry, {
       });
     } else {
       if (!pathEquals(source.pathname, entry.target)) {
-        await copy3(source.pathname, entry.target);
+        await copy4(source.pathname, entry.target);
       }
     }
   } else if (source?.type === "uri") {
@@ -3061,7 +3190,7 @@ async function transformManuscript(entry, {
     content = await processTocHtml(content, {
       entries: manuscriptEntries,
       manifestPath,
-      distDir: upath6.dirname(contentsEntry.target),
+      distDir: upath7.dirname(contentsEntry.target),
       tocTitle: contentsEntry.tocTitle,
       sectionDepth: contentsEntry.sectionDepth,
       styleOptions: contentsEntry,
@@ -3071,10 +3200,10 @@ async function transformManuscript(entry, {
   if (entry.rel === "cover") {
     const coverEntry = entry;
     content = await processCoverHtml(content, {
-      imageSrc: upath6.relative(
-        upath6.join(
+      imageSrc: upath7.relative(
+        upath7.join(
           entryContextDir,
-          upath6.relative(workspaceDir, coverEntry.target),
+          upath7.relative(workspaceDir, coverEntry.target),
           ".."
         ),
         coverEntry.coverImageSrc
@@ -3124,7 +3253,7 @@ async function generateManifest({
 }) {
   const manifestEntries = entries.map((entry) => ({
     title: entry.rel === "contents" && entry.tocTitle || entry.title,
-    path: upath6.relative(workspaceDir, entry.target),
+    path: upath7.relative(workspaceDir, entry.target),
     encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/html" ? void 0 : entry.contentType,
     rel: entry.rel
   }));
@@ -3134,7 +3263,7 @@ async function generateManifest({
     language,
     readingProgression,
     cover: cover && {
-      url: upath6.relative(entryContextDir, cover.src),
+      url: upath7.relative(entryContextDir, cover.src),
       name: cover.name
     },
     entries: manifestEntries,
@@ -3157,123 +3286,6 @@ async function compile(config) {
     await generateManifest(config);
   }
 }
-function getIgnoreThemeExamplePatterns({
-  themesDir,
-  cwd: cwd2
-}) {
-  return pathContains(cwd2, themesDir) ? [
-    `${upath6.relative(cwd2, themesDir)}/node_modules/*/example`,
-    `${upath6.relative(cwd2, themesDir)}/node_modules/*/*/example`
-  ] : [];
-}
-function getIgnoreAssetPatterns({
-  outputs,
-  entries,
-  cwd: cwd2
-}) {
-  return [
-    ...outputs.flatMap(
-      ({ format, path: p }) => !pathContains(cwd2, p) ? [] : format === "webpub" ? upath6.join(upath6.relative(cwd2, p), "**") : upath6.relative(cwd2, p)
-    ),
-    ...entries.flatMap(({ template }) => {
-      return template?.type === "file" && pathContains(cwd2, template.pathname) ? upath6.relative(cwd2, template.pathname) : [];
-    })
-  ];
-}
-function getAssetMatcherSettings({
-  copyAsset: { fileExtensions, includes, excludes },
-  outputs,
-  themesDir,
-  entries,
-  customStyle,
-  customUserStyle,
-  cwd: cwd2,
-  ignore = []
-}) {
-  const ignorePatterns = [
-    ...ignore,
-    ...excludes,
-    ...getIgnoreAssetPatterns({ outputs, entries, cwd: cwd2 })
-  ];
-  Logger.debug("globAssetFiles > ignorePatterns", ignorePatterns);
-  return [
-    // 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,
-        ...getIgnoreThemeExamplePatterns({ themesDir, cwd: cwd2 })
-      ]
-    },
-    // Step 2: Glob files matched with `includes`
-    // Ignore only files matched `excludes`
-    {
-      patterns: [
-        ...includes,
-        // Copy custom (user) style if specified
-        customStyle,
-        customUserStyle
-      ].filter((s) => Boolean(s)),
-      ignore: ignorePatterns
-    }
-  ];
-}
-function getAssetMatcher(arg) {
-  const matchers = getAssetMatcherSettings(arg).map(
-    ({ patterns, ignore }) => picomatch(patterns, { ignore })
-  );
-  return (test) => matchers.some((matcher) => matcher(test));
-}
-async function globAssetFiles(arg) {
-  const settings = getAssetMatcherSettings(arg);
-  return new Set(
-    (await Promise.all(
-      settings.map(
-        ({ patterns, ignore }) => glob2(patterns, {
-          cwd: arg.cwd,
-          ignore,
-          followSymbolicLinks: true
-        })
-      )
-    )).flat()
-  );
-}
-async function copyAssets({
-  entryContextDir,
-  workspaceDir,
-  copyAsset,
-  outputs,
-  themesDir,
-  entries,
-  customStyle,
-  customUserStyle
-}) {
-  if (pathEquals(entryContextDir, workspaceDir)) {
-    return;
-  }
-  const relWorkspaceDir = upath6.relative(entryContextDir, workspaceDir);
-  const assets = await globAssetFiles({
-    copyAsset,
-    cwd: entryContextDir,
-    outputs,
-    themesDir,
-    entries,
-    customStyle,
-    customUserStyle,
-    ignore: [
-      // don't copy workspace itself
-      ...relWorkspaceDir ? [upath6.join(relWorkspaceDir, "**")] : []
-    ]
-  });
-  Logger.debug("assets", assets);
-  for (const asset of assets) {
-    const target = upath6.join(workspaceDir, asset);
-    fs8.mkdirSync(upath6.dirname(target), { recursive: true });
-    await copy3(upath6.resolve(entryContextDir, asset), target);
-  }
-}
 
 // src/vite/plugin-util.ts
 var headStartTagRe = /<head[^>]*>/i;
@@ -3307,7 +3319,7 @@ function createEntriesRouteLookup(entries, cwd2) {
     return arr;
   };
   const cache = entries.reduce((acc, e) => {
-    acc[`/${upath7.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
+    acc[`/${upath8.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
     return acc;
   }, {});
   return (uri) => {
@@ -3321,17 +3333,25 @@ function getWorkspaceMatcher({
   workspaceDir,
   themesDir,
   viewerInput,
-  themeIndexes
+  themeIndexes,
+  entries,
+  outputs
 }) {
+  if (viewerInput.type === "webpub") {
+    return getWebPubResourceMatcher({
+      outputs,
+      themesDir,
+      entries,
+      cwd: workspaceDir,
+      manifestPath: viewerInput.manifestPath
+    });
+  }
   let entryFiles = [];
   switch (viewerInput.type) {
-    case "webpub":
-      entryFiles = [upath7.relative(workspaceDir, viewerInput.manifestPath)];
-      break;
     case "epub":
       entryFiles = [
-        upath7.join(
-          upath7.relative(workspaceDir, viewerInput.epubTmpOutputDir),
+        upath8.join(
+          upath8.relative(workspaceDir, viewerInput.epubTmpOutputDir),
           "**"
         )
       ];
@@ -3343,16 +3363,14 @@ function getWorkspaceMatcher({
     default:
       entryFiles = viewerInput;
   }
-  return picomatch2(
-    [
-      ...entryFiles,
-      ...pathContains(workspaceDir, themesDir) ? [upath7.join(upath7.relative(workspaceDir, themesDir), "**")] : [],
-      ...[...themeIndexes].flatMap(
-        (theme) => theme.type === "file" && pathContains(workspaceDir, theme.location) ? [upath7.relative(workspaceDir, theme.location)] : []
-      )
-    ],
-    { dot: true, ignore: ["node_modules/**"] }
-  );
+  return new GlobMatcher([
+    {
+      patterns: entryFiles,
+      ignore: ["node_modules/**"],
+      dot: true,
+      cwd: workspaceDir
+    }
+  ]);
 }
 function vsDevServerPlugin({
   config: _config,
@@ -3404,6 +3422,16 @@ function vsDevServerPlugin({
       serveAssets,
       serveAssetsMatcher
     };
+    if (needToUpdateManifest) {
+      Logger.debug(
+        "dev-server > serveWorkspaceMatcher %O",
+        serveWorkspaceMatcher.matcherConfig
+      );
+      Logger.debug(
+        "dev-server > serveAssetsMatcher %O",
+        serveAssetsMatcher.matcherConfig
+      );
+    }
     const configPath = locateVivliostyleConfig(inlineConfig);
     const projectDeps = [];
     if (configPath) {
@@ -3488,6 +3516,7 @@ function vsDevServerPlugin({
       res.setHeader("Location", `${expected}${qs || ""}`);
       return res.end();
     }
+    Logger.debug("dev-server > request %s", pathname);
     const cachePromise = transformCache.get(entry.target);
     if (cachePromise) {
       const cached = await cachePromise;
@@ -3536,15 +3565,34 @@ function vsDevServerPlugin({
       serveAssetsMatcher
     } = program;
     const [_, pathname] = decodeURI(req.url).match(urlMatchRe) ?? [];
-    if (pathname && serveWorkspaceMatcher(pathname.slice(1))) {
-      req.url = req.url.slice(config.base.length);
-      return serveWorkspace(req, res, next);
+    if (!pathname) {
+      return next();
     }
-    if (pathname && serveAssetsMatcher(pathname.slice(1))) {
+    const handleWorkspace = (next2) => {
+      if (!serveWorkspaceMatcher.match(pathname.slice(1))) {
+        return next2();
+      }
+      Logger.debug("dev-server > serveWorkspace %s", pathname);
+      const url = req.url;
       req.url = req.url.slice(config.base.length);
-      return serveAssets(req, res, next);
-    }
-    next();
+      return serveWorkspace(req, res, () => {
+        req.url = url;
+        next2();
+      });
+    };
+    const handleAssets = (next2) => {
+      if (!serveAssetsMatcher.match(pathname.slice(1))) {
+        return next2();
+      }
+      Logger.debug("dev-server > serveAssets %s", pathname);
+      const url = req.url;
+      req.url = url.slice(config.base.length);
+      return serveAssets(req, res, () => {
+        req.url = url;
+        next2();
+      });
+    };
+    handleWorkspace(() => handleAssets(next));
   };
   return {
     name: "vivliostyle:dev-server",
@@ -3593,7 +3641,7 @@ function vsDevServerPlugin({
 
 // src/vite/vite-plugin-static-serve.ts
 import sirv2 from "sirv";
-import upath8 from "upath";
+import upath9 from "upath";
 function vsStaticServePlugin({
   config: _config,
   inlineConfig
@@ -3607,7 +3655,7 @@ function vsStaticServePlugin({
       ([base, dirs]) => dirs.map(
         (dir) => [
           base,
-          sirv2(upath8.resolve(config.serverRootDir, dir), {
+          sirv2(upath9.resolve(config.serverRootDir, dir), {
             dev: true,
             etag: false
           })
@@ -3636,9 +3684,9 @@ function vsStaticServePlugin({
 }
 
 // src/vite/vite-plugin-viewer.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import sirv3 from "sirv";
-import upath9 from "upath";
+import upath10 from "upath";
 var viewerClientId = "@vivliostyle:viewer:client";
 var viewerClientRequestPath = `/${viewerClientId}`;
 var viewerClientContent = (
@@ -3651,13 +3699,13 @@ if (import.meta.hot) {
 }`
 );
 function vsViewerPlugin(_) {
-  const serveRootDir = upath9.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(upath9.join(serveRootDir, "index.html"), "utf-8"),
+        fs10.readFileSync(upath10.join(serveRootDir, "index.html"), "utf-8"),
         `<script type="module" src="${viewerClientRequestPath}"></script>`
       );
       res.statusCode = 200;
@@ -3712,11 +3760,11 @@ function getViewerParams(src, {
   let viewerParams = src ? `src=${escapeParam(src)}` : "";
   viewerParams += `&bookMode=${!singleDoc}&renderAllPages=${!quick}`;
   if (customStyle) {
-    const param = isValidUri(customStyle) ? customStyle : upath10.posix.join(base, customStyle);
+    const param = isValidUri(customStyle) ? customStyle : upath11.posix.join(base, customStyle);
     viewerParams += `&style=${escapeParam(param)}`;
   }
   if (customUserStyle) {
-    const param = isValidUri(customUserStyle) ? customUserStyle : upath10.posix.join(base, customUserStyle);
+    const param = isValidUri(customUserStyle) ? customUserStyle : upath11.posix.join(base, customUserStyle);
     viewerParams += `&userStyle=${escapeParam(param)}`;
   }
   if (pageSizeValue || cropMarks || bleed || cropOffset || css) {
@@ -3761,7 +3809,7 @@ async function getSourceUrl({
       input = viewerInput.epubOpfPath;
       break;
     case "epub": {
-      if (!fs10.existsSync(viewerInput.epubTmpOutputDir)) {
+      if (!fs11.existsSync(viewerInput.epubTmpOutputDir)) {
         await openEpub(viewerInput.epubPath, viewerInput.epubTmpOutputDir);
       }
       input = getDefaultEpubOpfPath(viewerInput.epubTmpOutputDir);
@@ -3771,7 +3819,7 @@ async function getSourceUrl({
       input = viewerInput;
   }
   return (isValidUri(input) ? new URL2(input) : new URL2(
-    upath10.posix.join(base, upath10.relative(workspaceDir, input)),
+    upath11.posix.join(base, upath11.relative(workspaceDir, input)),
     rootUrl
   )).href;
 }
@@ -3823,8 +3871,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 (fs11.existsSync(cacheDir)) {
+        fs11.rmSync(cacheDir, { recursive: true });
       }
     });
   }
@@ -3897,11 +3945,11 @@ export {
   getFullBrowserName,
   launchPreview,
   vsBrowserPlugin,
+  copyAssets,
   buildWebPublication,
   cleanupWorkspace,
   prepareThemeDirectory,
   compile,
-  copyAssets,
   vsDevServerPlugin,
   vsStaticServePlugin,
   vsViewerPlugin,
@@ -3909,4 +3957,4 @@ export {
   getViewerFullUrl,
   createViteServer
 };
-//# sourceMappingURL=chunk-XYOW6HSN.js.map
+//# sourceMappingURL=chunk-2E4GDR4I.js.map