@vivliostyle/cli 9.0.1 → 9.0.2

package/dist/{chunk-PY4J4NG6.js → chunk-KSGAS7XH.js}

@@ -1,4 +1,37 @@
 import {
+  importNodeModule
+} from "./chunk-FXUEYQRY.js";
+import {
+  DetailError,
+  Logger,
+  assertPubManifestSchema,
+  cwd,
+  getDefaultEpubOpfPath,
+  getEpubRootDir,
+  getFormattedError,
+  isInContainer,
+  isRunningOnWSL,
+  isValidUri,
+  openEpub,
+  parseJsonc,
+  pathContains,
+  pathEquals,
+  prettifySchemaError,
+  readJSON,
+  registerExitHandler,
+  runExitHandlers,
+  setupConfigFromFlags,
+  statFileSync,
+  touchTmpFile,
+  useTmpDirectory,
+  writeFileIfChanged
+} from "./chunk-S2Q2FDUM.js";
+import {
+  VivliostyleConfigSchema
+} from "./chunk-WFLNEE7C.js";
+import {
+  CONTAINER_LOCAL_HOSTNAME,
+  CONTAINER_URL,
   COVER_HTML_FILENAME,
   COVER_HTML_IMAGE_ALT,
   EMPTY_DATA_URI,
@@ -15,1117 +48,27 @@ import {
   XML_DECLARATION,
   cliVersion,
   viewerRoot
-} from "./chunk-EX7EA34F.js";
-import {
-  importNodeModule
-} from "./chunk-WX6JHPSL.js";
-import {
-  VivliostyleConfigSchema,
-  VivliostyleInlineConfig
-} from "./chunk-DMARNPN5.js";
+} from "./chunk-4IIM6RSG.js";
 import {
   __callDispose,
   __using
-} from "./chunk-BIEQXUOY.js";
-
-// src/util.ts
-import { codeFrameColumns } from "@babel/code-frame";
-import {
-  evaluate,
-  parse
-} from "@humanwhocodes/momoa";
-import { Ajv } from "ajv";
-import formatsPlugin from "ajv-formats";
-import { XMLParser } from "fast-xml-parser";
-import StreamZip from "node-stream-zip";
-import fs from "node:fs";
-import readline from "node:readline";
-import util from "node:util";
-import tmp from "tmp";
-import upath from "upath";
-import { gray as gray2, red, redBright as redBright2 } from "yoctocolors";
-
-// src/logger.ts
-import debug from "debug";
-import yoctoSpinner from "yocto-spinner";
-import {
-  blueBright,
-  gray,
-  greenBright,
-  redBright,
-  yellowBright
-} from "yoctocolors";
-var isUnicodeSupported = process.platform !== "win32" || Boolean(process.env.WT_SESSION);
-var randomBookSymbol = ["\u{1F4D5}", "\u{1F4D7}", "\u{1F4D8}", "\u{1F4D9}"][Math.floor(Math.random() * 4)];
-var infoSymbol = blueBright("INFO");
-var successSymbol = greenBright("SUCCESS");
-var warnSymbol = yellowBright("WARN");
-var errorSymbol = redBright("ERROR");
-var Logger = class _Logger {
-  /**
-   * 0: silent 1: info 2: verbose 3: debug
-   */
-  static #logLevel = 0;
-  static #loggerInstance;
-  static #nonBlockingLogPrinted = false;
-  static #customLogger;
-  static debug = debug("vs-cli");
-  static get #spinner() {
-    return this.#loggerInstance && this.#loggerInstance.#_spinner;
-  }
-  static get isInteractive() {
-    return Boolean(
-      !this.#customLogger && process.stderr.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env) && !import.meta.env?.VITEST && !debug.enabled("vs-cli") && // Prevent stream output in docker container so that not to spawn process
-      !isInContainer()
-    );
-  }
-  static startLogging(text) {
-    if (this.#logLevel === 0) {
-      return;
-    }
-    if (!this.isInteractive) {
-      this.logInfo(text);
-      return;
-    }
-    if (this.#loggerInstance) {
-      this.#loggerInstance.#_spinner.text = text;
-      return this.#loggerInstance;
-    }
-    this.#loggerInstance = new _Logger();
-    this.#loggerInstance.#_spinner.start(text);
-    return this.#loggerInstance;
-  }
-  static suspendLogging(text) {
-    if (this.#logLevel === 0) {
-      return;
-    }
-    if (!this.#spinner || !this.isInteractive) {
-      this.logInfo(text);
-      return;
-    }
-    const currentMsg = this.#spinner?.text;
-    this.logUpdate(currentMsg);
-    this.#spinner.stop(`${infoSymbol} ${text}
-`);
-    return {
-      [Symbol.dispose]() {
-        if (_Logger.isInteractive) {
-          console.log("");
-          _Logger.#spinner?.start(currentMsg);
-          _Logger.#nonBlockingLogPrinted = true;
-        }
-      }
-    };
-  }
-  static log(...messages) {
-    if (this.#logLevel < 1) {
-      return;
-    }
-    console.log(...messages);
-  }
-  static logUpdate(...messages) {
-    if (!this.#spinner || !this.isInteractive) {
-      this.logInfo(...messages);
-      return;
-    }
-    this.#spinner.stop(
-      this.#nonBlockingLogPrinted ? void 0 : `${infoSymbol} ${this.#spinner.text}`
-    );
-    this.#spinner.start(messages.join(" "));
-    this.#nonBlockingLogPrinted = false;
-  }
-  static getMessage(message, symbol) {
-    return !this.#customLogger && symbol ? `${symbol} ${message}` : message;
-  }
-  static #nonBlockingLog(logMethod, message) {
-    if (!this.#spinner || !this.isInteractive) {
-      if (isInContainer()) {
-        message = `${gray("[Docker]")} ${message}`;
-      }
-      this.#logLevel >= 3 ? this.debug(message) : (this.#customLogger || console)[logMethod](message);
-      return;
-    }
-    this.logUpdate(this.#spinner.text);
-    this.#nonBlockingLogPrinted = true;
-    this.#spinner.stop(message);
-    this.#spinner.start();
-  }
-  static logSuccess(...messages) {
-    if (this.#logLevel < 1) {
-      return;
-    }
-    this.#nonBlockingLog(
-      "info",
-      this.getMessage(messages.join(" "), successSymbol)
-    );
-  }
-  static logError(...messages) {
-    if (this.#logLevel < 1) {
-      return;
-    }
-    this.#nonBlockingLog(
-      "error",
-      this.getMessage(messages.join(" "), errorSymbol)
-    );
-  }
-  static logWarn(...messages) {
-    if (this.#logLevel < 1) {
-      return;
-    }
-    this.#nonBlockingLog(
-      "warn",
-      this.getMessage(messages.join(" "), warnSymbol)
-    );
-  }
-  static logInfo(...messages) {
-    if (this.#logLevel < 1) {
-      return;
-    }
-    this.#nonBlockingLog(
-      "info",
-      this.getMessage(messages.join(" "), infoSymbol)
-    );
-  }
-  static logVerbose(...messages) {
-    if (this.#logLevel < 2) {
-      return;
-    }
-    this.#nonBlockingLog("info", this.getMessage(messages.join(" ")));
-  }
-  static setLogLevel(level) {
-    if (!level) {
-      return;
-    }
-    this.#logLevel = {
-      silent: 0,
-      info: 1,
-      verbose: 2,
-      debug: 3
-    }[level];
-    if (this.#logLevel >= 3) {
-      debug.enable("vs-cli");
-    }
-  }
-  static setCustomLogger(logger) {
-    this.#customLogger = logger;
-  }
-  #_spinner;
-  constructor() {
-    this.#_spinner = yoctoSpinner({
-      spinner: {
-        frames: isUnicodeSupported ? ["\u2581\u2581\u2571 ", "\u2581\u2551\u2581 ", "\u2572\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 ", "\u2581\u2581\u2581 "] : ["-   ", "\\   ", "|   ", "/   "],
-        interval: 80
-      },
-      color: "gray"
-    });
-    return this;
-  }
-  [Symbol.dispose]() {
-    this.#_spinner.stop(
-      _Logger.#nonBlockingLogPrinted ? void 0 : `${infoSymbol} ${this.#_spinner.text}`
-    );
-    _Logger.#loggerInstance = void 0;
-  }
-};
-
-// schemas/pub-manifest/module/bcp.schema.json
-var bcp_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/bcp.schema.json",
-  title: "BCP47 Language tag",
-  type: "string",
-  pattern: "^((?:(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?:([A-Za-z]{2,3}(-(?:[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?:[A-Za-z]{4}))?(-(?:[A-Za-z]{2}|[0-9]{3}))?(-(?:[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?:[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?:x(-[A-Za-z0-9]{1,8})+))?)|(?:x(-[A-Za-z0-9]{1,8})+))$"
-};
-
-// schemas/pub-manifest/module/context.schema.json
-var context_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/context.schema.json",
-  title: "Publication Contexts",
-  type: "array",
-  items: [
-    {
-      const: "https://schema.org"
-    },
-    {
-      const: "https://www.w3.org/ns/pub-context"
-    }
-  ],
-  additionalItems: {
-    anyOf: [
-      {
-        type: "string"
-      },
-      {
-        type: "object",
-        properties: {
-          language: {
-            $ref: "bcp.schema.json"
-          },
-          direction: false
-        },
-        required: ["language"]
-      },
-      {
-        type: "object",
-        properties: {
-          direction: {
-            type: "string",
-            enum: ["ltr", "rtl"]
-          },
-          language: false
-        },
-        required: ["direction"]
-      },
-      {
-        type: "object",
-        properties: {
-          language: {
-            $ref: "bcp.schema.json"
-          },
-          direction: {
-            type: "string",
-            enum: ["ltr", "rtl"]
-          }
-        },
-        required: ["language", "direction"]
-      },
-      {
-        type: "object",
-        properties: {
-          language: false,
-          direction: false
-        }
-      }
-    ]
-  }
-};
-
-// schemas/pub-manifest/module/contributor-object.schema.json
-var contributor_object_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/contributor-object.schema.json",
-  title: "Contributor Object",
-  type: "object",
-  properties: {
-    name: {
-      $ref: "localizable.schema.json"
-    },
-    id: {
-      $ref: "url.schema.json"
-    },
-    type: {
-      oneOf: [
-        {
-          type: "string",
-          enum: ["Person", "Organization"],
-          default: "Person"
-        },
-        {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          contains: {
-            enum: ["Person", "Organization"]
-          }
-        }
-      ]
-    },
-    url: {
-      $ref: "url.schema.json"
-    },
-    identifier: {
-      type: "array",
-      items: {
-        type: "string"
-      }
-    }
-  },
-  required: ["name"]
-};
-
-// schemas/pub-manifest/module/contributor.schema.json
-var contributor_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/contributor.schema.json",
-  title: "Contributor",
-  anyOf: [
-    {
-      type: "string"
-    },
-    {
-      type: "array",
-      items: {
-        anyOf: [
-          {
-            type: "string"
-          },
-          {
-            $ref: "contributor-object.schema.json"
-          }
-        ]
-      }
-    },
-    {
-      $ref: "contributor-object.schema.json"
-    }
-  ]
-};
-
-// schemas/pub-manifest/module/date.schema.json
-var date_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/date.schema.json",
-  title: "Dates",
-  type: "string",
-  format: "date-time"
-};
-
-// schemas/pub-manifest/module/duration.schema.json
-var duration_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/duration.schema.json",
-  title: "Duration",
-  type: "string",
-  pattern: "^P(?!$)((\\d+Y)|(\\d+\\.\\d+Y$))?((\\d+M)|(\\d+\\.\\d+M$))?((\\d+W)|(\\d+\\.\\d+W$))?((\\d+D)|(\\d+\\.\\d+D$))?(T(?=\\d)((\\d+H)|(\\d+\\.\\d+H$))?((\\d+M)|(\\d+\\.\\d+M$))?(\\d+(\\.\\d+)?S)?)??$"
-};
-
-// schemas/pub-manifest/module/item-lists.schema.json
-var item_lists_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/item-lists.schema.json",
-  title: "Lists of ItemList",
-  oneOf: [
-    {
-      $ref: "ItemList.schema.json"
-    },
-    {
-      type: "array",
-      items: {
-        $ref: "ItemList.schema.json"
-      }
-    }
-  ]
-};
-
-// schemas/pub-manifest/module/ItemList.schema.json
-var ItemList_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/ItemList.schema.json",
-  title: "schema.org ItemList object",
-  type: "object",
-  properties: {
-    type: {
-      oneOf: [
-        {
-          type: "string",
-          const: "ItemList"
-        },
-        {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          contains: {
-            const: "ItemList"
-          }
-        }
-      ]
-    },
-    itemListElement: {
-      type: ["array"],
-      items: {
-        type: "string"
-      }
-    }
-  },
-  required: ["type", "itemListElement"]
-};
-
-// schemas/pub-manifest/module/language.schema.json
-var language_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/language.schema.json",
-  title: "Languages",
-  oneOf: [
-    {
-      $ref: "bcp.schema.json"
-    },
-    {
-      type: "array",
-      items: {
-        $ref: "bcp.schema.json"
-      }
-    }
-  ]
-};
-
-// schemas/pub-manifest/module/link.schema.json
-var link_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/link.schema.json",
-  title: "Publication Links",
-  type: "object",
-  properties: {
-    type: {
-      oneOf: [
-        {
-          type: "string",
-          const: "LinkedResource"
-        },
-        {
-          type: "array",
-          items: {
-            type: "string"
-          },
-          contains: {
-            const: "LinkedResource"
-          }
-        }
-      ]
-    },
-    url: {
-      $ref: "url.schema.json"
-    },
-    encodingFormat: {
-      type: "string"
-    },
-    name: {
-      $ref: "localizable.schema.json"
-    },
-    description: {
-      anyOf: [
-        {
-          type: "string"
-        },
-        {
-          $ref: "localizable-object.schema.json"
-        }
-      ]
-    },
-    rel: {
-      type: ["string", "array"],
-      items: {
-        type: "string"
-      }
-    },
-    integrity: {
-      type: "string"
-    },
-    duration: {
-      $ref: "duration.schema.json"
-    },
-    alternate: {
-      $ref: "resource.categorization.schema.json"
-    }
-  },
-  required: ["url"]
-};
-
-// schemas/pub-manifest/module/localizable-object.schema.json
-var localizable_object_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/localizable-object.schema.json",
-  title: "Localizable String Object",
-  type: "object",
-  properties: {
-    value: {
-      type: "string"
-    },
-    language: {
-      $ref: "bcp.schema.json"
-    }
-  },
-  required: ["value"]
-};
-
-// schemas/pub-manifest/module/localizable.schema.json
-var localizable_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/localizable.schema.json",
-  title: "Localizable String or Object",
-  anyOf: [
-    {
-      type: "string"
-    },
-    {
-      type: "array",
-      items: {
-        anyOf: [
-          {
-            type: "string"
-          },
-          {
-            $ref: "localizable-object.schema.json"
-          }
-        ]
-      }
-    },
-    {
-      $ref: "localizable-object.schema.json"
-    }
-  ]
-};
-
-// schemas/pub-manifest/module/resource.categorization.schema.json
-var resource_categorization_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/resource.categorization.schema.json",
-  title: "Resource Categorization",
-  oneOf: [
-    {
-      oneOf: [
-        {
-          $ref: "url.schema.json"
-        },
-        {
-          $ref: "link.schema.json"
-        }
-      ]
-    },
-    {
-      type: "array",
-      items: {
-        anyOf: [
-          {
-            $ref: "url.schema.json"
-          },
-          {
-            $ref: "link.schema.json"
-          }
-        ]
-      },
-      uniqueItems: true
-    }
-  ]
-};
-
-// schemas/pub-manifest/module/strings.schema.json
-var strings_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/strings.schema.json",
-  title: "Unique strings",
-  type: ["string", "array"],
-  items: {
-    type: "string"
-  }
-};
-
-// schemas/pub-manifest/module/url.schema.json
-var url_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/url.schema.json",
-  title: "URL",
-  type: "string",
-  format: "uri-reference"
-};
-
-// schemas/pub-manifest/module/urls.schema.json
-var urls_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/module/urls.schema.json",
-  title: "URLs",
-  oneOf: [
-    {
-      type: "string",
-      format: "uri-reference"
-    },
-    {
-      type: "array",
-      items: {
-        type: "string",
-        format: "uri-reference"
-      }
-    }
-  ]
-};
-
-// schemas/pub-manifest/publication.schema.json
-var publication_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://www.w3.org/ns/pub-schema/manifest/publication.schema.json",
-  title: "Publication Manifest",
-  type: "object",
-  properties: {
-    "@context": {
-      $ref: "module/context.schema.json"
-    },
-    type: {
-      type: ["string", "array"],
-      items: {
-        type: "string"
-      }
-    },
-    conformsTo: {
-      oneOf: [
-        {
-          $ref: "module/url.schema.json"
-        },
-        {
-          type: "array",
-          items: {
-            $ref: "module/url.schema.json"
-          }
-        }
-      ]
-    },
-    id: {
-      type: "string"
-    },
-    abridged: {
-      type: "boolean"
-    },
-    accessMode: {
-      $ref: "module/strings.schema.json"
-    },
-    accessModeSufficient: {
-      $ref: "module/item-lists.schema.json"
-    },
-    accessibilityFeature: {
-      $ref: "module/strings.schema.json"
-    },
-    accessibilityHazard: {
-      $ref: "module/strings.schema.json"
-    },
-    accessibilitySummary: {
-      $ref: "module/localizable.schema.json"
-    },
-    artist: {
-      $ref: "module/contributor.schema.json"
-    },
-    author: {
-      $ref: "module/contributor.schema.json"
-    },
-    colorist: {
-      $ref: "module/contributor.schema.json"
-    },
-    contributor: {
-      $ref: "module/contributor.schema.json"
-    },
-    creator: {
-      $ref: "module/contributor.schema.json"
-    },
-    editor: {
-      $ref: "module/contributor.schema.json"
-    },
-    illustrator: {
-      $ref: "module/contributor.schema.json"
-    },
-    inker: {
-      $ref: "module/contributor.schema.json"
-    },
-    letterer: {
-      $ref: "module/contributor.schema.json"
-    },
-    penciler: {
-      $ref: "module/contributor.schema.json"
-    },
-    publisher: {
-      $ref: "module/contributor.schema.json"
-    },
-    readBy: {
-      $ref: "module/contributor.schema.json"
-    },
-    translator: {
-      $ref: "module/contributor.schema.json"
-    },
-    url: {
-      $ref: "module/urls.schema.json"
-    },
-    duration: {
-      $ref: "module/duration.schema.json"
-    },
-    inLanguage: {
-      $ref: "module/language.schema.json"
-    },
-    dateModified: {
-      $ref: "module/date.schema.json"
-    },
-    datePublished: {
-      $ref: "module/date.schema.json"
-    },
-    name: {
-      $ref: "module/localizable.schema.json"
-    },
-    readingOrder: {
-      $ref: "module/resource.categorization.schema.json"
-    },
-    resources: {
-      $ref: "module/resource.categorization.schema.json"
-    },
-    links: {
-      $ref: "module/resource.categorization.schema.json"
-    },
-    readingProgression: {
-      type: "string",
-      enum: ["ltr", "rtl"],
-      default: "ltr"
-    }
-  },
-  required: ["@context", "conformsTo"]
-};
-
-// src/schema/pub-manifest.ts
-var publicationSchemas = [
-  bcp_schema_default,
-  context_schema_default,
-  contributor_object_schema_default,
-  contributor_schema_default,
-  date_schema_default,
-  duration_schema_default,
-  item_lists_schema_default,
-  ItemList_schema_default,
-  language_schema_default,
-  link_schema_default,
-  localizable_object_schema_default,
-  localizable_schema_default,
-  resource_categorization_schema_default,
-  strings_schema_default,
-  url_schema_default,
-  urls_schema_default,
-  publication_schema_default
-];
-
-// src/util.ts
-var cwd = upath.normalize(process.cwd());
-var beforeExitHandlers = [];
-var registerExitHandler = (debugMessage, handler) => {
-  beforeExitHandlers.push(() => {
-    Logger.debug(debugMessage);
-    handler();
-  });
-};
-function runExitHandlers() {
-  while (beforeExitHandlers.length) {
-    try {
-      beforeExitHandlers.shift()?.();
-    } catch (e) {
-    }
-  }
-}
-var exitSignals = ["exit", "SIGINT", "SIGTERM"];
-exitSignals.forEach((sig) => {
-  process.once(sig, (signal, exitCode) => {
-    runExitHandlers();
-    if (process.exitCode === void 0) {
-      process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
-    }
-    process.exit();
-  });
-});
-if (process.platform === "win32") {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  rl.on("SIGINT", () => {
-    runExitHandlers();
-    process.exit(1);
-  });
-  registerExitHandler("Closing readline interface", () => {
-    rl.close();
-  });
-}
-var DetailError = class extends Error {
-  constructor(message, detail) {
-    super(message);
-    this.detail = detail;
-  }
-};
-function getFormattedError(err) {
-  return err instanceof DetailError ? `${err.message}
-${err.detail}` : err.stack || `${err.message}`;
-}
-function gracefulError(err) {
-  console.log(`${redBright2("ERROR")} ${getFormattedError(err)}
-
-${gray2("If you think this is a bug, please report at https://github.com/vivliostyle/vivliostyle-cli/issues")}`);
-  process.exit(1);
-}
-function readJSON(path) {
-  try {
-    return JSON.parse(fs.readFileSync(path, "utf8"));
-  } catch (err) {
-    return void 0;
-  }
-}
-function statFileSync(filePath, {
-  errorMessage = "Specified input does not exist"
-} = {}) {
-  try {
-    return fs.statSync(filePath);
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw new Error(`${errorMessage}: ${filePath}`);
-    }
-    throw err;
-  }
-}
-async function inflateZip(filePath, dest) {
-  return await new Promise((res, rej) => {
-    try {
-      const zip = new StreamZip({
-        file: filePath,
-        storeEntries: true
-      });
-      zip.on("error", (err) => {
-        rej(err);
-      });
-      zip.on("ready", async () => {
-        await util.promisify(zip.extract)(null, dest);
-        await util.promisify(zip.close)();
-        Logger.debug(`Unzipped ${filePath} to ${dest}`);
-        res();
-      });
-    } catch (err) {
-      rej(err);
-    }
-  });
-}
-function useTmpDirectory() {
-  return new Promise((res, rej) => {
-    tmp.dir({ unsafeCleanup: true }, (err, path, clear) => {
-      if (err) {
-        return rej(err);
-      }
-      Logger.debug(`Created the temporary directory: ${path}`);
-      if (import.meta.env?.VITEST) {
-        return res([path, () => {
-        }]);
-      }
-      const callback = () => {
-        fs.rmSync(path, { force: true, recursive: true });
-      };
-      registerExitHandler(
-        `Removing the temporary directory: ${path}`,
-        callback
-      );
-      res([path, callback]);
-    });
-  });
-}
-function touchTmpFile(path) {
-  fs.mkdirSync(upath.dirname(path), { recursive: true });
-  fs.closeSync(fs.openSync(path, "a"));
-  Logger.debug(`Created the temporary file: ${path}`);
-  const callback = () => {
-    fs.rmSync(path, { force: true, recursive: true });
-  };
-  registerExitHandler(`Removing the temporary file: ${path}`, callback);
-  return callback;
-}
-function pathEquals(path1, path2) {
-  return upath.relative(path1, path2) === "";
-}
-function pathContains(parentPath, childPath) {
-  const rel = upath.relative(parentPath, childPath);
-  return rel !== "" && !rel.startsWith("..");
-}
-function isValidUri(str) {
-  return /^(https?|file|data):/i.test(str);
-}
-function isInContainer() {
-  return fs.existsSync("/opt/vivliostyle-cli/.vs-cli-version");
-}
-function isRunningOnWSL() {
-  return fs.existsSync("/proc/version") && fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
-}
-async function openEpub(epubPath, tmpDir) {
-  await inflateZip(epubPath, tmpDir);
-  Logger.debug(`Created the temporary EPUB directory: ${tmpDir}`);
-  const deleteEpub = () => {
-    fs.rmSync(tmpDir, { force: true, recursive: true });
-  };
-  registerExitHandler(
-    `Removing the temporary EPUB directory: ${tmpDir}`,
-    deleteEpub
-  );
-  return deleteEpub;
-}
-function getDefaultEpubOpfPath(epubDir) {
-  const containerXmlPath = upath.join(epubDir, "META-INF/container.xml");
-  const xmlParser = new XMLParser({
-    ignoreAttributes: false
-  });
-  const { container } = xmlParser.parse(
-    fs.readFileSync(containerXmlPath, "utf8")
-  );
-  const rootfile = [container.rootfiles.rootfile].flat()[0];
-  const epubOpfPath = upath.join(epubDir, rootfile["@_full-path"]);
-  return epubOpfPath;
-}
-function getEpubRootDir(epubOpfPath) {
-  function traverse(dir) {
-    const files = fs.readdirSync(dir);
-    if (files.includes("META-INF") && pathEquals(epubOpfPath, getDefaultEpubOpfPath(dir))) {
-      return dir;
-    }
-    const next = upath.dirname(dir);
-    if (pathEquals(dir, next)) {
-      return;
-    }
-    return traverse(next);
-  }
-  return traverse(upath.dirname(epubOpfPath));
-}
-var getAjvValidatorFunction = (schema, refSchemas) => (obj) => {
-  const ajv = new Ajv({ strict: false });
-  const addFormats = formatsPlugin;
-  addFormats(ajv);
-  if (refSchemas) {
-    ajv.addSchema(refSchemas);
-  }
-  const validate = ajv.compile(schema);
-  const valid = validate(obj);
-  if (!valid) {
-    throw validate.errors?.[0] || new Error();
-  }
-  return true;
-};
-var assertPubManifestSchema = getAjvValidatorFunction(
-  publication_schema_default,
-  publicationSchemas
-);
-function parseJsonc(rawJsonc) {
-  const ast = parse(rawJsonc, {
-    mode: "jsonc",
-    ranges: false,
-    tokens: false
-  });
-  return evaluate(ast);
-}
-function prettifySchemaError(rawJsonc, issues) {
-  const parsed = parse(rawJsonc, {
-    mode: "jsonc",
-    ranges: false,
-    tokens: false
-  });
-  function traverse(issues2, depth) {
-    return issues2.flatMap((issue) => {
-      const p = issue.path?.length || 0;
-      if (!issue.issues) {
-        return [[[issue], depth + p]];
-      }
-      return traverse(issue.issues, depth + p).map(([i, d]) => [
-        [issue, ...i],
-        d
-      ]);
-    });
-  }
-  const all = traverse(issues, 0);
-  const maxDepth = Math.max(...all.map(([, d]) => d));
-  const issuesTraversed = all.find(([, d]) => d === maxDepth)[0];
-  let jsonValue = parsed.body;
-  for (const p of issuesTraversed.flatMap((v3) => v3.path ?? [])) {
-    let childValue;
-    if (p.type === "object" && jsonValue.type === "Object") {
-      childValue = jsonValue.members.find(
-        (m) => m.name.type === "Identifier" && m.name.name === p.key || m.name.type === "String" && m.name.value === p.key
-      )?.value;
-    }
-    if (p.type === "array" && jsonValue.type === "Array") {
-      childValue = jsonValue.elements[p.key]?.value;
-    }
-    if (childValue) {
-      jsonValue = childValue;
-    } else {
-      break;
-    }
-  }
-  let message = `${red(issuesTraversed.at(-1).message)}`;
-  if (jsonValue) {
-    message += `
-${codeFrameColumns(rawJsonc, jsonValue.loc, {
-      highlightCode: true
-    })}`;
-  }
-  return message;
-}
-function writeFileIfChanged(filePath, content) {
-  if (!fs.existsSync(filePath) || !fs.readFileSync(filePath).equals(content)) {
-    fs.mkdirSync(upath.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-  }
-}
-
-// src/commands/cli-flags.ts
-import upath2 from "upath";
-import * as v from "valibot";
-function parseFlagsToInlineConfig(argv, setupProgram) {
-  const program = setupProgram();
-  program.parse(argv);
-  let options = program.opts();
-  const input = program.args?.[0];
-  options = warnDeprecatedFlags(options);
-  let inlineConfig = { input, ...options };
-  if (input && !options.config && upath2.basename(input).startsWith("vivliostyle.config")) {
-    inlineConfig = { config: input, ...options };
-  }
-  return v.parse(VivliostyleInlineConfig, inlineConfig);
-}
-function setupConfigFromFlags(flags) {
-  if (!flags.input) {
-    if (flags.enableViewerStartPage) {
-      return {
-        tasks: [{ entry: [] }],
-        inlineOptions: {
-          input: { format: "webbook", entry: EMPTY_DATA_URI }
-        }
-      };
-    } else {
-      throw new Error(
-        "No input is set. Please set an appropriate entry or a Vivliostyle config file."
-      );
-    }
-  }
-  return {
-    tasks: [{ entry: [] }],
-    inlineOptions: {}
-  };
-}
-function warnDeprecatedFlags(options) {
-  const modifiedOptions = { ...options };
-  if (options.executableChromium) {
-    Logger.logWarn(
-      "'--executable-chromium' option was deprecated and will be removed in a future release. Please replace with '--executable-browser' option."
-    );
-    modifiedOptions.executableBrowser = options.executableChromium;
-  }
-  if (options.verbose) {
-    Logger.logWarn(
-      "'--verbose' option was deprecated and will be removed in a future release. Please replace with '--log-level verbose' option."
-    );
-    modifiedOptions.logLevel = "verbose";
-  }
-  if (options.sandbox === false) {
-    Logger.logWarn(
-      "'--no-sandbox' option was deprecated and will be removed in a future release. It is no longer necessary because the sandbox is disabled by default."
-    );
-  }
-  if (options.http) {
-    Logger.logWarn(
-      "'--http' option was deprecated and will be removed in a future release. It is unnecessary because the HTTP server starts automatically."
-    );
-  }
-  return modifiedOptions;
-}
+} from "./chunk-I7BWSAN6.js";
 
 // src/config/load.ts
-import fs2 from "node:fs";
+import fs from "node:fs";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
-import upath3 from "upath";
-import * as v2 from "valibot";
+import upath from "upath";
+import * as v from "valibot";
 var require2 = createRequire(import.meta.url);
 function locateVivliostyleConfig({
   config,
   cwd: cwd2 = cwd
 }) {
   if (config) {
-    return upath3.resolve(cwd2, config);
+    return upath.resolve(cwd2, config);
   }
-  return [".js", ".mjs", ".cjs", ".json"].map((ext) => upath3.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs2.existsSync(p));
+  return [".js", ".mjs", ".cjs", ".json"].map((ext) => upath.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs.existsSync(p));
 }
 async function loadVivliostyleConfig({
   config,
@@ -1133,7 +76,7 @@ async function loadVivliostyleConfig({
   cwd: cwd2
 }) {
   if (configData) {
-    return v2.parse(VivliostyleConfigSchema, configData);
+    return v.parse(VivliostyleConfigSchema, configData);
   }
   const absPath = locateVivliostyleConfig({ config, cwd: cwd2 });
   if (!absPath) {
@@ -1142,8 +85,8 @@ async function loadVivliostyleConfig({
   let parsedConfig;
   let jsonRaw;
   try {
-    if (upath3.extname(absPath) === ".json") {
-      jsonRaw = fs2.readFileSync(absPath, "utf8");
+    if (upath.extname(absPath) === ".json") {
+      jsonRaw = fs.readFileSync(absPath, "utf8");
       parsedConfig = parseJsonc(jsonRaw);
     } else {
       delete require2.cache[require2.resolve(absPath)];
@@ -1162,7 +105,7 @@ async function loadVivliostyleConfig({
       thrownError.stack ?? thrownError.message
     );
   }
-  const result = v2.safeParse(VivliostyleConfigSchema, parsedConfig);
+  const result = v.safeParse(VivliostyleConfigSchema, parsedConfig);
   if (result.success) {
     const { tasks, inlineOptions } = result.output;
     return {
@@ -1272,304 +215,30 @@ function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
       server: {
         ...pruneObject(task.server ?? {}),
         ...pruneObject({ host, port })
-      }
-    })),
-    inlineOptions: {
-      ...pruneObject(inlineOptions),
-      ...pruneObject(
-        overrideInlineOptions
-      )
-    }
-  };
-}
-
-// src/browser.ts
-import fs3 from "node:fs";
-async function launchBrowser({
-  browserType,
-  proxy,
-  executablePath,
-  headless,
-  noSandbox,
-  disableWebSecurity,
-  disableDevShmUsage
-}) {
-  const playwright = await importNodeModule("playwright-core");
-  playwright.firefox.executablePath;
-  const options = browserType === "chromium" ? {
-    executablePath,
-    chromiumSandbox: !noSandbox,
-    headless,
-    args: [
-      "--allow-file-access-from-files",
-      ...disableWebSecurity ? ["--disable-web-security"] : [],
-      ...disableDevShmUsage ? ["--disable-dev-shm-usage"] : [],
-      // #357: Set devicePixelRatio=1 otherwise it causes layout issues in HiDPI displays
-      ...headless ? ["--force-device-scale-factor=1"] : [],
-      // #565: Add --disable-gpu option when running on WSL
-      ...isRunningOnWSL() ? ["--disable-gpu"] : [],
-      // set Chromium language to English to avoid locale-dependent issues
-      "--lang=en",
-      ...!headless && process.platform === "darwin" ? ["", "-AppleLanguages", "(en)"] : []
-    ],
-    env: { ...process.env, LANG: "en.UTF-8" },
-    proxy
-  } : (
-    // TODO: Investigate appropriate settings on Firefox & Webkit
-    { executablePath, headless }
-  );
-  const browser = await playwright[browserType].launch(options);
-  registerExitHandler("Closing browser", () => {
-    browser.close();
-  });
-  return browser;
-}
-async function getExecutableBrowserPath(browserType) {
-  const playwright = await importNodeModule("playwright-core");
-  return playwright[browserType].executablePath();
-}
-function getFullBrowserName(browserType) {
-  return {
-    chromium: "Chromium",
-    firefox: "Firefox",
-    webkit: "Webkit"
-  }[browserType];
-}
-function checkBrowserAvailability(path) {
-  return fs3.existsSync(path);
-}
-async function downloadBrowser(browserType) {
-  const { registry } = await importNodeModule("playwright-core/lib/server");
-  const executable = registry.findExecutable(browserType);
-  {
-    var _stack = [];
-    try {
-      const _2 = __using(_stack, Logger.suspendLogging(
-        "Rendering browser is not installed yet. Downloading now."
-      ));
-      await registry.install([executable], false);
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  }
-  return executable.executablePath();
-}
-async function launchPreview({
-  mode,
-  url,
-  onBrowserOpen,
-  onPageOpen,
-  config: { browser: browserConfig, proxy, sandbox, ignoreHttpsErrors }
-}) {
-  let executableBrowser = browserConfig.executablePath;
-  if (executableBrowser) {
-    if (!checkBrowserAvailability(executableBrowser)) {
-      throw new Error(
-        `Cannot find the browser. Please check the executable browser path: ${executableBrowser}`
-      );
-    }
-  } else {
-    executableBrowser = await getExecutableBrowserPath(browserConfig.type);
-    if (!checkBrowserAvailability(executableBrowser)) {
-      await downloadBrowser(browserConfig.type);
-    }
-  }
-  Logger.debug(`Executing browser path: ${executableBrowser}`);
-  const browser = await launchBrowser({
-    browserType: browserConfig.type,
-    proxy,
-    executablePath: executableBrowser,
-    headless: mode === "build",
-    noSandbox: !sandbox,
-    disableDevShmUsage: isInContainer()
-  });
-  await onBrowserOpen?.(browser);
-  const page = await browser.newPage({
-    viewport: mode === "build" ? (
-      // This viewport size important to detect headless environment in Vivliostyle viewer
-      // https://github.com/vivliostyle/vivliostyle.js/blob/73bcf323adcad80126b0175630609451ccd09d8a/packages/core/src/vivliostyle/vgen.ts#L2489-L2500
-      {
-        width: 800,
-        height: 600
-      }
-    ) : null,
-    ignoreHTTPSErrors: ignoreHttpsErrors
-  });
-  await onPageOpen?.(page);
-  page.on("dialog", () => {
-  });
-  await page.goto(url);
-  return { browser, page };
+      }
+    })),
+    inlineOptions: {
+      ...pruneObject(inlineOptions),
+      ...pruneObject(
+        overrideInlineOptions
+      )
+    }
+  };
 }
 
-// src/server.ts
-import fs11 from "node:fs";
-import { URL as URL2 } from "node:url";
-import upath13 from "upath";
-import {
-  createServer,
-  preview
-} from "vite";
-
-// src/vite/vite-plugin-dev-server.ts
-import escapeRe from "escape-string-regexp";
-import { pathToFileURL as pathToFileURL7 } from "node:url";
-import picomatch2 from "picomatch";
-import sirv from "sirv";
-import upath10 from "upath";
-
 // src/config/resolve.ts
 import { VFM } from "@vivliostyle/vfm";
 import { lookup as mime } from "mime-types";
-import fs5 from "node:fs";
-import { pathToFileURL as pathToFileURL3 } from "node:url";
+import fs3 from "node:fs";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 import npa from "npm-package-arg";
-import upath5 from "upath";
-
-// src/container.ts
-import { execFile } from "node:child_process";
-import process2 from "node:process";
-import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
-import { promisify } from "node:util";
-import upath4 from "upath";
-var execFileAsync = promisify(execFile);
-var CONTAINER_IMAGE = `ghcr.io/vivliostyle/cli:${cliVersion}`;
-var CONTAINER_ROOT_DIR = "/data";
-var CONTAINER_LOCAL_HOSTNAME = "host.docker.internal";
-function toContainerPath(urlOrAbsPath) {
-  if (isValidUri(urlOrAbsPath)) {
-    if (urlOrAbsPath.toLowerCase().startsWith("file")) {
-      return pathToFileURL2(
-        upath4.posix.join(
-          CONTAINER_ROOT_DIR,
-          upath4.toUnix(fileURLToPath(urlOrAbsPath)).replace(/^\w:/, "")
-        )
-      ).href;
-    } else {
-      return urlOrAbsPath;
-    }
-  }
-  return upath4.posix.join(
-    CONTAINER_ROOT_DIR,
-    upath4.toUnix(urlOrAbsPath).replace(/^\w:/, "")
-  );
-}
-function collectVolumeArgs(mountPoints) {
-  return mountPoints.filter((p, i, array) => {
-    if (i !== array.indexOf(p)) {
-      return false;
-    }
-    let parent = p;
-    while (!pathEquals(parent, upath4.dirname(parent))) {
-      parent = upath4.dirname(parent);
-      if (array.includes(parent)) {
-        return false;
-      }
-    }
-    return true;
-  }).map((p) => `${p}:${toContainerPath(p)}`);
-}
-async function runContainer({
-  image,
-  userVolumeArgs,
-  commandArgs,
-  entrypoint,
-  env,
-  workdir
-}) {
-  const commandExists = await importNodeModule("command-exists");
-  if (!await commandExists("docker")) {
-    throw new Error(
-      `Docker isn't be installed. To use this feature, you'll need to install Docker.`
-    );
-  }
-  const versionCmd = await execFileAsync("docker", [
-    "version",
-    "--format",
-    "{{.Server.Version}}"
-  ]);
-  const version = versionCmd.stdout.trim();
-  const [major, minor] = version.split(".").map(Number);
-  if (major < 20 || major === 20 && minor < 10) {
-    throw new Error(
-      `Docker version ${version} is not supported. Please upgrade to Docker 20.10.0 or later.`
-    );
-  }
-  try {
-    var _stack = [];
-    try {
-      const _2 = __using(_stack, Logger.suspendLogging("Launching docker container"));
-      const args = [
-        "run",
-        ...Logger.isInteractive ? ["-it"] : [],
-        "--rm",
-        ...entrypoint ? ["--entrypoint", entrypoint] : [],
-        ...env ? env.flatMap(([k, v3]) => ["-e", `${k}=${v3}`]) : [],
-        ...process2.env.DEBUG ? ["-e", `DEBUG=${process2.env.DEBUG}`] : [],
-        ...userVolumeArgs.flatMap((arg) => ["-v", arg]),
-        ...workdir ? ["-w", workdir] : [],
-        image,
-        ...commandArgs
-      ];
-      Logger.debug(`docker ${args.join(" ")}`);
-      const { execa } = await importNodeModule("execa");
-      const proc = execa("docker", args, {
-        stdio: "inherit"
-      });
-      await proc;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  } catch (error) {
-    throw new Error(
-      "An error occurred on the running container. Please see logs above."
-    );
-  }
-}
-async function buildPDFWithContainer({
-  target,
-  config,
-  inlineConfig
-}) {
-  const sourceUrl = new URL(await getSourceUrl(config));
-  if (sourceUrl.origin === config.rootUrl) {
-    sourceUrl.hostname = CONTAINER_LOCAL_HOSTNAME;
-  }
-  const bypassedOption = {
-    ...inlineConfig,
-    input: {
-      format: "webbook",
-      entry: sourceUrl.href
-    },
-    output: [
-      {
-        ...target,
-        path: toContainerPath(target.path)
-      }
-    ]
-  };
-  await runContainer({
-    image: config.image,
-    userVolumeArgs: collectVolumeArgs([
-      config.context,
-      upath4.dirname(target.path)
-    ]),
-    env: [["VS_CLI_BUILD_PDF_OPTIONS", JSON.stringify(bypassedOption)]],
-    commandArgs: ["build"],
-    workdir: toContainerPath(config.context)
-  });
-  return target.path;
-}
+import upath2 from "upath";
 
 // src/processor/markdown.ts
 import {
   readMetadata
 } from "@vivliostyle/vfm";
-import fs4 from "node:fs";
+import fs2 from "node:fs";
 import vfile from "vfile";
 function safeReadMetadata(content) {
   try {
@@ -1579,7 +248,7 @@ function safeReadMetadata(content) {
   }
 }
 async function processMarkdown(documentProcessorFactory, filepath, options = {}) {
-  const markdownString = fs4.readFileSync(filepath, "utf8");
+  const markdownString = fs2.readFileSync(filepath, "utf8");
   const processor = documentProcessorFactory(
     options,
     safeReadMetadata(markdownString)
@@ -1590,7 +259,7 @@ async function processMarkdown(documentProcessorFactory, filepath, options = {})
   return processed;
 }
 function readMarkdownMetadata(filepath) {
-  return safeReadMetadata(fs4.readFileSync(filepath, "utf8"));
+  return safeReadMetadata(fs2.readFileSync(filepath, "utf8"));
 }
 
 // src/config/resolve.ts
@@ -1599,6 +268,7 @@ var manuscriptMediaTypes = [
   "text/html",
   "application/xhtml+xml"
 ];
+var UseTemporaryServerRoot = Symbol("UseTemporaryServerRoot");
 var DEFAULT_ASSET_EXTENSIONS = [
   "png",
   "jpg",
@@ -1642,18 +312,18 @@ function parseTheme({
   if (isValidUri(specifier)) {
     return {
       type: "uri",
-      name: upath5.basename(specifier),
+      name: upath2.basename(specifier),
       location: specifier
     };
   }
-  const stylePath = upath5.resolve(context, specifier);
-  if (fs5.existsSync(stylePath) && stylePath.endsWith(".css")) {
-    const sourceRelPath = upath5.relative(context, stylePath);
+  const stylePath = upath2.resolve(context, specifier);
+  if (fs3.existsSync(stylePath) && stylePath.endsWith(".css")) {
+    const sourceRelPath = upath2.relative(context, stylePath);
     return {
       type: "file",
-      name: upath5.basename(specifier),
+      name: upath2.basename(specifier),
       source: stylePath,
-      location: upath5.resolve(workspaceDir, sourceRelPath)
+      location: upath2.resolve(workspaceDir, sourceRelPath)
     };
   }
   const parsed = parsePackageName(specifier, context);
@@ -1666,9 +336,9 @@ function parseTheme({
   let name = parsed.name;
   let resolvedSpecifier = specifier;
   if (parsed.type === "directory" && parsed.fetchSpec) {
-    const pkgJsonPath = upath5.join(parsed.fetchSpec, "package.json");
-    if (fs5.existsSync(pkgJsonPath)) {
-      const packageJson = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf8"));
+    const pkgJsonPath = upath2.join(parsed.fetchSpec, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
+      const packageJson = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
       name = packageJson.name;
       resolvedSpecifier = parsed.fetchSpec;
     }
@@ -1680,7 +350,7 @@ function parseTheme({
     type: "package",
     name,
     specifier: resolvedSpecifier,
-    location: upath5.join(themesDir, "node_modules", name),
+    location: upath2.join(themesDir, "node_modules", name),
     importPath
   };
 }
@@ -1705,7 +375,7 @@ function parseFileMetadata({
   workspaceDir,
   themesDir
 }) {
-  const sourceDir = upath5.dirname(sourcePath);
+  const sourceDir = upath2.dirname(sourcePath);
   let title;
   let themes;
   if (contentType === "text/markdown") {
@@ -1724,7 +394,7 @@ function parseFileMetadata({
       );
     }
   } else {
-    const content = fs5.readFileSync(sourcePath, "utf8");
+    const content = fs3.readFileSync(sourcePath, "utf8");
     title = content.match(/<title>([^<]*)<\/title>/)?.[1] || void 0;
   }
   return { title, themes };
@@ -1732,7 +402,7 @@ function parseFileMetadata({
 function resolveTaskConfig(config, options) {
   const context = options.cwd ?? cwd;
   Logger.debug("resolveTaskConfig > context %s", context);
-  const entryContextDir = config.entryContext ? upath5.resolve(context, config.entryContext) : context;
+  const entryContextDir = config.entryContext ? upath2.resolve(context, config.entryContext) : context;
   const language = config.language;
   const readingProgression = config.readingProgression;
   const size = config.size ? parsePageSize(config.size) : void 0;
@@ -1740,8 +410,8 @@ function resolveTaskConfig(config, options) {
   const bleed = options.bleed;
   const cropOffset = options.cropOffset;
   const css = options.css;
-  const customStyle = options.style && (isValidUri(options.style) ? options.style : pathToFileURL3(options.style).href);
-  const customUserStyle = options.userStyle && (isValidUri(options.userStyle) ? options.userStyle : pathToFileURL3(options.userStyle).href);
+  const customStyle = options.style && (isValidUri(options.style) ? options.style : pathToFileURL2(options.style).href);
+  const customUserStyle = options.userStyle && (isValidUri(options.userStyle) ? options.userStyle : pathToFileURL2(options.userStyle).href);
   const singleDoc = options.singleDoc ?? false;
   const quick = options.quick ?? false;
   const temporaryFilePrefix = config.temporaryFilePrefix ?? `.vs-${Date.now()}.`;
@@ -1764,7 +434,7 @@ function resolveTaskConfig(config, options) {
     username: options.proxyUser,
     password: options.proxyPass
   } : void 0;
-  const image = config.image ?? CONTAINER_IMAGE;
+  const image = config.image ?? `${CONTAINER_URL}:${cliVersion}`;
   const viewer = config.viewer ?? void 0;
   const viewerParam = config.viewerParam ?? void 0;
   const logLevel = options.logLevel ?? "silent";
@@ -1782,7 +452,7 @@ function resolveTaskConfig(config, options) {
     };
     if (config.output) {
       return config.output.map((target) => {
-        const outputPath = upath5.resolve(context, target.path);
+        const outputPath = upath2.resolve(context, target.path);
         const format = target.format;
         switch (format) {
           case "pdf":
@@ -1814,7 +484,7 @@ function resolveTaskConfig(config, options) {
     return [
       {
         ...defaultPdfOptions,
-        path: upath5.resolve(context, filename)
+        path: upath2.resolve(context, filename)
       }
     ];
   })();
@@ -1837,7 +507,7 @@ function resolveTaskConfig(config, options) {
     };
   })();
   const cover = config.cover && {
-    src: upath5.resolve(entryContextDir, config.cover.src),
+    src: upath2.resolve(entryContextDir, config.cover.src),
     name: config.cover.name || COVER_HTML_IMAGE_ALT
   };
   const copyAsset = {
@@ -1870,7 +540,7 @@ function resolveTaskConfig(config, options) {
     cover
   });
   for (const output of outputs) {
-    const relPath = upath5.relative(context, output.path);
+    const relPath = upath2.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.`
@@ -1884,19 +554,18 @@ function resolveTaskConfig(config, options) {
   }
   const { entries, workspaceDir } = projectConfig;
   const duplicatedTarget = entries.find(
-    (v1, i) => entries.findLastIndex((v22) => v1.target === v22.target) !== i
+    (v1, i) => entries.findLastIndex((v2) => v1.target === v2.target) !== i
   )?.target;
   if (duplicatedTarget) {
     const sourceFile = entries.find(
       (entry) => entry.target === duplicatedTarget && entry.source?.type === "file"
     )?.source;
     throw new Error(
-      `The output path "${upath5.relative(workspaceDir, duplicatedTarget)}" will overwrite existing content.` + (sourceFile ? ` Please choose a different name for the source file: ${sourceFile.pathname}` : "")
+      `The output path "${upath2.relative(workspaceDir, duplicatedTarget)}" will overwrite existing content.` + (sourceFile ? ` Please choose a different name for the source file: ${sourceFile.pathname}` : "")
     );
   }
   const resolvedConfig = {
     ...projectConfig,
-    context,
     entryContextDir,
     outputs,
     themeIndexes,
@@ -1943,6 +612,7 @@ function resolveSingleInputConfig({
   base
 }) {
   Logger.debug("entering single entry config mode");
+  let serverRootDir;
   let sourcePath;
   let workspaceDir;
   const inputFormat = input.format;
@@ -1952,16 +622,17 @@ function resolveSingleInputConfig({
   const exportAliases = [];
   if (isValidUri(input.entry)) {
     sourcePath = input.entry;
+    serverRootDir = UseTemporaryServerRoot;
     workspaceDir = context;
   } else {
-    sourcePath = upath5.resolve(context, input.entry);
+    sourcePath = upath2.resolve(context, input.entry);
     statFileSync(sourcePath);
     switch (input.format) {
       case "webbook":
       case "markdown":
       case "pub-manifest":
       case "epub":
-        workspaceDir = upath5.dirname(sourcePath);
+        workspaceDir = upath2.dirname(sourcePath);
         break;
       case "epub-opf": {
         const rootDir = getEpubRootDir(sourcePath);
@@ -1976,8 +647,9 @@ function resolveSingleInputConfig({
       default:
         return input.format;
     }
+    serverRootDir = workspaceDir;
   }
-  const themesDir = upath5.resolve(workspaceDir, "themes");
+  const themesDir = upath2.resolve(workspaceDir, "themes");
   if (input.format === "markdown") {
     const contentType = "text/markdown";
     const metadata = parseFileMetadata({
@@ -1985,9 +657,9 @@ function resolveSingleInputConfig({
       sourcePath,
       workspaceDir
     });
-    const target = upath5.resolve(
+    const target = upath2.resolve(
       workspaceDir,
-      `${temporaryFilePrefix}${upath5.basename(sourcePath)}`
+      `${temporaryFilePrefix}${upath2.basename(sourcePath)}`
     ).replace(/\.md$/, ".html");
     touchTmpFile(target);
     const themes = metadata.themes ?? config.theme?.map(
@@ -2012,25 +684,25 @@ function resolveSingleInputConfig({
     });
     exportAliases.push({
       source: target,
-      target: upath5.resolve(
-        upath5.dirname(target),
-        upath5.basename(sourcePath).replace(/\.md$/, ".html")
+      target: upath2.resolve(
+        upath2.dirname(target),
+        upath2.basename(sourcePath).replace(/\.md$/, ".html")
       )
     });
   }
   let fallbackTitle;
   let viewerInput;
   if (inputFormat === "markdown") {
-    const manifestPath = upath5.resolve(
+    const manifestPath = upath2.resolve(
       workspaceDir,
       `${temporaryFilePrefix}${MANIFEST_FILENAME}`
     );
     touchTmpFile(manifestPath);
     exportAliases.push({
       source: manifestPath,
-      target: upath5.resolve(workspaceDir, MANIFEST_FILENAME)
+      target: upath2.resolve(workspaceDir, MANIFEST_FILENAME)
     });
-    fallbackTitle = entries.length === 1 && entries[0].title ? entries[0].title : upath5.basename(sourcePath);
+    fallbackTitle = entries.length === 1 && entries[0].title ? entries[0].title : upath2.basename(sourcePath);
     viewerInput = {
       type: "webpub",
       manifestPath,
@@ -2046,8 +718,8 @@ function resolveSingleInputConfig({
       }
       webbookEntryUrl = url.href;
     } else {
-      const rootFileUrl = pathToFileURL3(workspaceDir).href;
-      const urlPath = pathToFileURL3(sourcePath).href.slice(rootFileUrl.length);
+      const rootFileUrl = pathToFileURL2(workspaceDir).href;
+      const urlPath = pathToFileURL2(sourcePath).href.slice(rootFileUrl.length);
       webbookEntryUrl = `${base}${urlPath}`;
       webbookPath = sourcePath;
     }
@@ -2064,15 +736,16 @@ function resolveSingleInputConfig({
     viewerInput = {
       type: "epub",
       epubPath: sourcePath,
-      epubTmpOutputDir: upath5.join(
+      epubTmpOutputDir: upath2.join(
         sourcePath,
-        `../${temporaryFilePrefix}${upath5.basename(sourcePath)}`
+        `../${temporaryFilePrefix}${upath2.basename(sourcePath)}`
       )
     };
   } else {
     return inputFormat;
   }
   return {
+    serverRootDir,
     workspaceDir,
     themesDir,
     entries,
@@ -2096,13 +769,13 @@ function resolveComposedProjectConfig({
   cover
 }) {
   Logger.debug("entering composed project config mode");
-  const workspaceDir = upath5.resolve(
+  const workspaceDir = upath2.resolve(
     context,
     config.workspaceDir ?? ".vivliostyle"
   );
-  const themesDir = upath5.resolve(workspaceDir, "themes");
-  const pkgJsonPath = upath5.resolve(entryContextDir, "package.json");
-  const pkgJson = fs5.existsSync(pkgJsonPath) ? readJSON(pkgJsonPath) : void 0;
+  const themesDir = upath2.resolve(workspaceDir, "themes");
+  const pkgJsonPath = upath2.resolve(context, "package.json");
+  const pkgJson = fs3.existsSync(pkgJsonPath) ? readJSON(pkgJsonPath) : void 0;
   if (pkgJson) {
     Logger.debug("located package.json path", pkgJsonPath);
   }
@@ -2118,19 +791,19 @@ function resolveComposedProjectConfig({
   rootThemes.forEach((t) => themeIndexes.add(t));
   const tocConfig = {
     tocTitle: config.toc?.title ?? config?.tocTitle ?? TOC_TITLE,
-    target: upath5.resolve(workspaceDir, config.toc?.htmlPath ?? TOC_FILENAME),
+    target: upath2.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 : upath5.resolve(
+  const coverHtml = config.cover && ("htmlPath" in config.cover && !config.cover.htmlPath ? void 0 : upath2.resolve(
     workspaceDir,
     config.cover?.htmlPath || COVER_HTML_FILENAME
   ));
   const ensureCoverImage = (src) => {
-    const absPath = src && upath5.resolve(entryContextDir, src);
+    const absPath = src && upath2.resolve(entryContextDir, src);
     if (absPath) {
       statFileSync(absPath, {
         errorMessage: "Specified cover image does not exist"
@@ -2149,16 +822,16 @@ function resolveComposedProjectConfig({
         return {
           type: "uri",
           href: entryPath,
-          rootDir: upath5.join(workspaceDir, new URL(entryPath).host)
+          rootDir: upath2.join(workspaceDir, new URL(entryPath).host)
         };
       } else if (entryPath.startsWith("/")) {
         return {
           type: "uri",
           href: entryPath,
-          rootDir: upath5.join(workspaceDir, "localhost")
+          rootDir: upath2.join(workspaceDir, "localhost")
         };
       }
-      const pathname = upath5.resolve(entryContextDir, entryPath);
+      const pathname = upath2.resolve(entryContextDir, entryPath);
       statFileSync(pathname);
       const contentType = mime(pathname);
       if (!isManuscriptMediaType(contentType)) {
@@ -2181,9 +854,9 @@ function resolveComposedProjectConfig({
     const getTargetPath = (source) => {
       switch (source.type) {
         case "file":
-          return upath5.resolve(
+          return upath2.resolve(
             workspaceDir,
-            upath5.relative(entryContextDir, source.pathname).replace(/\.md$/, ".html")
+            upath2.relative(entryContextDir, source.pathname).replace(/\.md$/, ".html")
           );
         case "uri": {
           const url = new URL(source.href, "a://dummy");
@@ -2191,14 +864,14 @@ function resolveComposedProjectConfig({
           if (!/\.\w+$/.test(pathname)) {
             pathname = `${pathname.replace(/\/$/, "")}/index.html`;
           }
-          return upath5.join(source.rootDir, pathname);
+          return upath2.join(source.rootDir, pathname);
         }
         default:
           return source;
       }
     };
     if ((isContentsEntry(entry) || isCoverEntry(entry)) && entry.path) {
-      const source = upath5.resolve(entryContextDir, entry.path);
+      const source = upath2.resolve(entryContextDir, entry.path);
       try {
         statFileSync(source);
       } catch (error) {
@@ -2213,7 +886,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 ? upath5.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
+      let target = entry.output ? upath2.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({
           theme,
@@ -2225,9 +898,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 = upath5.resolve(
-          upath5.dirname(target),
-          `${temporaryFilePrefix}${upath5.basename(target)}`
+        const tmpPath = upath2.resolve(
+          upath2.dirname(target),
+          `${temporaryFilePrefix}${upath2.basename(target)}`
         );
         exportAliases.push({ source: tmpPath, target });
         touchTmpFile(tmpPath);
@@ -2248,7 +921,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 ? upath5.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
+      let target = entry.output ? upath2.resolve(workspaceDir, entry.output) : inputInfo && getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({
           theme,
@@ -2264,14 +937,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 ??= upath5.resolve(
+      target ??= upath2.resolve(
         workspaceDir,
         entry.path || coverHtml || COVER_HTML_FILENAME
       );
       if (inputInfo?.type === "file" && pathEquals(inputInfo.pathname, target)) {
-        const tmpPath = upath5.resolve(
-          upath5.dirname(target),
-          `${temporaryFilePrefix}${upath5.basename(target)}`
+        const tmpPath = upath2.resolve(
+          upath2.dirname(target),
+          `${temporaryFilePrefix}${upath2.basename(target)}`
         );
         exportAliases.push({ source: tmpPath, target });
         touchTmpFile(tmpPath);
@@ -2292,7 +965,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 ? upath5.resolve(workspaceDir, entry.output) : getTargetPath(inputInfo);
+      const target = entry.output ? upath2.resolve(workspaceDir, entry.output) : getTargetPath(inputInfo);
       const themes = entry.theme ? [entry.theme].flat().map(
         (theme) => parseTheme({ theme, context, workspaceDir, themesDir })
       ) : metadata?.themes ?? [...rootThemes];
@@ -2315,7 +988,7 @@ Maybe you want to set the "output" field instead.`
     if (entries.length === 1 && entries[0].title) {
       fallbackProjectTitle = entries[0].title;
     } else {
-      fallbackProjectTitle = upath5.basename(outputs[0].path);
+      fallbackProjectTitle = upath2.basename(outputs[0].path);
     }
   }
   if (!!config?.toc && !entries.find(({ rel }) => rel === "contents")) {
@@ -2337,16 +1010,17 @@ Maybe you want to set the "output" field instead.`
     });
   }
   return {
+    serverRootDir: context,
     workspaceDir,
     themesDir,
     entries,
     input: {
       format: "pub-manifest",
-      entry: upath5.join(workspaceDir, MANIFEST_FILENAME)
+      entry: upath2.join(workspaceDir, MANIFEST_FILENAME)
     },
     viewerInput: {
       type: "webpub",
-      manifestPath: upath5.join(workspaceDir, MANIFEST_FILENAME),
+      manifestPath: upath2.join(workspaceDir, MANIFEST_FILENAME),
       needToGenerateManifest: true
     },
     exportAliases,
@@ -2355,23 +1029,159 @@ Maybe you want to set the "output" field instead.`
   };
 }
 
+// src/browser.ts
+import fs4 from "node:fs";
+async function launchBrowser({
+  browserType,
+  proxy,
+  executablePath,
+  headless,
+  noSandbox,
+  disableDevShmUsage
+}) {
+  const playwright = await importNodeModule("playwright-core");
+  playwright.firefox.executablePath;
+  const options = browserType === "chromium" ? {
+    executablePath,
+    chromiumSandbox: !noSandbox,
+    headless,
+    args: [
+      // #579: disable web security to allow cross-origin requests
+      "--disable-web-security",
+      ...disableDevShmUsage ? ["--disable-dev-shm-usage"] : [],
+      // #357: Set devicePixelRatio=1 otherwise it causes layout issues in HiDPI displays
+      ...headless ? ["--force-device-scale-factor=1"] : [],
+      // #565: Add --disable-gpu option when running on WSL
+      ...isRunningOnWSL() ? ["--disable-gpu"] : [],
+      // set Chromium language to English to avoid locale-dependent issues
+      "--lang=en",
+      ...!headless && process.platform === "darwin" ? ["", "-AppleLanguages", "(en)"] : []
+    ],
+    env: { ...process.env, LANG: "en.UTF-8" },
+    proxy
+  } : (
+    // TODO: Investigate appropriate settings on Firefox & Webkit
+    { executablePath, headless }
+  );
+  const browser = await playwright[browserType].launch(options);
+  registerExitHandler("Closing browser", () => {
+    browser.close();
+  });
+  return browser;
+}
+async function getExecutableBrowserPath(browserType) {
+  const playwright = await importNodeModule("playwright-core");
+  return playwright[browserType].executablePath();
+}
+function getFullBrowserName(browserType) {
+  return {
+    chromium: "Chromium",
+    firefox: "Firefox",
+    webkit: "Webkit"
+  }[browserType];
+}
+function checkBrowserAvailability(path) {
+  return fs4.existsSync(path);
+}
+async function downloadBrowser(browserType) {
+  const { registry } = await importNodeModule("playwright-core/lib/server");
+  const executable = registry.findExecutable(browserType);
+  {
+    var _stack = [];
+    try {
+      const _2 = __using(_stack, Logger.suspendLogging(
+        "Rendering browser is not installed yet. Downloading now."
+      ));
+      await registry.install([executable], false);
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  return executable.executablePath();
+}
+async function launchPreview({
+  mode,
+  url,
+  onBrowserOpen,
+  onPageOpen,
+  config: { browser: browserConfig, proxy, sandbox, ignoreHttpsErrors }
+}) {
+  let executableBrowser = browserConfig.executablePath;
+  if (executableBrowser) {
+    if (!checkBrowserAvailability(executableBrowser)) {
+      throw new Error(
+        `Cannot find the browser. Please check the executable browser path: ${executableBrowser}`
+      );
+    }
+  } else {
+    executableBrowser = await getExecutableBrowserPath(browserConfig.type);
+    if (!checkBrowserAvailability(executableBrowser)) {
+      await downloadBrowser(browserConfig.type);
+    }
+  }
+  Logger.debug(`Executing browser path: ${executableBrowser}`);
+  const browser = await launchBrowser({
+    browserType: browserConfig.type,
+    proxy,
+    executablePath: executableBrowser,
+    headless: mode === "build",
+    noSandbox: !sandbox,
+    disableDevShmUsage: isInContainer()
+  });
+  await onBrowserOpen?.(browser);
+  const page = await browser.newPage({
+    viewport: mode === "build" ? (
+      // This viewport size important to detect headless environment in Vivliostyle viewer
+      // https://github.com/vivliostyle/vivliostyle.js/blob/73bcf323adcad80126b0175630609451ccd09d8a/packages/core/src/vivliostyle/vgen.ts#L2489-L2500
+      {
+        width: 800,
+        height: 600
+      }
+    ) : null,
+    ignoreHTTPSErrors: ignoreHttpsErrors
+  });
+  await onPageOpen?.(page);
+  page.on("dialog", () => {
+  });
+  await page.goto(url);
+  return { browser, page };
+}
+
+// src/server.ts
+import fs10 from "node:fs";
+import { URL as URL2 } from "node:url";
+import upath10 from "upath";
+import {
+  createServer,
+  preview
+} from "vite";
+
+// 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";
+
 // src/processor/compile.ts
 import { copy as copy3, move } from "fs-extra/esm";
-import fs9 from "node:fs";
+import fs8 from "node:fs";
 import picomatch from "picomatch";
 import prettier from "prettier";
 import parserHtml from "prettier/parser-html";
 import { glob as glob2 } from "tinyglobby";
-import upath9 from "upath";
+import upath6 from "upath";
 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 fs7 from "node:fs";
-import { pathToFileURL as pathToFileURL6 } from "node:url";
+import fs6 from "node:fs";
+import { pathToFileURL as pathToFileURL5 } from "node:url";
 import { glob } from "tinyglobby";
-import upath8 from "upath";
+import upath5 from "upath";
 
 // src/processor/html.tsx
 import jsdom, {
@@ -2380,8 +1190,8 @@ import jsdom, {
 } from "@vivliostyle/jsdom";
 import DOMPurify from "dompurify";
 import { toHtml } from "hast-util-to-html";
-import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL4 } from "node:url";
-import upath6 from "upath";
+import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "node:url";
+import upath3 from "upath";
 import MIMEType from "whatwg-mimetype";
 import { jsx, jsxs } from "hastscript/jsx-runtime";
 var createVirtualConsole = (onError) => {
@@ -2441,7 +1251,7 @@ var ResourceLoader = class extends BaseResourceLoader {
       if (mimeType === "text/html" && !/\.html?$/.test(url.pathname)) {
         url.pathname = `${url.pathname.replace(/\/$/, "")}/index.html`;
       }
-      let relTarget = upath6.relative(rootHref, url.href);
+      let relTarget = upath3.relative(rootHref, url.href);
       return decodeURI(relTarget);
     };
     const fetchedResources = [];
@@ -2460,7 +1270,7 @@ var ResourceLoader = class extends BaseResourceLoader {
           } catch (e) {
           }
           const relTarget = normalizeToLocalPath(url, encodingFormat);
-          const target = upath6.join(outputDir, relTarget);
+          const target = upath3.join(outputDir, relTarget);
           fetchedResources.push({ url: relTarget, encodingFormat });
           writeFileIfChanged(target, buffer);
         }).catch(onError);
@@ -2476,7 +1286,7 @@ async function getJsdomFromUrlOrFile({
     throw error;
   })
 }) {
-  const url = isValidUri(src) ? new URL(src) : pathToFileURL4(src);
+  const url = isValidUri(src) ? new URL(src) : pathToFileURL3(src);
   let dom;
   if (url.protocol === "http:" || url.protocol === "https:") {
     dom = await JSDOM.fromURL(src, {
@@ -2485,10 +1295,10 @@ async function getJsdomFromUrlOrFile({
     });
   } else if (url.protocol === "file:") {
     if (resourceLoader) {
-      const file = resourceLoader._readFile(fileURLToPath2(url));
+      const file = resourceLoader._readFile(fileURLToPath(url));
       resourceLoader.fetcherMap.set(url.href, file);
     }
-    dom = await JSDOM.fromFile(fileURLToPath2(url), {
+    dom = await JSDOM.fromFile(fileURLToPath(url), {
       virtualConsole,
       resources: resourceLoader,
       contentType: "text/html; charset=UTF-8"
@@ -2623,11 +1433,11 @@ async function generateTocListSection({
   } = transform;
   const structure = await Promise.all(
     entries.map(async (entry) => {
-      const href = encodeURI(upath6.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 || upath6.basename(entry.target, ".html"),
-        href: encodeURI(upath6.relative(distDir, entry.target)),
+        title: entry.title || upath3.basename(entry.target, ".html"),
+        href: encodeURI(upath3.relative(distDir, entry.target)),
         sections,
         children: []
         // TODO
@@ -2675,7 +1485,7 @@ async function processTocHtml(dom, {
     const l = document.createElement("link");
     l.setAttribute("rel", "publication");
     l.setAttribute("type", "application/ld+json");
-    l.setAttribute("href", encodeURI(upath6.relative(distDir, manifestPath)));
+    l.setAttribute("href", encodeURI(upath3.relative(distDir, manifestPath)));
     document.head.appendChild(l);
   }
   const style = document.querySelector("style[data-vv-style]");
@@ -2937,9 +1747,9 @@ import { XMLBuilder } from "fast-xml-parser";
 import { copy } from "fs-extra/esm";
 import GithubSlugger from "github-slugger";
 import { lookup as mime2 } from "mime-types";
-import fs6 from "node:fs";
-import { pathToFileURL as pathToFileURL5 } from "node:url";
-import upath7 from "upath";
+import fs5 from "node:fs";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
+import upath4 from "upath";
 import { v4 as uuid } from "uuid";
 import serializeToXml from "w3c-xmlserializer";
 var TOC_ID = "toc";
@@ -2953,21 +1763,21 @@ var COVER_IMAGE_MIMETYPES = [
   "image/webp"
 ];
 var changeExtname = (filepath, newExt) => {
-  let ext = upath7.extname(filepath);
+  let ext = upath4.extname(filepath);
   return `${filepath.slice(0, -ext.length)}${newExt}`;
 };
 var getRelativeHref = (target, baseUrl, rootUrl) => {
-  const absBasePath = upath7.join("/", baseUrl);
-  const absRootPath = upath7.join("/", rootUrl);
-  const hrefUrl = new URL(encodeURI(target), pathToFileURL5(absBasePath));
+  const absBasePath = upath4.join("/", baseUrl);
+  const absRootPath = upath4.join("/", rootUrl);
+  const hrefUrl = new URL(encodeURI(target), pathToFileURL4(absBasePath));
   if (hrefUrl.protocol !== "file:") {
     return target;
   }
   if (/\.html?$/.test(hrefUrl.pathname)) {
     hrefUrl.pathname = changeExtname(hrefUrl.pathname, ".xhtml");
   }
-  const pathname = upath7.posix.relative(
-    pathToFileURL5(upath7.dirname(absRootPath)).pathname,
+  const pathname = upath4.posix.relative(
+    pathToFileURL4(upath4.dirname(absRootPath)).pathname,
     hrefUrl.pathname
   );
   return `${pathname}${hrefUrl.search}${hrefUrl.hash}`;
@@ -2978,16 +1788,16 @@ var normalizeLocalizableString = (value, availableLanguages) => {
   }
   const values = [value].flat().map((value2) => typeof value2 === "string" ? { value: value2 } : value2);
   const localizedValues = values.filter(
-    (v3) => !!v3.language
+    (v2) => !!v2.language
   );
   const preferredLang = lookupLanguage(
-    localizedValues.map((v3) => v3.language),
+    localizedValues.map((v2) => v2.language),
     availableLanguages
   );
   if (preferredLang) {
-    return localizedValues[localizedValues.findIndex((v3) => v3.language === preferredLang)].value;
+    return localizedValues[localizedValues.findIndex((v2) => v2.language === preferredLang)].value;
   }
-  return values.find((v3) => !v3.language)?.value;
+  return values.find((v2) => !v2.language)?.value;
 };
 var appendManifestProperty = (entry, newProperty) => {
   entry.properties = entry.properties ? Array.from(/* @__PURE__ */ new Set([...entry.properties.split(" "), newProperty])).join(
@@ -3010,10 +1820,10 @@ async function exportEpub({
     epubVersion
   });
   const [tmpDir] = await useTmpDirectory();
-  fs6.mkdirSync(upath7.join(tmpDir, "META-INF"), { recursive: true });
-  await copy(webpubDir, upath7.join(tmpDir, "EPUB"));
+  fs5.mkdirSync(upath4.join(tmpDir, "META-INF"), { recursive: true });
+  await copy(webpubDir, upath4.join(tmpDir, "EPUB"));
   const uid = `urn:uuid:${uuid()}`;
-  const entryHtmlRelPath = entryHtmlFile && upath7.relative(webpubDir, upath7.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))
   );
@@ -3050,7 +1860,7 @@ async function exportEpub({
         return acc;
       } catch (e) {
       }
-      if (!fs6.existsSync(upath7.join(tmpDir, "EPUB", url))) {
+      if (!fs5.existsSync(upath4.join(tmpDir, "EPUB", url))) {
         return acc;
       }
       const mediaType = encodingFormat || mime2(url) || "text/plain";
@@ -3073,7 +1883,7 @@ async function exportEpub({
     (url) => /\.html?$/.test(url)
   );
   let tocHtml = htmlFiles.find((f) => f === tocResource?.url);
-  const readingOrder = [manifest.readingOrder || entryHtmlRelPath].flat().flatMap((v3) => v3 ? typeof v3 === "string" ? { url: v3 } : v3 : []);
+  const readingOrder = [manifest.readingOrder || entryHtmlRelPath].flat().flatMap((v2) => v2 ? typeof v2 === "string" ? { url: v2 } : v2 : []);
   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."
@@ -3104,7 +1914,7 @@ async function exportEpub({
       text: EPUB_LANDMARKS_COVER_ENTRY
     });
   }
-  const contextDir = upath7.join(tmpDir, "EPUB");
+  const contextDir = upath4.join(tmpDir, "EPUB");
   const processHtml = async (target2) => {
     let parseResult;
     try {
@@ -3141,7 +1951,7 @@ async function exportEpub({
     processResult[target2] = await processHtml(target2);
   }
   const { document: entryDocument } = processResult[tocHtml].dom.window;
-  const docLanguages = [manifest.inLanguage].flat().filter((v3) => Boolean(v3));
+  const docLanguages = [manifest.inLanguage].flat().filter((v2) => Boolean(v2));
   if (docLanguages.length === 0) {
     docLanguages.push(entryDocument.documentElement.lang || "en");
   }
@@ -3166,20 +1976,20 @@ async function exportEpub({
     });
   }
   if (relManifestPath) {
-    await fs6.promises.rm(upath7.join(tmpDir, "EPUB", relManifestPath), {
+    await fs5.promises.rm(upath4.join(tmpDir, "EPUB", relManifestPath), {
       force: true,
       recursive: true
     });
     delete manifestItem[relManifestPath];
   }
-  fs6.writeFileSync(
-    upath7.join(tmpDir, "META-INF/container.xml"),
+  fs5.writeFileSync(
+    upath4.join(tmpDir, "META-INF/container.xml"),
     EPUB_CONTAINER_XML,
     "utf8"
   );
   Logger.debug(`Generating content.opf`);
-  fs6.writeFileSync(
-    upath7.join(tmpDir, "EPUB/content.opf"),
+  fs5.writeFileSync(
+    upath4.join(tmpDir, "EPUB/content.opf"),
     buildEpubPackageDocument({
       epubVersion,
       uid,
@@ -3196,13 +2006,13 @@ async function exportEpub({
 async function writeAsXhtml(dom, absPath) {
   const xhtml = `${XML_DECLARATION}
 ${serializeToXml(dom.window.document)}`;
-  await fs6.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
+  await fs5.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
 }
 async function transpileHtmlToXhtml({
   target,
   contextDir
 }) {
-  const absPath = upath7.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   const dom = await getJsdomFromUrlOrFile({ src: absPath });
   const { document } = dom.window;
   document.documentElement.removeAttribute("xmlns");
@@ -3212,7 +2022,7 @@ async function transpileHtmlToXhtml({
     el.setAttribute("href", getRelativeHref(href, target, target));
   });
   await writeAsXhtml(dom, absPath);
-  await fs6.promises.unlink(absPath);
+  await fs5.promises.unlink(absPath);
   return {
     dom,
     // FIXME: Yes, I recognize this implementation is inadequate.
@@ -3270,7 +2080,7 @@ async function processTocDocument({
         let name = normalizeLocalizableString(content.name, docLanguages);
         if (!name) {
           const dom2 = await getJsdomFromUrlOrFile({
-            src: upath7.join(contextDir, changeExtname(content.url, ".xhtml"))
+            src: upath4.join(contextDir, changeExtname(content.url, ".xhtml"))
           });
           name = dom2.window.document.title;
         }
@@ -3323,7 +2133,7 @@ async function processTocDocument({
     }
     publicationLinkEl.parentNode?.removeChild(publicationLinkEl);
   }
-  const absPath = upath7.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { tocResourceTree };
 }
@@ -3338,7 +2148,7 @@ async function processPagelistDocument({
     nav.setAttribute("id", PAGELIST_ID);
     nav.setAttribute("epub:type", "page-list");
   }
-  const absPath = upath7.join(contextDir, target);
+  const absPath = upath4.join(contextDir, target);
   await writeAsXhtml(dom, absPath);
   return { pageListResourceTree };
 }
@@ -3355,7 +2165,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((v3) => ({ ...attributes || {}, "#text": `${value}` }));
+  const transformToGenericTextNode = (value, attributes) => [value].flat().filter(Boolean).map((v2) => ({ ...attributes || {}, "#text": `${value}` }));
   const transformContributor = (contributorMap) => Object.entries(contributorMap).flatMap(
     ([type, contributor]) => contributor ? [contributor].flat().map((entry, index) => ({
       _id: slugger.slug(`${type}-${index + 1}`),
@@ -3457,7 +2267,7 @@ async function compressEpub({
   sourceDir
 }) {
   Logger.debug(`Compressing EPUB: ${target}`);
-  const output = fs6.createWriteStream(target);
+  const output = fs5.createWriteStream(target);
   const archive = archiver("zip", {
     zlib: { level: 9 }
     // Compression level
@@ -3477,8 +2287,8 @@ async function compressEpub({
       // https://www.w3.org/TR/epub-33/#sec-zip-container-mime
       store: true
     });
-    archive.directory(upath7.join(sourceDir, "META-INF"), "META-INF");
-    archive.directory(upath7.join(sourceDir, "EPUB"), "EPUB");
+    archive.directory(upath4.join(sourceDir, "META-INF"), "META-INF");
+    archive.directory(upath4.join(sourceDir, "EPUB"), "EPUB");
     archive.finalize();
   });
 }
@@ -3495,11 +2305,11 @@ function sortManifestResources(manifest) {
 async function prepareWebPublicationDirectory({
   outputDir
 }) {
-  if (fs7.existsSync(outputDir)) {
+  if (fs6.existsSync(outputDir)) {
     Logger.debug("going to remove existing webpub", outputDir);
-    await fs7.promises.rm(outputDir, { force: true, recursive: true });
+    await fs6.promises.rm(outputDir, { force: true, recursive: true });
   }
-  fs7.mkdirSync(outputDir, { recursive: true });
+  fs6.mkdirSync(outputDir, { recursive: true });
 }
 function transformPublicationManifest(entity, transformer) {
   const { url: transformUrl } = transformer;
@@ -3596,15 +2406,15 @@ function writePublicationManifest(output, options) {
       typeof thrownError === "string" ? thrownError : thrownError.stack ?? thrownError.message
     );
   }
-  fs7.mkdirSync(upath8.dirname(output), { recursive: true });
-  fs7.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
+  fs6.mkdirSync(upath5.dirname(output), { recursive: true });
+  fs6.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
   return publication;
 }
 async function retrieveWebbookEntry({
   viewerInput,
   outputDir
 }) {
-  const webbookEntryUrl = viewerInput.webbookPath ? pathToFileURL6(viewerInput.webbookPath).href : viewerInput.webbookEntryUrl;
+  const webbookEntryUrl = viewerInput.webbookPath ? pathToFileURL5(viewerInput.webbookPath).href : viewerInput.webbookEntryUrl;
   if (/^https?:/i.test(webbookEntryUrl)) {
     Logger.logUpdate("Fetching remote contents");
   }
@@ -3613,18 +2423,18 @@ async function retrieveWebbookEntry({
     src: webbookEntryUrl,
     resourceLoader
   });
-  const entryHtml = viewerInput.webbookPath ? upath8.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,
     baseUrl: webbookEntryUrl
   }) || {};
   const rootUrl = /^https?:/i.test(webbookEntryUrl) ? new URL("/", webbookEntryUrl).href : new URL(".", webbookEntryUrl).href;
-  const pathContains2 = (url) => !upath8.relative(rootUrl, url).startsWith("..");
+  const pathContains2 = (url) => !upath5.relative(rootUrl, url).startsWith("..");
   const retriever = new Map(resourceLoader.fetcherMap);
   if (manifest && manifestUrl) {
-    [manifest.resources || []].flat().forEach((v3) => {
-      const url = typeof v3 === "string" ? v3 : v3.url;
+    [manifest.resources || []].flat().forEach((v2) => {
+      const url = typeof v2 === "string" ? v2 : v2.url;
       const fullUrl = new URL(encodeURI(url), manifestUrl).href;
       if (!pathContains2(fullUrl) || retriever.has(fullUrl)) {
         return;
@@ -3634,9 +2444,9 @@ async function retrieveWebbookEntry({
         retriever.set(fullUrl, fetchPromise);
       }
     });
-    for (const v3 of [manifest.readingOrder || []].flat()) {
-      const url = typeof v3 === "string" ? v3 : v3.url;
-      if (!/\.html?$/.test(url) && !(typeof v3 === "string" || v3.encodingFormat === "text/html")) {
+    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")) {
         continue;
       }
       const fullUrl = new URL(encodeURI(url), manifestUrl).href;
@@ -3652,7 +2462,7 @@ async function retrieveWebbookEntry({
         })
       });
       subpathResourceLoader.fetcherMap.forEach(
-        (v4, k) => !retriever.has(k) && retriever.set(k, v4)
+        (v3, k) => !retriever.has(k) && retriever.set(k, v3)
       );
     }
   }
@@ -3670,7 +2480,7 @@ async function retrieveWebbookEntry({
     const referencedContents = [
       ...[manifest.readingOrder || []].flat(),
       ...[manifest.resources || []].flat()
-    ].map((v3) => typeof v3 === "string" ? v3 : v3.url);
+    ].map((v2) => typeof v2 === "string" ? v2 : v2.url);
     manifest.resources = [
       ...[manifest.resources || []].flat(),
       ...fetchedResources.filter(
@@ -3681,14 +2491,14 @@ async function retrieveWebbookEntry({
   }
   Logger.debug(
     "Saved webbook resources",
-    fetchedResources.map((v3) => v3.url)
+    fetchedResources.map((v2) => v2.url)
   );
   Logger.debug(
     "Publication manifest from webbook",
     manifest && JSON.stringify(manifest, null, 2)
   );
   return {
-    entryHtmlFile: upath8.join(outputDir, entryHtml),
+    entryHtmlFile: upath5.join(outputDir, entryHtml),
     manifest
   };
 }
@@ -3703,12 +2513,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 = upath8.relative(outputDir, entryHtmlFile);
+  const entry = upath5.relative(outputDir, entryHtmlFile);
   const allFiles = await glob("**", {
     cwd: outputDir
   });
   const manifest = writePublicationManifest(
-    upath8.join(outputDir, MANIFEST_FILENAME),
+    upath5.join(outputDir, MANIFEST_FILENAME),
     {
       title,
       author,
@@ -3725,13 +2535,13 @@ async function supplyWebPublicationManifestForWebbook({
   link.setAttribute("type", "application/ld+json");
   link.setAttribute(
     "href",
-    upath8.relative(
-      upath8.dirname(entryHtmlFile),
-      upath8.join(outputDir, MANIFEST_FILENAME)
+    upath5.relative(
+      upath5.dirname(entryHtmlFile),
+      upath5.join(outputDir, MANIFEST_FILENAME)
     )
   );
   document.head.appendChild(link);
-  await fs7.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
+  await fs6.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
   Logger.debug(
     "Generated publication manifest from HTML",
     JSON.stringify(manifest, null, 2)
@@ -3749,8 +2559,8 @@ async function copyWebPublicationAssets({
   entries
 }) {
   const relExportAliases = exportAliases.map(({ source, target }) => ({
-    source: upath8.relative(input, source),
-    target: upath8.relative(input, target)
+    source: upath5.relative(input, source),
+    target: upath5.relative(input, target)
   })).filter(({ source }) => !source.startsWith(".."));
   const allFiles = /* @__PURE__ */ new Set([
     ...await globAssetFiles({
@@ -3762,7 +2572,7 @@ async function copyWebPublicationAssets({
     }),
     ...await glob(
       [
-        `**/${upath8.relative(input, manifestPath)}`,
+        `**/${upath5.relative(input, manifestPath)}`,
         "**/*.{html,htm,xhtml,xht,css}"
       ],
       {
@@ -3803,24 +2613,24 @@ async function copyWebPublicationAssets({
     )
   );
   const resources = [];
-  let actualManifestPath = upath8.join(
+  let actualManifestPath = upath5.join(
     outputDir,
-    upath8.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 = upath8.join(outputDir, relTarget);
-    fs7.mkdirSync(upath8.dirname(target), { recursive: true });
-    await copy2(upath8.join(input, file), target);
-    if (alias && pathEquals(upath8.join(input, alias.source), manifestPath)) {
+    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)) {
       actualManifestPath = target;
     }
   }
   Logger.debug("webbook publication.json", actualManifestPath);
   const manifest = decodePublicationManifest(
-    JSON.parse(fs7.readFileSync(actualManifestPath, "utf8"))
+    JSON.parse(fs6.readFileSync(actualManifestPath, "utf8"))
   );
   for (const entry of relExportAliases) {
     const rewriteAliasPath = (e) => {
@@ -3852,14 +2662,14 @@ async function copyWebPublicationAssets({
     ...[manifest.resources || []].flat(),
     ...resources.flatMap((file) => {
       if (preDefinedResources.includes(file) || // Omit publication.json itself
-      pathEquals(file, upath8.relative(outputDir, actualManifestPath))) {
+      pathEquals(file, upath5.relative(outputDir, actualManifestPath))) {
         return [];
       }
       return file;
     })
   ];
   sortManifestResources(manifest);
-  fs7.writeFileSync(
+  fs6.writeFileSync(
     actualManifestPath,
     JSON.stringify(encodePublicationManifest(manifest), null, 2)
   );
@@ -3891,7 +2701,7 @@ async function buildWebPublication({
     if (config.input.format === "markdown") {
       const entry = [manifest.readingOrder].flat()[0];
       if (entry) {
-        entryHtmlFile = upath8.join(
+        entryHtmlFile = upath5.join(
           outputDir,
           typeof entry === "string" ? entry : entry.url
         );
@@ -3916,7 +2726,7 @@ async function buildWebPublication({
       webpubDir: outputDir,
       entryHtmlFile,
       manifest,
-      relManifestPath: actualManifestPath && upath8.relative(outputDir, actualManifestPath),
+      relManifestPath: actualManifestPath && upath5.relative(outputDir, actualManifestPath),
       target: target.path,
       epubVersion: target.version
     });
@@ -3926,12 +2736,12 @@ async function buildWebPublication({
 
 // src/processor/theme.ts
 import Arborist from "@npmcli/arborist";
-import fs8 from "node:fs";
+import fs7 from "node:fs";
 async function checkThemeInstallationNecessity({
   themesDir,
   themeIndexes
 }) {
-  if (!fs8.existsSync(themesDir)) {
+  if (!fs7.existsSync(themesDir)) {
     return [...themeIndexes].some((theme) => theme.type === "package");
   }
   const commonOpt = {
@@ -3949,7 +2759,7 @@ async function installThemeDependencies({
   themesDir,
   themeIndexes
 }) {
-  fs8.mkdirSync(themesDir, { recursive: true });
+  fs7.mkdirSync(themesDir, { recursive: true });
   try {
     const commonOpt = {
       path: themesDir,
@@ -3964,7 +2774,7 @@ async function installThemeDependencies({
         )
       )
     ];
-    const rm = existing.filter((v3) => !add.includes(v3));
+    const rm = existing.filter((v2) => !add.includes(v2));
     const opt = { ...commonOpt, rm, add };
     const arb = new Arborist(opt);
     await arb.reify(opt);
@@ -3984,21 +2794,21 @@ function locateThemePath(theme, from) {
     return theme.location;
   }
   if (theme.type === "file") {
-    return upath9.relative(from, theme.location);
+    return upath6.relative(from, theme.location);
   }
   if (theme.importPath) {
     return [theme.importPath].flat().map((locator) => {
-      const resolvedPath = upath9.resolve(theme.location, locator);
-      if (!pathContains(theme.location, resolvedPath) || !fs9.existsSync(resolvedPath)) {
+      const resolvedPath = upath6.resolve(theme.location, locator);
+      if (!pathContains(theme.location, resolvedPath) || !fs8.existsSync(resolvedPath)) {
         throw new Error(
           `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
         );
       }
-      return upath9.relative(from, resolvedPath);
+      return upath6.relative(from, resolvedPath);
     });
   } else {
-    const pkgJsonPath = upath9.join(theme.location, "package.json");
-    const packageJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf8"));
+    const pkgJsonPath = upath6.join(theme.location, "package.json");
+    const packageJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf8"));
     const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
     if (!maybeStyle) {
       throw new DetailError(
@@ -4006,7 +2816,7 @@ function locateThemePath(theme, from) {
         "Please ensure this package satisfies a `vivliostyle.theme.style` property."
       );
     }
-    return upath9.relative(from, upath9.join(theme.location, maybeStyle));
+    return upath6.relative(from, upath6.join(theme.location, maybeStyle));
   }
 }
 async function cleanupWorkspace({
@@ -4022,27 +2832,27 @@ async function cleanupWorkspace({
   }
   Logger.debug("cleanup workspace files", workspaceDir);
   let movedWorkspacePath;
-  if (pathContains(workspaceDir, themesDir) && fs9.existsSync(themesDir)) {
-    movedWorkspacePath = upath9.join(
-      upath9.dirname(workspaceDir),
+  if (pathContains(workspaceDir, themesDir) && fs8.existsSync(themesDir)) {
+    movedWorkspacePath = upath6.join(
+      upath6.dirname(workspaceDir),
       `.vs-${Date.now()}`
     );
-    const movedThemePath = upath9.join(
+    const movedThemePath = upath6.join(
       movedWorkspacePath,
-      upath9.relative(workspaceDir, themesDir)
+      upath6.relative(workspaceDir, themesDir)
     );
-    fs9.mkdirSync(upath9.dirname(movedThemePath), { recursive: true });
+    fs8.mkdirSync(upath6.dirname(movedThemePath), { recursive: true });
     registerExitHandler(
       `Removing the moved workspace directory: ${movedWorkspacePath}`,
       () => {
-        if (movedWorkspacePath && fs9.existsSync(movedWorkspacePath)) {
-          fs9.rmSync(movedWorkspacePath, { recursive: true, force: true });
+        if (movedWorkspacePath && fs8.existsSync(movedWorkspacePath)) {
+          fs8.rmSync(movedWorkspacePath, { recursive: true, force: true });
         }
       }
     );
     await move(themesDir, movedThemePath);
   }
-  await fs9.promises.rm(workspaceDir, { recursive: true, force: true });
+  await fs8.promises.rm(workspaceDir, { recursive: true, force: true });
   if (movedWorkspacePath) {
     await move(movedWorkspacePath, workspaceDir);
   }
@@ -4051,10 +2861,10 @@ async function prepareThemeDirectory({
   themesDir,
   themeIndexes
 }) {
-  if (fs9.existsSync(upath9.join(themesDir, "packages")) && !fs9.existsSync(upath9.join(themesDir, "node_modules"))) {
-    fs9.renameSync(
-      upath9.join(themesDir, "packages"),
-      upath9.join(themesDir, "node_modules")
+  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 (await checkThemeInstallationNecessity({ themesDir, themeIndexes })) {
@@ -4063,7 +2873,7 @@ async function prepareThemeDirectory({
   }
   for (const theme of themeIndexes) {
     if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
-      fs9.mkdirSync(upath9.dirname(theme.location), { recursive: true });
+      fs8.mkdirSync(upath6.dirname(theme.location), { recursive: true });
       await copy3(theme.source, theme.location);
     }
   }
@@ -4084,7 +2894,7 @@ async function transformManuscript(entry, {
   let resourceLoader;
   let resourceUrl;
   const style = entry.themes.flatMap(
-    (theme) => locateThemePath(theme, upath9.dirname(entry.target))
+    (theme) => locateThemePath(theme, upath6.dirname(entry.target))
   );
   if (source?.type === "file") {
     if (source.contentType === "text/markdown") {
@@ -4179,7 +2989,7 @@ async function transformManuscript(entry, {
     content = await processTocHtml(content, {
       entries: manuscriptEntries,
       manifestPath,
-      distDir: upath9.dirname(contentsEntry.target),
+      distDir: upath6.dirname(contentsEntry.target),
       tocTitle: contentsEntry.tocTitle,
       sectionDepth: contentsEntry.sectionDepth,
       styleOptions: contentsEntry,
@@ -4189,10 +2999,10 @@ async function transformManuscript(entry, {
   if (entry.rel === "cover") {
     const coverEntry = entry;
     content = await processCoverHtml(content, {
-      imageSrc: upath9.relative(
-        upath9.join(
+      imageSrc: upath6.relative(
+        upath6.join(
           entryContextDir,
-          upath9.relative(workspaceDir, coverEntry.target),
+          upath6.relative(workspaceDir, coverEntry.target),
           ".."
         ),
         coverEntry.coverImageSrc
@@ -4239,7 +3049,7 @@ async function generateManifest({
 }) {
   const manifestEntries = entries.map((entry) => ({
     title: entry.rel === "contents" && entry.tocTitle || entry.title,
-    path: upath9.relative(workspaceDir, entry.target),
+    path: upath6.relative(workspaceDir, entry.target),
     encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/html" ? void 0 : entry.contentType,
     rel: entry.rel
   }));
@@ -4249,7 +3059,7 @@ async function generateManifest({
     language,
     readingProgression,
     cover: cover && {
-      url: upath9.relative(entryContextDir, cover.src),
+      url: upath6.relative(entryContextDir, cover.src),
       name: cover.name
     },
     entries: manifestEntries,
@@ -4277,8 +3087,8 @@ function getIgnoreThemeExamplePatterns({
   cwd: cwd2
 }) {
   return pathContains(cwd2, themesDir) ? [
-    `${upath9.relative(cwd2, themesDir)}/node_modules/*/example`,
-    `${upath9.relative(cwd2, themesDir)}/node_modules/*/*/example`
+    `${upath6.relative(cwd2, themesDir)}/node_modules/*/example`,
+    `${upath6.relative(cwd2, themesDir)}/node_modules/*/*/example`
   ] : [];
 }
 function getIgnoreAssetPatterns({
@@ -4288,10 +3098,10 @@ function getIgnoreAssetPatterns({
 }) {
   return [
     ...outputs.flatMap(
-      ({ format, path: p }) => !pathContains(cwd2, p) ? [] : format === "webpub" ? upath9.join(upath9.relative(cwd2, p), "**") : upath9.relative(cwd2, p)
+      ({ 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) ? upath9.relative(cwd2, template.pathname) : [];
+      return template?.type === "file" && pathContains(cwd2, template.pathname) ? upath6.relative(cwd2, template.pathname) : [];
     })
   ];
 }
@@ -4359,7 +3169,7 @@ async function copyAssets({
   if (pathEquals(entryContextDir, workspaceDir)) {
     return;
   }
-  const relWorkspaceDir = upath9.relative(entryContextDir, workspaceDir);
+  const relWorkspaceDir = upath6.relative(entryContextDir, workspaceDir);
   const assets = await globAssetFiles({
     copyAsset,
     cwd: entryContextDir,
@@ -4368,14 +3178,14 @@ async function copyAssets({
     entries,
     ignore: [
       // don't copy workspace itself
-      ...relWorkspaceDir ? [upath9.join(relWorkspaceDir, "**")] : []
+      ...relWorkspaceDir ? [upath6.join(relWorkspaceDir, "**")] : []
     ]
   });
   Logger.debug("assets", assets);
   for (const asset of assets) {
-    const target = upath9.join(workspaceDir, asset);
-    fs9.mkdirSync(upath9.dirname(target), { recursive: true });
-    await copy3(upath9.resolve(entryContextDir, asset), target);
+    const target = upath6.join(workspaceDir, asset);
+    fs8.mkdirSync(upath6.dirname(target), { recursive: true });
+    await copy3(upath6.resolve(entryContextDir, asset), target);
   }
 }
 
@@ -4402,16 +3212,16 @@ function createEntriesRouteLookup(entries, cwd2) {
     if (uri.charCodeAt(len) === 47) {
       uri = uri.substring(0, len);
     }
-    let arr = [], tmp2 = `${uri}/index`;
+    let arr = [], tmp = `${uri}/index`;
     for (; i < extns.length; i++) {
       x = extns[i] ? `.${extns[i]}` : "";
       if (uri) arr.push(uri + x);
-      arr.push(tmp2 + x);
+      arr.push(tmp + x);
     }
     return arr;
   };
   const cache = entries.reduce((acc, e) => {
-    acc[`/${upath10.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
+    acc[`/${upath7.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
     return acc;
   }, {});
   return (uri) => {
@@ -4430,12 +3240,12 @@ function getWorkspaceMatcher({
   let entryFiles = [];
   switch (viewerInput.type) {
     case "webpub":
-      entryFiles = [upath10.relative(workspaceDir, viewerInput.manifestPath)];
+      entryFiles = [upath7.relative(workspaceDir, viewerInput.manifestPath)];
       break;
     case "epub":
       entryFiles = [
-        upath10.join(
-          upath10.relative(workspaceDir, viewerInput.epubTmpOutputDir),
+        upath7.join(
+          upath7.relative(workspaceDir, viewerInput.epubTmpOutputDir),
           "**"
         )
       ];
@@ -4450,9 +3260,9 @@ function getWorkspaceMatcher({
   return picomatch2(
     [
       ...entryFiles,
-      ...pathContains(workspaceDir, themesDir) ? [upath10.join(upath10.relative(workspaceDir, themesDir), "**")] : [],
+      ...pathContains(workspaceDir, themesDir) ? [upath7.join(upath7.relative(workspaceDir, themesDir), "**")] : [],
       ...[...themeIndexes].flatMap(
-        (theme) => theme.type === "file" && pathContains(workspaceDir, theme.location) ? [upath10.relative(workspaceDir, theme.location)] : []
+        (theme) => theme.type === "file" && pathContains(workspaceDir, theme.location) ? [upath7.relative(workspaceDir, theme.location)] : []
       )
     ],
     { dot: true, ignore: ["node_modules/**"] }
@@ -4542,8 +3352,8 @@ function vsDevServerPlugin({
     return await promise;
   }
   async function invalidate(entry, config2) {
-    const cwd2 = pathToFileURL7(config2.workspaceDir);
-    const target = pathToFileURL7(entry.target);
+    const cwd2 = pathToFileURL6(config2.workspaceDir);
+    const target = pathToFileURL6(entry.target);
     if (target.href.indexOf(cwd2.href) !== 0) {
       return;
     }
@@ -4677,23 +3487,28 @@ function vsDevServerPlugin({
 
 // src/vite/vite-plugin-static-serve.ts
 import sirv2 from "sirv";
-import upath11 from "upath";
+import upath8 from "upath";
 function vsStaticServePlugin({
   config: _config,
   inlineConfig
 }) {
   let config = _config;
-  const createMiddlewares = () => Object.entries(config.static).flatMap(
-    ([base, dirs]) => dirs.map(
-      (dir) => [
-        base,
-        sirv2(upath11.resolve(config.context, dir), {
-          dev: true,
-          etag: false
-        })
-      ]
-    )
-  );
+  const createMiddlewares = () => {
+    if (typeof config.serverRootDir !== "string") {
+      return [];
+    }
+    return Object.entries(config.static).flatMap(
+      ([base, dirs]) => dirs.map(
+        (dir) => [
+          base,
+          sirv2(upath8.resolve(config.serverRootDir, dir), {
+            dev: true,
+            etag: false
+          })
+        ]
+      )
+    );
+  };
   return {
     name: "vivliostyle:static-serve",
     apply: () => Boolean(inlineConfig.enableStaticServe),
@@ -4715,9 +3530,9 @@ function vsStaticServePlugin({
 }
 
 // src/vite/vite-plugin-viewer.ts
-import fs10 from "node:fs";
+import fs9 from "node:fs";
 import sirv3 from "sirv";
-import upath12 from "upath";
+import upath9 from "upath";
 var viewerClientId = "@vivliostyle:viewer:client";
 var viewerClientRequestPath = `/${viewerClientId}`;
 var viewerClientContent = (
@@ -4730,13 +3545,13 @@ if (import.meta.hot) {
 }`
 );
 function vsViewerPlugin(_) {
-  const serveRootDir = upath12.join(viewerRoot, "lib");
+  const serveRootDir = upath9.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(
-        fs10.readFileSync(upath12.join(serveRootDir, "index.html"), "utf-8"),
+        fs9.readFileSync(upath9.join(serveRootDir, "index.html"), "utf-8"),
         `<script type="module" src="${viewerClientRequestPath}"></script>`
       );
       res.statusCode = 200;
@@ -4837,7 +3652,7 @@ async function getSourceUrl({
       input = viewerInput.epubOpfPath;
       break;
     case "epub": {
-      if (!fs11.existsSync(viewerInput.epubTmpOutputDir)) {
+      if (!fs10.existsSync(viewerInput.epubTmpOutputDir)) {
         await openEpub(viewerInput.epubPath, viewerInput.epubTmpOutputDir);
       }
       input = getDefaultEpubOpfPath(viewerInput.epubTmpOutputDir);
@@ -4847,7 +3662,7 @@ async function getSourceUrl({
       input = viewerInput;
   }
   return (isValidUri(input) ? new URL2(input) : new URL2(
-    upath13.posix.join(base, upath13.relative(workspaceDir, input)),
+    upath10.posix.join(base, upath10.relative(workspaceDir, input)),
     rootUrl
   )).href;
 }
@@ -4892,14 +3707,15 @@ async function createViteServer({
     server: viteConfig.server,
     preview: viteConfig.preview,
     customLogger: viteConfig.customLogger,
-    cacheDir: viteConfig.cacheDir
+    cacheDir: viteConfig.cacheDir,
+    root: viteConfig.root
   };
   Logger.debug("createViteServer > viteInlineConfig %O", viteInlineConfig);
-  if (config.context === config.workspaceDir) {
+  if (config.serverRootDir === config.workspaceDir) {
     const { cacheDir } = viteInlineConfig;
     registerExitHandler("Removing the Vite cacheDir", () => {
-      if (fs11.existsSync(cacheDir)) {
-        fs11.rmSync(cacheDir, { recursive: true });
+      if (fs10.existsSync(cacheDir)) {
+        fs10.rmSync(cacheDir, { recursive: true });
       }
     });
   }
@@ -4963,20 +3779,12 @@ function vsBrowserPlugin({
 }
 
 export {
-  cwd,
-  runExitHandlers,
-  gracefulError,
-  pathEquals,
-  isInContainer,
-  isUnicodeSupported,
-  randomBookSymbol,
-  Logger,
-  parseFlagsToInlineConfig,
-  setupConfigFromFlags,
   loadVivliostyleConfig,
   warnDeprecatedConfig,
   mergeConfig,
   mergeInlineConfig,
+  isWebPubConfig,
+  resolveTaskConfig,
   getFullBrowserName,
   launchPreview,
   vsBrowserPlugin,
@@ -4988,13 +3796,8 @@ export {
   vsDevServerPlugin,
   vsStaticServePlugin,
   vsViewerPlugin,
+  getSourceUrl,
   getViewerFullUrl,
-  createViteServer,
-  CONTAINER_IMAGE,
-  toContainerPath,
-  collectVolumeArgs,
-  runContainer,
-  buildPDFWithContainer,
-  isWebPubConfig,
-  resolveTaskConfig
+  createViteServer
 };
+//# sourceMappingURL=chunk-KSGAS7XH.js.map