@vivliostyle/cli 9.0.0-next.3 → 9.0.0-next.5

package/dist/chunk-SPYTZBBG.js

@@ -0,0 +1,4988 @@
+import {
+  COVER_HTML_FILENAME,
+  COVER_HTML_IMAGE_ALT,
+  EMPTY_DATA_URI,
+  EPUB_CONTAINER_XML,
+  EPUB_LANDMARKS_COVER_ENTRY,
+  EPUB_LANDMARKS_TITLE,
+  EPUB_LANDMARKS_TOC_ENTRY,
+  EPUB_NS,
+  EPUB_OUTPUT_VERSION,
+  MANIFEST_FILENAME,
+  TOC_FILENAME,
+  TOC_TITLE,
+  VIEWER_ROOT_PATH,
+  XML_DECLARATION,
+  cliVersion,
+  viewerRoot
+} from "./chunk-EX7EA34F.js";
+import {
+  importNodeModule
+} from "./chunk-WX6JHPSL.js";
+import {
+  VivliostyleConfigSchema,
+  VivliostyleInlineConfig
+} from "./chunk-DMARNPN5.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-BIEQXUOY.js";
+
+// src/util.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import {
+  evaluate,
+  parse
+} from "@humanwhocodes/momoa";
+import AjvModule from "ajv";
+import AjvFormatsModule from "ajv-formats";
+import { XMLParser } from "fast-xml-parser";
+import { removeSync } from "fs-extra/esm";
+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 = () => {
+        removeSync(path);
+      };
+      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 = () => {
+    removeSync(path);
+  };
+  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");
+}
+async function openEpub(epubPath, tmpDir) {
+  await inflateZip(epubPath, tmpDir);
+  Logger.debug(`Created the temporary EPUB directory: ${tmpDir}`);
+  const deleteEpub = () => {
+    fs.rmSync(tmpDir, { 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 Ajv = AjvModule.default;
+var addFormats = AjvFormatsModule.default;
+var getAjvValidatorFunction = (schema, refSchemas) => (obj) => {
+  const ajv = new Ajv({ strict: false });
+  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;
+}
+
+// src/config/load.ts
+import fs2 from "node:fs";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import upath3 from "upath";
+import * as v2 from "valibot";
+var require2 = createRequire(import.meta.url);
+function locateVivliostyleConfig({
+  config,
+  cwd: cwd2 = cwd
+}) {
+  if (config) {
+    return upath3.resolve(cwd2, config);
+  }
+  return [".js", ".mjs", ".cjs", ".json"].map((ext) => upath3.join(cwd2, `vivliostyle.config${ext}`)).find((p) => fs2.existsSync(p));
+}
+async function loadVivliostyleConfig({
+  config,
+  configData,
+  cwd: cwd2
+}) {
+  if (configData) {
+    return v2.parse(VivliostyleConfigSchema, configData);
+  }
+  const absPath = locateVivliostyleConfig({ config, cwd: cwd2 });
+  if (!absPath) {
+    return;
+  }
+  let parsedConfig;
+  let jsonRaw;
+  try {
+    if (upath3.extname(absPath) === ".json") {
+      jsonRaw = fs2.readFileSync(absPath, "utf8");
+      parsedConfig = parseJsonc(jsonRaw);
+    } else {
+      delete require2.cache[require2.resolve(absPath)];
+      const url = pathToFileURL(absPath);
+      url.search = `version=${Date.now()}`;
+      parsedConfig = (await import(
+        /* @vite-ignore */
+        url.href
+      )).default;
+      jsonRaw = JSON.stringify(parsedConfig, null, 2);
+    }
+  } catch (error) {
+    const thrownError = error;
+    throw new DetailError(
+      `An error occurred on loading a config file: ${absPath}`,
+      thrownError.stack ?? thrownError.message
+    );
+  }
+  const result = v2.safeParse(VivliostyleConfigSchema, parsedConfig);
+  if (result.success) {
+    const { tasks, inlineOptions } = result.output;
+    return {
+      tasks,
+      inlineOptions: {
+        ...inlineOptions,
+        cwd: cwd2 ?? cwd,
+        config: absPath
+      }
+    };
+  } else {
+    const errorString = prettifySchemaError(jsonRaw, result.issues);
+    throw new DetailError(
+      `Validation of vivliostyle config failed. Please check the schema: ${config}`,
+      errorString
+    );
+  }
+}
+function warnDeprecatedConfig(config) {
+  if (config.tasks.some((task) => task.includeAssets)) {
+    Logger.logWarn(
+      "'includeAssets' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'copyAsset.includes' property instead."
+    );
+  }
+  if (config.tasks.some((task) => task.tocTitle)) {
+    Logger.logWarn(
+      "'tocTitle' property of Vivliostyle config was deprecated and will be removed in a future release. Please use 'toc.title' property instead."
+    );
+  }
+  if (config.tasks.some((task) => task.http)) {
+    Logger.logWarn(
+      "'http' property of Vivliostyle config was deprecated and will be removed in a future release. This option is enabled by default, and the file protocol is no longer supported."
+    );
+  }
+}
+
+// src/config/merge.ts
+var pruneObject = (obj) => {
+  const ret = { ...obj };
+  for (const key in ret) {
+    if (ret[key] === void 0 || ret[key] === null) {
+      delete ret[key];
+    }
+  }
+  return ret;
+};
+function mergeConfig(base, override) {
+  return {
+    tasks: base.tasks.map((task, i) => ({
+      ...pruneObject(task),
+      ...pruneObject(override)
+    })),
+    inlineOptions: base.inlineOptions
+  };
+}
+function mergeInlineConfig({ tasks, inlineOptions }, inlineConfig) {
+  const {
+    theme,
+    size,
+    pressReady,
+    title,
+    author,
+    language,
+    readingProgression,
+    timeout,
+    image,
+    viewer,
+    viewerParam,
+    browser,
+    output,
+    renderMode,
+    preflight,
+    preflightOption,
+    vite,
+    viteConfigFile,
+    host,
+    port,
+    ...overrideInlineOptions
+  } = inlineConfig;
+  return {
+    tasks: tasks.map((task) => ({
+      ...pruneObject(task),
+      ...pruneObject({
+        theme,
+        size,
+        pressReady,
+        title,
+        author,
+        language,
+        readingProgression,
+        timeout,
+        image,
+        viewer,
+        viewerParam,
+        browser,
+        vite,
+        viteConfigFile
+      }),
+      output: (output?.length ? output : task.output)?.map((o) => ({
+        ...pruneObject(o),
+        ...pruneObject({
+          renderMode,
+          preflight,
+          preflightOption
+        })
+      })),
+      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",
+      // set Chromium language to English to avoid locale-dependent issues (e.g. minimum font size)
+      "--lang=en"
+      // ...(!headless && process.platform === 'darwin'
+      //   ? ['-AppleLanguages', '(en)']
+      //   : []),
+    ].filter((value) => Boolean(value)),
+    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 };
+}
+
+// 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 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;
+}
+
+// src/processor/markdown.ts
+import {
+  readMetadata
+} from "@vivliostyle/vfm";
+import fs4 from "node:fs";
+import vfile from "vfile";
+function safeReadMetadata(content) {
+  try {
+    return readMetadata(content);
+  } catch {
+    return {};
+  }
+}
+async function processMarkdown(documentProcessorFactory, filepath, options = {}) {
+  const markdownString = fs4.readFileSync(filepath, "utf8");
+  const processor = documentProcessorFactory(
+    options,
+    safeReadMetadata(markdownString)
+  );
+  const processed = await processor.process(
+    vfile({ path: filepath, contents: markdownString })
+  );
+  return processed;
+}
+function readMarkdownMetadata(filepath) {
+  return safeReadMetadata(fs4.readFileSync(filepath, "utf8"));
+}
+
+// src/config/resolve.ts
+var manuscriptMediaTypes = [
+  "text/markdown",
+  "text/html",
+  "application/xhtml+xml"
+];
+var DEFAULT_ASSET_EXTENSIONS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "svg",
+  "gif",
+  "webp",
+  "apng",
+  "ttf",
+  "otf",
+  "woff",
+  "woff2"
+];
+function isManuscriptMediaType(mediaType) {
+  return !!(mediaType && manuscriptMediaTypes.includes(mediaType));
+}
+function isWebPubConfig(config) {
+  return config.viewerInput.type === "webpub";
+}
+function isWebbookConfig(config) {
+  return config.viewerInput.type === "webbook";
+}
+function parsePackageName(specifier, cwd2) {
+  try {
+    let result = npa(specifier, cwd2);
+    if (result.type === "git" && result.saveSpec?.startsWith("github:")) {
+      result = npa(`file:${specifier}`, cwd2);
+    }
+    return result;
+  } catch (error) {
+    return null;
+  }
+}
+function parseTheme({
+  theme,
+  context,
+  workspaceDir,
+  themesDir
+}) {
+  const { specifier, import: importPath } = typeof theme === "string" ? { specifier: theme, import: void 0 } : theme;
+  if (isValidUri(specifier)) {
+    return {
+      type: "uri",
+      name: upath5.basename(specifier),
+      location: specifier
+    };
+  }
+  const stylePath = upath5.resolve(context, specifier);
+  if (fs5.existsSync(stylePath) && stylePath.endsWith(".css")) {
+    const sourceRelPath = upath5.relative(context, stylePath);
+    return {
+      type: "file",
+      name: upath5.basename(specifier),
+      source: stylePath,
+      location: upath5.resolve(workspaceDir, sourceRelPath)
+    };
+  }
+  const parsed = parsePackageName(specifier, context);
+  if (!parsed) {
+    throw new Error(`Invalid package name: ${specifier}`);
+  }
+  if (!parsed.registry && parsed.type !== "directory") {
+    throw new Error(`This package specifier is not allowed: ${specifier}`);
+  }
+  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"));
+      name = packageJson.name;
+      resolvedSpecifier = parsed.fetchSpec;
+    }
+  }
+  if (!name) {
+    throw new Error(`Could not determine the package name: ${specifier}`);
+  }
+  return {
+    type: "package",
+    name,
+    specifier: resolvedSpecifier,
+    location: upath5.join(themesDir, "node_modules", name),
+    importPath
+  };
+}
+function parsePageSize(size) {
+  const [width, height, ...others] = `${size}`.split(",");
+  if (!width || others.length) {
+    throw new Error(`Cannot parse size: ${size}`);
+  } else if (width && height) {
+    return {
+      width,
+      height
+    };
+  } else {
+    return {
+      format: width
+    };
+  }
+}
+function parseFileMetadata({
+  contentType,
+  sourcePath,
+  workspaceDir,
+  themesDir
+}) {
+  const sourceDir = upath5.dirname(sourcePath);
+  let title;
+  let themes;
+  if (contentType === "text/markdown") {
+    const metadata = readMarkdownMetadata(sourcePath);
+    title = metadata.title;
+    if (metadata.vfm?.theme && themesDir) {
+      themes = [metadata.vfm.theme].flat().filter(
+        (entry) => !!entry && (typeof entry === "string" || typeof entry === "object")
+      ).map(
+        (theme) => parseTheme({
+          theme,
+          context: sourceDir,
+          workspaceDir,
+          themesDir
+        })
+      );
+    }
+  } else {
+    const content = fs5.readFileSync(sourcePath, "utf8");
+    title = content.match(/<title>([^<]*)<\/title>/)?.[1] || void 0;
+  }
+  return { title, themes };
+}
+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 language = config.language;
+  const readingProgression = config.readingProgression;
+  const size = config.size ? parsePageSize(config.size) : void 0;
+  const cropMarks = options.cropMarks ?? false;
+  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 singleDoc = options.singleDoc ?? false;
+  const quick = options.quick ?? false;
+  const temporaryFilePrefix = config.temporaryFilePrefix ?? `.vs-${Date.now()}.`;
+  const documentProcessorFactory = config?.documentProcessor ?? VFM;
+  const vfmOptions = {
+    ...config?.vfm,
+    hardLineBreaks: config?.vfm?.hardLineBreaks ?? false,
+    disableFormatHtml: config?.vfm?.disableFormatHtml ?? false
+  };
+  const timeout = config.timeout ?? 12e4;
+  const sandbox = options.sandbox ?? false;
+  const browser = {
+    type: config.browser ?? "chromium",
+    executablePath: options.executableBrowser
+  };
+  const proxyServer = options.proxyServer ?? process.env.HTTP_PROXY ?? void 0;
+  const proxy = proxyServer ? {
+    server: proxyServer,
+    bypass: options.proxyBypass ?? process.env.NOPROXY ?? void 0,
+    username: options.proxyUser,
+    password: options.proxyPass
+  } : void 0;
+  const image = config.image ?? CONTAINER_IMAGE;
+  const viewer = config.viewer ?? void 0;
+  const viewerParam = config.viewerParam ?? void 0;
+  const logLevel = options.logLevel ?? "silent";
+  const ignoreHttpsErrors = options.ignoreHttpsErrors ?? false;
+  const base = config.base ?? "/vivliostyle";
+  const staticRoutes = config.static ?? {};
+  const viteConfig = config.vite;
+  const viteConfigFile = config.viteConfigFile ?? true;
+  const outputs = (() => {
+    const defaultPdfOptions = {
+      format: "pdf",
+      renderMode: "local",
+      preflight: config.pressReady ? "press-ready" : void 0,
+      preflightOption: []
+    };
+    if (config.output) {
+      return config.output.map((target) => {
+        const outputPath = upath5.resolve(context, target.path);
+        const format = target.format;
+        switch (format) {
+          case "pdf":
+            return {
+              ...defaultPdfOptions,
+              ...target,
+              format,
+              path: outputPath
+            };
+          case "epub":
+            return {
+              ...target,
+              format,
+              path: outputPath,
+              version: EPUB_OUTPUT_VERSION
+            };
+          case "webpub":
+            return {
+              ...target,
+              format,
+              path: outputPath
+            };
+          default:
+            return format;
+        }
+      });
+    }
+    const filename = config.title ? `${config.title}.pdf` : "output.pdf";
+    return [
+      {
+        ...defaultPdfOptions,
+        path: upath5.resolve(context, filename)
+      }
+    ];
+  })();
+  const { server, rootUrl } = (() => {
+    let host = config.server?.host ?? false;
+    const port = config.server?.port ?? 13e3;
+    if (outputs.some(
+      (target) => target.format === "pdf" && target.renderMode === "docker"
+    )) {
+      host = true;
+    }
+    const rootHostname = isInContainer() ? CONTAINER_LOCAL_HOSTNAME : !host ? "localhost" : host === true ? "0.0.0.0" : host;
+    return {
+      server: {
+        host,
+        port,
+        proxy: config.server?.proxy ?? {}
+      },
+      rootUrl: `http://${rootHostname}:${port}`
+    };
+  })();
+  const cover = config.cover && {
+    src: upath5.resolve(entryContextDir, config.cover.src),
+    name: config.cover.name || COVER_HTML_IMAGE_ALT
+  };
+  const copyAsset = {
+    includes: config.copyAsset?.includes ?? config.includeAssets ?? [],
+    excludes: config.copyAsset?.excludes ?? [],
+    fileExtensions: [
+      .../* @__PURE__ */ new Set([
+        ...DEFAULT_ASSET_EXTENSIONS,
+        ...config.copyAsset?.includeFileExtensions ?? []
+      ])
+    ].filter(
+      (ext) => !(config.copyAsset?.excludeFileExtensions ?? []).includes(ext)
+    )
+  };
+  const themeIndexes = /* @__PURE__ */ new Set();
+  const projectConfig = !options.config && options.input ? resolveSingleInputConfig({
+    config,
+    input: options.input,
+    context,
+    temporaryFilePrefix,
+    themeIndexes,
+    base
+  }) : resolveComposedProjectConfig({
+    config,
+    context,
+    entryContextDir,
+    outputs,
+    temporaryFilePrefix,
+    themeIndexes,
+    rootUrl,
+    cover
+  });
+  for (const output of outputs) {
+    const relPath = upath5.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.`
+      );
+    }
+    if (pathContains(output.path, projectConfig.workspaceDir) || pathEquals(output.path, projectConfig.workspaceDir)) {
+      throw new Error(
+        `The output path is set to "${relPath}", but this will overwrite the working directory of Vivliostyle. Please specify a different path.`
+      );
+    }
+  }
+  const { entries, workspaceDir } = projectConfig;
+  const duplicatedTarget = entries.find(
+    (v1, i) => entries.findLastIndex((v22) => v1.target === v22.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}` : "")
+    );
+  }
+  const resolvedConfig = {
+    ...projectConfig,
+    context,
+    entryContextDir,
+    outputs,
+    themeIndexes,
+    copyAsset,
+    temporaryFilePrefix,
+    size,
+    cropMarks,
+    bleed,
+    cropOffset,
+    css,
+    customStyle,
+    customUserStyle,
+    singleDoc,
+    quick,
+    language,
+    readingProgression,
+    documentProcessorFactory,
+    vfmOptions,
+    cover,
+    timeout,
+    sandbox,
+    browser,
+    proxy,
+    image,
+    viewer,
+    viewerParam,
+    logLevel,
+    ignoreHttpsErrors,
+    base,
+    server,
+    static: staticRoutes,
+    rootUrl,
+    viteConfig,
+    viteConfigFile
+  };
+  return resolvedConfig;
+}
+function resolveSingleInputConfig({
+  config,
+  input,
+  context,
+  temporaryFilePrefix,
+  themeIndexes,
+  base
+}) {
+  Logger.debug("entering single entry config mode");
+  let sourcePath;
+  let workspaceDir;
+  const inputFormat = input.format;
+  const title = config?.title;
+  const author = config?.author;
+  const entries = [];
+  const exportAliases = [];
+  if (isValidUri(input.entry)) {
+    sourcePath = input.entry;
+    workspaceDir = context;
+  } else {
+    sourcePath = upath5.resolve(context, input.entry);
+    statFileSync(sourcePath);
+    switch (input.format) {
+      case "webbook":
+      case "markdown":
+      case "pub-manifest":
+      case "epub":
+        workspaceDir = upath5.dirname(sourcePath);
+        break;
+      case "epub-opf": {
+        const rootDir = getEpubRootDir(sourcePath);
+        if (!rootDir) {
+          throw new Error(
+            `Could not determine the EPUB root directory for the OPF file: ${sourcePath}`
+          );
+        }
+        workspaceDir = rootDir;
+        break;
+      }
+      default:
+        return input.format;
+    }
+  }
+  const themesDir = upath5.resolve(workspaceDir, "themes");
+  if (input.format === "markdown") {
+    const contentType = "text/markdown";
+    const metadata = parseFileMetadata({
+      contentType,
+      sourcePath,
+      workspaceDir
+    });
+    const target = upath5.resolve(
+      workspaceDir,
+      `${temporaryFilePrefix}${upath5.basename(sourcePath)}`
+    ).replace(/\.md$/, ".html");
+    touchTmpFile(target);
+    const themes = metadata.themes ?? config.theme?.map(
+      (theme) => parseTheme({
+        theme,
+        context,
+        workspaceDir,
+        themesDir
+      })
+    ) ?? [];
+    themes.forEach((t) => themeIndexes.add(t));
+    entries.push({
+      contentType,
+      source: {
+        type: "file",
+        pathname: sourcePath,
+        contentType
+      },
+      target,
+      title: metadata.title,
+      themes
+    });
+    exportAliases.push({
+      source: target,
+      target: upath5.resolve(
+        upath5.dirname(target),
+        upath5.basename(sourcePath).replace(/\.md$/, ".html")
+      )
+    });
+  }
+  let fallbackTitle;
+  let viewerInput;
+  if (inputFormat === "markdown") {
+    const manifestPath = upath5.resolve(
+      workspaceDir,
+      `${temporaryFilePrefix}${MANIFEST_FILENAME}`
+    );
+    touchTmpFile(manifestPath);
+    exportAliases.push({
+      source: manifestPath,
+      target: upath5.resolve(workspaceDir, MANIFEST_FILENAME)
+    });
+    fallbackTitle = entries.length === 1 && entries[0].title ? entries[0].title : upath5.basename(sourcePath);
+    viewerInput = {
+      type: "webpub",
+      manifestPath,
+      needToGenerateManifest: true
+    };
+  } else if (inputFormat === "webbook") {
+    let webbookEntryUrl;
+    let webbookPath;
+    if (isValidUri(sourcePath)) {
+      const url = new URL(sourcePath);
+      if (/^https?:/i.test(url.protocol) && !url.pathname.endsWith("/") && !/\.html?$/.test(url.pathname)) {
+        url.pathname = `${url.pathname}/`;
+      }
+      webbookEntryUrl = url.href;
+    } else {
+      const rootFileUrl = pathToFileURL3(workspaceDir).href;
+      const urlPath = pathToFileURL3(sourcePath).href.slice(rootFileUrl.length);
+      webbookEntryUrl = `${base}${urlPath}`;
+      webbookPath = sourcePath;
+    }
+    viewerInput = { type: "webbook", webbookEntryUrl, webbookPath };
+  } else if (inputFormat === "pub-manifest") {
+    viewerInput = {
+      type: "webpub",
+      manifestPath: sourcePath,
+      needToGenerateManifest: false
+    };
+  } else if (inputFormat === "epub-opf") {
+    viewerInput = { type: "epub-opf", epubOpfPath: sourcePath };
+  } else if (inputFormat === "epub") {
+    viewerInput = {
+      type: "epub",
+      epubPath: sourcePath,
+      epubTmpOutputDir: upath5.join(
+        sourcePath,
+        `../${temporaryFilePrefix}${upath5.basename(sourcePath)}`
+      )
+    };
+  } else {
+    return inputFormat;
+  }
+  return {
+    workspaceDir,
+    themesDir,
+    entries,
+    input: {
+      format: inputFormat,
+      entry: sourcePath
+    },
+    viewerInput,
+    exportAliases,
+    title: title || fallbackTitle,
+    author
+  };
+}
+function resolveComposedProjectConfig({
+  config,
+  context,
+  entryContextDir,
+  outputs,
+  temporaryFilePrefix,
+  themeIndexes,
+  rootUrl,
+  cover
+}) {
+  Logger.debug("entering composed project config mode");
+  const workspaceDir = upath5.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;
+  if (pkgJson) {
+    Logger.debug("located package.json path", pkgJsonPath);
+  }
+  const exportAliases = [];
+  const rootThemes = config.theme?.map(
+    (theme) => parseTheme({
+      theme,
+      context,
+      workspaceDir,
+      themesDir
+    })
+  ) ?? [];
+  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),
+    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(
+    workspaceDir,
+    config.cover?.htmlPath || COVER_HTML_FILENAME
+  ));
+  const ensureCoverImage = (src) => {
+    const absPath = src && upath5.resolve(entryContextDir, src);
+    if (absPath) {
+      statFileSync(absPath, {
+        errorMessage: "Specified cover image does not exist"
+      });
+    }
+    return absPath;
+  };
+  const projectTitle = config?.title ?? pkgJson?.name;
+  const projectAuthor = config?.author ?? pkgJson?.author;
+  const isContentsEntry = (entry) => entry.rel === "contents";
+  const isCoverEntry = (entry) => entry.rel === "cover";
+  const isArticleEntry = (entry) => !isContentsEntry(entry) && !isCoverEntry(entry);
+  function parseEntry(entry) {
+    const getInputInfo = (entryPath) => {
+      if (/^https?:/.test(entryPath)) {
+        return {
+          type: "uri",
+          href: entryPath,
+          rootDir: upath5.join(workspaceDir, new URL(entryPath).host)
+        };
+      } else if (entryPath.startsWith("/")) {
+        return {
+          type: "uri",
+          href: `${rootUrl}${entryPath}`,
+          rootDir: upath5.join(workspaceDir, "localhost")
+        };
+      }
+      const pathname = upath5.resolve(entryContextDir, entryPath);
+      statFileSync(pathname);
+      const contentType = mime(pathname);
+      if (!isManuscriptMediaType(contentType)) {
+        throw new Error(
+          `Invalid manuscript type ${contentType} detected: ${entry}`
+        );
+      }
+      return {
+        type: "file",
+        pathname,
+        contentType,
+        metadata: parseFileMetadata({
+          contentType,
+          sourcePath: pathname,
+          workspaceDir,
+          themesDir
+        })
+      };
+    };
+    const getTargetPath = (source) => {
+      switch (source.type) {
+        case "file":
+          return upath5.resolve(
+            workspaceDir,
+            upath5.relative(entryContextDir, source.pathname).replace(/\.md$/, ".html")
+          );
+        case "uri": {
+          const url = new URL(source.href, "a://dummy");
+          let pathname = url.pathname;
+          if (!/\.html?$/.test(pathname)) {
+            pathname = `${pathname.replace(/\/$/, "")}/index.html`;
+          }
+          return upath5.join(source.rootDir, pathname);
+        }
+        default:
+          return source;
+      }
+    };
+    if ((isContentsEntry(entry) || isCoverEntry(entry)) && entry.path) {
+      const source = upath5.resolve(entryContextDir, entry.path);
+      try {
+        statFileSync(source);
+      } catch (error) {
+        Logger.logWarn(
+          `The "path" option is set but the file does not exist: ${source}
+Maybe you want to set the "output" field instead.`
+        );
+        entry.output = entry.path;
+        entry.path = void 0;
+      }
+    }
+    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);
+      const themes = entry.theme ? [entry.theme].flat().map(
+        (theme) => parseTheme({
+          theme,
+          context,
+          workspaceDir,
+          themesDir
+        })
+      ) : metadata?.themes ?? [...rootThemes];
+      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)}`
+        );
+        exportAliases.push({ source: tmpPath, target });
+        touchTmpFile(tmpPath);
+        target = tmpPath;
+      }
+      const parsedEntry = {
+        rel: "contents",
+        ...tocConfig,
+        target,
+        title: entry.title ?? metadata?.title ?? projectTitle,
+        themes,
+        pageBreakBefore: entry.pageBreakBefore,
+        pageCounterReset: entry.pageCounterReset,
+        ..."type" in template && { template }
+      };
+      return parsedEntry;
+    }
+    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);
+      const themes = entry.theme ? [entry.theme].flat().map(
+        (theme) => parseTheme({
+          theme,
+          context,
+          workspaceDir,
+          themesDir
+        })
+      ) : metadata?.themes ?? [];
+      themes.forEach((t) => themeIndexes.add(t));
+      const coverImageSrc = ensureCoverImage(entry.imageSrc || cover?.src);
+      if (!coverImageSrc) {
+        throw new Error(
+          `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(
+        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)}`
+        );
+        exportAliases.push({ source: tmpPath, target });
+        touchTmpFile(tmpPath);
+        target = tmpPath;
+      }
+      const parsedEntry = {
+        rel: "cover",
+        target,
+        title: entry.title ?? metadata?.title ?? projectTitle,
+        themes,
+        coverImageSrc,
+        coverImageAlt: entry.imageAlt || cover?.name || COVER_HTML_IMAGE_ALT,
+        pageBreakBefore: entry.pageBreakBefore,
+        ..."type" in template && { template }
+      };
+      return parsedEntry;
+    }
+    if (isArticleEntry(entry)) {
+      const inputInfo = getInputInfo(entry.path);
+      const { metadata, ...source } = inputInfo;
+      const target = entry.output ? upath5.resolve(workspaceDir, entry.output) : getTargetPath(inputInfo);
+      const themes = entry.theme ? [entry.theme].flat().map(
+        (theme) => parseTheme({ theme, context, workspaceDir, themesDir })
+      ) : metadata?.themes ?? [...rootThemes];
+      themes.forEach((t) => themeIndexes.add(t));
+      const parsedEntry = {
+        contentType: inputInfo.type === "file" ? inputInfo.contentType : "text/html",
+        source,
+        target,
+        title: entry.title ?? metadata?.title ?? projectTitle,
+        themes,
+        ...entry.rel && { rel: entry.rel }
+      };
+      return parsedEntry;
+    }
+    return entry;
+  }
+  const entries = config.entry.map(parseEntry);
+  let fallbackProjectTitle;
+  if (!projectTitle) {
+    if (entries.length === 1 && entries[0].title) {
+      fallbackProjectTitle = entries[0].title;
+    } else {
+      fallbackProjectTitle = upath5.basename(outputs[0].path);
+    }
+  }
+  if (!!config?.toc && !entries.find(({ rel }) => rel === "contents")) {
+    entries.unshift({
+      rel: "contents",
+      ...tocConfig,
+      themes: [...rootThemes]
+    });
+  }
+  if (cover && coverHtml && !entries.find(({ rel }) => rel === "cover")) {
+    entries.unshift({
+      rel: "cover",
+      target: coverHtml,
+      title: projectTitle,
+      themes: [],
+      // Don't inherit rootThemes for cover documents
+      coverImageSrc: ensureCoverImage(cover.src),
+      coverImageAlt: cover.name
+    });
+  }
+  return {
+    workspaceDir,
+    themesDir,
+    entries,
+    input: {
+      format: "pub-manifest",
+      entry: upath5.join(workspaceDir, MANIFEST_FILENAME)
+    },
+    viewerInput: {
+      type: "webpub",
+      manifestPath: upath5.join(workspaceDir, MANIFEST_FILENAME),
+      needToGenerateManifest: true
+    },
+    exportAliases,
+    title: projectTitle || fallbackProjectTitle,
+    author: projectAuthor
+  };
+}
+
+// src/processor/compile.ts
+import { copy as copy3, move, remove as remove3 } from "fs-extra/esm";
+import fs9 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 MIMEType2 from "whatwg-mimetype";
+
+// src/output/webbook.ts
+import { copy as copy2, remove as remove2 } from "fs-extra/esm";
+import { lookup as mime3 } from "mime-types";
+import fs7 from "node:fs";
+import { pathToFileURL as pathToFileURL6 } from "node:url";
+import { glob } from "tinyglobby";
+import upath8 from "upath";
+
+// src/processor/html.tsx
+import jsdom, {
+  ResourceLoader as BaseResourceLoader,
+  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 MIMEType from "whatwg-mimetype";
+import { jsx, jsxs } from "hastscript/jsx-runtime";
+var createVirtualConsole = (onError) => {
+  const virtualConsole = new jsdom.VirtualConsole();
+  virtualConsole.on("error", (message) => {
+    Logger.debug("[JSDOM Console] error:", message);
+  });
+  virtualConsole.on("warn", (message) => {
+    Logger.debug("[JSDOM Console] warn:", message);
+  });
+  virtualConsole.on("log", (message) => {
+    Logger.debug("[JSDOM Console] log:", message);
+  });
+  virtualConsole.on("info", (message) => {
+    Logger.debug("[JSDOM Console] info:", message);
+  });
+  virtualConsole.on("dir", (message) => {
+    Logger.debug("[JSDOM Console] dir:", message);
+  });
+  virtualConsole.on("jsdomError", (error) => {
+    if (error.message === "Could not parse CSS stylesheet") {
+      return;
+    }
+    onError(
+      new DetailError(
+        "Error occurred when loading content",
+        error.stack ?? error.message
+      )
+    );
+  });
+  return virtualConsole;
+};
+var htmlPurify = DOMPurify(new JSDOM("").window);
+var ResourceLoader = class extends BaseResourceLoader {
+  fetcherMap = /* @__PURE__ */ new Map();
+  fetch(url, options) {
+    Logger.debug(`[JSDOM] Fetching resource: ${url}`);
+    const fetcher = super.fetch(url, options);
+    if (fetcher) {
+      this.fetcherMap.set(url, fetcher);
+    }
+    return fetcher;
+  }
+  static async saveFetchedResources({
+    fetcherMap,
+    rootUrl,
+    outputDir,
+    onError
+  }) {
+    const rootHref = /^https?:/i.test(new URL(rootUrl).protocol) ? new URL("/", rootUrl).href : new URL(".", rootUrl).href;
+    const normalizeToLocalPath = (urlString, mimeType) => {
+      let url = new URL(urlString);
+      url.hash = "";
+      if (mimeType === "text/html" && !/\.html?$/.test(url.pathname)) {
+        url.pathname = `${url.pathname.replace(/\/$/, "")}/index.html`;
+      }
+      let relTarget = upath6.relative(rootHref, url.href);
+      return decodeURI(relTarget);
+    };
+    const fetchedResources = [];
+    await Promise.allSettled(
+      [...fetcherMap.entries()].flatMap(async ([url, fetcher]) => {
+        if (!url.startsWith(rootHref)) {
+          return [];
+        }
+        return fetcher.then(async (buffer) => {
+          let encodingFormat;
+          try {
+            const contentType = fetcher.response?.headers["content-type"];
+            if (contentType) {
+              encodingFormat = new MIMEType(contentType).essence;
+            }
+          } catch (e) {
+          }
+          const relTarget = normalizeToLocalPath(url, encodingFormat);
+          const target = upath6.join(outputDir, relTarget);
+          fetchedResources.push({ url: relTarget, encodingFormat });
+          writeFileIfChanged(target, buffer);
+        }).catch(onError);
+      })
+    );
+    return fetchedResources;
+  }
+};
+async function getJsdomFromUrlOrFile({
+  src,
+  resourceLoader,
+  virtualConsole = createVirtualConsole((error) => {
+    throw error;
+  })
+}) {
+  const url = isValidUri(src) ? new URL(src) : pathToFileURL4(src);
+  let dom;
+  if (url.protocol === "http:" || url.protocol === "https:") {
+    dom = await JSDOM.fromURL(src, {
+      virtualConsole,
+      resources: resourceLoader
+    });
+  } else if (url.protocol === "file:") {
+    if (resourceLoader) {
+      const file = resourceLoader._readFile(fileURLToPath2(url));
+      resourceLoader.fetcherMap.set(url.href, file);
+    }
+    dom = await JSDOM.fromFile(fileURLToPath2(url), {
+      virtualConsole,
+      resources: resourceLoader,
+      contentType: "text/html; charset=UTF-8"
+    });
+  } else {
+    throw new Error(`Unsupported protocol: ${url.protocol}`);
+  }
+  return dom;
+}
+function getJsdomFromString({
+  html,
+  virtualConsole = createVirtualConsole((error) => {
+    throw error;
+  })
+}) {
+  return new JSDOM(html, {
+    virtualConsole
+  });
+}
+async function getStructuredSectionFromHtml(htmlPath, href) {
+  const dom = await getJsdomFromUrlOrFile({ src: htmlPath });
+  const { document } = dom.window;
+  const allHeadings = [...document.querySelectorAll("h1, h2, h3, h4, h5, h6")].filter((el) => {
+    return !el.matches("blockquote *");
+  }).sort((a, b) => {
+    const position = a.compareDocumentPosition(b);
+    return position & 2 ? 1 : position & 4 ? -1 : 0;
+  });
+  function traverse(headers) {
+    if (headers.length === 0) {
+      return [];
+    }
+    const [head, ...tail] = headers;
+    const section = head.parentElement;
+    const id = head.id || section.id;
+    const level = Number(head.tagName.slice(1));
+    let i = tail.findIndex((s) => Number(s.tagName.slice(1)) <= level);
+    i = i === -1 ? tail.length : i;
+    return [
+      {
+        headingHtml: htmlPurify.sanitize(head.innerHTML),
+        headingText: head.textContent?.trim().replace(/\s+/g, " ") || "",
+        level,
+        ...href && id && { href: `${href}#${encodeURIComponent(id)}` },
+        ...id && { id },
+        children: traverse(tail.slice(0, i))
+      },
+      ...traverse(tail.slice(i))
+    ];
+  }
+  return traverse(allHeadings);
+}
+var getTocHtmlStyle = ({
+  pageBreakBefore,
+  pageCounterReset
+}) => {
+  if (!pageBreakBefore && typeof pageCounterReset !== "number") {
+    return null;
+  }
+  return (
+    /* css */
+    `
+${pageBreakBefore ? `:root {
+  break-before: ${pageBreakBefore};
+}` : ""}
+${typeof pageCounterReset === "number" ? `@page :nth(1) {
+  counter-reset: page ${Math.floor(pageCounterReset - 1)};
+}` : ""}
+`
+  );
+};
+var defaultTocTransform = {
+  transformDocumentList: (nodeList) => (propsList) => {
+    return /* @__PURE__ */ jsx("ol", { children: nodeList.map((a, i) => [a, propsList[i]]).flatMap(
+      ([{ href, title, sections }, { children, ...otherProps }]) => {
+        if (sections?.length === 1 && sections[0].level === 1) {
+          return [children].flat().flatMap((e) => {
+            if (e.type === "element" && e.tagName === "ol") {
+              return e.children;
+            }
+            return e;
+          });
+        }
+        return /* @__PURE__ */ jsxs("li", { ...otherProps, children: [
+          /* @__PURE__ */ jsx("a", { ...{ href }, children: title }),
+          children
+        ] });
+      }
+    ) });
+  },
+  transformSectionList: (nodeList) => (propsList) => {
+    return /* @__PURE__ */ jsx("ol", { children: nodeList.map((a, i) => [a, propsList[i]]).map(
+      ([{ headingHtml, href, level }, { children, ...otherProps }]) => {
+        const headingContent = {
+          type: "raw",
+          value: headingHtml
+        };
+        return /* @__PURE__ */ jsxs("li", { ...otherProps, "data-section-level": level, children: [
+          href ? /* @__PURE__ */ jsx("a", { ...{ href }, children: headingContent }) : /* @__PURE__ */ jsx("span", { children: headingContent }),
+          children
+        ] });
+      }
+    ) });
+  }
+};
+function generateDefaultTocHtml({
+  language,
+  title
+}) {
+  const toc = /* @__PURE__ */ jsxs("html", { lang: language, children: [
+    /* @__PURE__ */ jsxs("head", { children: [
+      /* @__PURE__ */ jsx("meta", { charset: "utf-8" }),
+      /* @__PURE__ */ jsx("title", { children: title || "" }),
+      /* @__PURE__ */ jsx("style", { "data-vv-style": true })
+    ] }),
+    /* @__PURE__ */ jsxs("body", { children: [
+      /* @__PURE__ */ jsx("h1", { children: title || "" }),
+      /* @__PURE__ */ jsx("nav", { id: "toc", role: "doc-toc" })
+    ] })
+  ] });
+  return toHtml(toc);
+}
+async function generateTocListSection({
+  entries,
+  distDir,
+  sectionDepth,
+  transform = {}
+}) {
+  const {
+    transformDocumentList = defaultTocTransform.transformDocumentList,
+    transformSectionList = defaultTocTransform.transformSectionList
+  } = transform;
+  const structure = await Promise.all(
+    entries.map(async (entry) => {
+      const href = encodeURI(upath6.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)),
+        sections,
+        children: []
+        // TODO
+      };
+    })
+  );
+  const docToc = transformDocumentList(structure)(
+    structure.map((doc) => {
+      function renderSectionList(sections) {
+        const nodeList = sections.flatMap((section) => {
+          if (section.level > sectionDepth) {
+            return [];
+          }
+          return section;
+        });
+        if (nodeList.length === 0) {
+          return [];
+        }
+        return transformSectionList(nodeList)(
+          nodeList.map((node) => ({
+            children: [renderSectionList(node.children || [])].flat()
+          }))
+        );
+      }
+      return {
+        children: [renderSectionList(doc.sections || [])].flat()
+      };
+    })
+  );
+  return toHtml(docToc, { allowDangerousHtml: true });
+}
+async function processTocHtml(dom, {
+  manifestPath,
+  tocTitle,
+  styleOptions = {},
+  entries,
+  distDir,
+  sectionDepth,
+  transform
+}) {
+  const { document } = dom.window;
+  if (!document.querySelector(
+    'link[rel="publication"][type="application/ld+json"]'
+  )) {
+    const l = document.createElement("link");
+    l.setAttribute("rel", "publication");
+    l.setAttribute("type", "application/ld+json");
+    l.setAttribute("href", encodeURI(upath6.relative(distDir, manifestPath)));
+    document.head.appendChild(l);
+  }
+  const style = document.querySelector("style[data-vv-style]");
+  if (style) {
+    const textContent = getTocHtmlStyle(styleOptions);
+    if (textContent) {
+      style.textContent = textContent;
+    } else {
+      style.remove();
+    }
+  }
+  const nav = document.querySelector('nav, [role="doc-toc"]');
+  if (nav && !nav.hasChildNodes()) {
+    const h2 = document.createElement("h2");
+    h2.textContent = tocTitle;
+    nav.appendChild(h2);
+    nav.innerHTML += await generateTocListSection({
+      entries,
+      distDir,
+      sectionDepth,
+      transform
+    });
+  }
+  return dom;
+}
+var getCoverHtmlStyle = ({
+  pageBreakBefore
+}) => (
+  /* css */
+  `
+${pageBreakBefore ? `:root {
+  break-before: ${pageBreakBefore};
+}` : ""}
+body {
+  margin: 0;
+}
+[role="doc-cover"] {
+  display: block;
+  width: 100vw;
+  height: 100vh;
+  object-fit: contain;
+}
+@page {
+  margin: 0;
+}
+`
+);
+function generateDefaultCoverHtml({
+  language,
+  title
+}) {
+  const toc = /* @__PURE__ */ jsxs("html", { lang: language, children: [
+    /* @__PURE__ */ jsxs("head", { children: [
+      /* @__PURE__ */ jsx("meta", { charset: "utf-8" }),
+      /* @__PURE__ */ jsx("title", { children: title || "" }),
+      /* @__PURE__ */ jsx("style", { "data-vv-style": true })
+    ] }),
+    /* @__PURE__ */ jsx("body", { children: /* @__PURE__ */ jsx("section", { role: "region", "aria-label": "Cover", children: /* @__PURE__ */ jsx("img", { role: "doc-cover" }) }) })
+  ] });
+  return toHtml(toc);
+}
+async function processCoverHtml(dom, {
+  imageSrc,
+  imageAlt,
+  styleOptions = {}
+}) {
+  const { document } = dom.window;
+  const style = document.querySelector("style[data-vv-style]");
+  if (style) {
+    const textContent = getCoverHtmlStyle(styleOptions);
+    if (textContent) {
+      style.textContent = textContent;
+    } else {
+      style.remove();
+    }
+  }
+  const cover = document.querySelector('img[role="doc-cover"]');
+  if (cover && !cover.hasAttribute("src")) {
+    cover.setAttribute("src", encodeURI(imageSrc));
+  }
+  if (cover && !cover.hasAttribute("alt")) {
+    cover.setAttribute("alt", imageAlt);
+  }
+  return dom;
+}
+async function processManuscriptHtml(dom, {
+  title,
+  style,
+  contentType,
+  language
+}) {
+  const { document } = dom.window;
+  if (title) {
+    if (!document.querySelector("title")) {
+      const t = document.createElement("title");
+      document.head.appendChild(t);
+    }
+    document.title = title;
+  }
+  for (const s of style ?? []) {
+    const l = document.createElement("link");
+    l.setAttribute("rel", "stylesheet");
+    l.setAttribute("type", "text/css");
+    l.setAttribute("href", encodeURI(s));
+    document.head.appendChild(l);
+  }
+  if (language) {
+    if (contentType === "application/xhtml+xml") {
+      if (!document.documentElement.getAttribute("xml:lang")) {
+        document.documentElement.setAttribute("lang", language);
+        document.documentElement.setAttribute("xml:lang", language);
+      }
+    } else {
+      if (!document.documentElement.getAttribute("lang")) {
+        document.documentElement.setAttribute("lang", language);
+      }
+    }
+  }
+  return dom;
+}
+async function fetchLinkedPublicationManifest({
+  dom,
+  resourceLoader,
+  baseUrl
+}) {
+  const { document } = dom.window;
+  const linkEl = document.querySelector('link[href][rel="publication"]');
+  if (!linkEl) {
+    return null;
+  }
+  const href = linkEl.getAttribute("href").trim();
+  let manifest;
+  let manifestUrl = baseUrl;
+  if (href.startsWith("#")) {
+    const scriptEl = document.getElementById(href.slice(1));
+    if (scriptEl?.getAttribute("type") !== "application/ld+json") {
+      return null;
+    }
+    Logger.debug(`Found embedded publication manifest: ${href}`);
+    try {
+      manifest = JSON.parse(scriptEl.innerHTML);
+    } catch (error) {
+      const thrownError = error;
+      throw new DetailError(
+        "Failed to parse manifest data",
+        typeof thrownError.stack
+      );
+    }
+  } else {
+    Logger.debug(`Found linked publication manifest: ${href}`);
+    const url = new URL(href, baseUrl);
+    manifestUrl = url.href;
+    const buffer = await resourceLoader.fetch(url.href);
+    if (!buffer) {
+      throw new Error(`Failed to fetch manifest JSON file: ${url.href}`);
+    }
+    const manifestJson = buffer.toString();
+    try {
+      manifest = JSON.parse(manifestJson);
+    } catch (error) {
+      const thrownError = error;
+      throw new DetailError(
+        "Failed to parse manifest data",
+        typeof thrownError.stack
+      );
+    }
+  }
+  try {
+    assertPubManifestSchema(manifest);
+  } catch (error) {
+    Logger.logWarn(
+      `Publication manifest validation failed. Processing continues, but some problems may occur.
+${error}`
+    );
+  }
+  return {
+    manifest: decodePublicationManifest(manifest),
+    manifestUrl
+  };
+}
+function parseTocDocument(dom) {
+  const { document } = dom.window;
+  const docTocEl = document.querySelectorAll('[role="doc-toc"]');
+  if (docTocEl.length === 0) {
+    return null;
+  }
+  const tocRoot = docTocEl.item(0);
+  const parseTocItem = (element) => {
+    if (element.tagName !== "LI") {
+      return null;
+    }
+    const label = element.children.item(0);
+    const ol = element.children.item(1);
+    if (!label || label.tagName !== "A" && label.tagName !== "SPAN") {
+      return null;
+    }
+    if (!ol || ol.tagName !== "OL") {
+      return { element, label };
+    }
+    const children = Array.from(ol.children).reduce((acc, val) => {
+      if (!acc) {
+        return acc;
+      }
+      const res = parseTocItem(val);
+      return res && [...acc, res];
+    }, []);
+    return children && {
+      element,
+      label,
+      children
+    };
+  };
+  let heading;
+  for (let child of Array.from(tocRoot.children)) {
+    if (child.tagName === "OL") {
+      const children = Array.from(child.children).reduce((acc, val) => {
+        if (!acc) {
+          return acc;
+        }
+        const res = parseTocItem(val);
+        return res && [...acc, res];
+      }, []);
+      return children && { element: tocRoot, heading, children };
+    } else if (["H1", "H2", "H3", "H4", "H5", "H6", "HGROUP"].includes(child.tagName)) {
+      heading = child;
+    } else {
+      return null;
+    }
+  }
+  return null;
+}
+function parsePageListDocument(dom) {
+  const { document } = dom.window;
+  const docPageListEl = document.querySelectorAll('[role="doc-pagelist"]');
+  if (docPageListEl.length === 0) {
+    return null;
+  }
+  const pageListRoot = docPageListEl.item(0);
+  let heading;
+  for (let child of Array.from(pageListRoot.children)) {
+    if (child.tagName === "OL") {
+      const children = Array.from(child.children).reduce((acc, element) => {
+        return acc && (element.tagName === "LI" ? [...acc, { element }] : null);
+      }, []);
+      return children && { element: pageListRoot, heading, children };
+    } else if (["H1", "H2", "H3", "H4", "H5", "H6", "HGROUP"].includes(child.tagName)) {
+      heading = child;
+    } else {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/output/epub.ts
+import archiver from "archiver";
+import { lookup as lookupLanguage } from "bcp-47-match";
+import { XMLBuilder } from "fast-xml-parser";
+import { copy, remove } 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 { v4 as uuid } from "uuid";
+import serializeToXml from "w3c-xmlserializer";
+var TOC_ID = "toc";
+var LANDMARKS_ID = "landmarks";
+var PAGELIST_ID = "page-list";
+var COVER_IMAGE_MIMETYPES = [
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/svg+xml",
+  "image/webp"
+];
+var changeExtname = (filepath, newExt) => {
+  let ext = upath7.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));
+  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,
+    hrefUrl.pathname
+  );
+  return `${pathname}${hrefUrl.search}${hrefUrl.hash}`;
+};
+var normalizeLocalizableString = (value, availableLanguages) => {
+  if (!value) {
+    return;
+  }
+  const values = [value].flat().map((value2) => typeof value2 === "string" ? { value: value2 } : value2);
+  const localizedValues = values.filter(
+    (v3) => !!v3.language
+  );
+  const preferredLang = lookupLanguage(
+    localizedValues.map((v3) => v3.language),
+    availableLanguages
+  );
+  if (preferredLang) {
+    return localizedValues[localizedValues.findIndex((v3) => v3.language === preferredLang)].value;
+  }
+  return values.find((v3) => !v3.language)?.value;
+};
+var appendManifestProperty = (entry, newProperty) => {
+  entry.properties = entry.properties ? Array.from(/* @__PURE__ */ new Set([...entry.properties.split(" "), newProperty])).join(
+    " "
+  ) : newProperty;
+};
+async function exportEpub({
+  webpubDir,
+  entryHtmlFile,
+  manifest,
+  relManifestPath,
+  target,
+  epubVersion
+}) {
+  Logger.debug("Export EPUB", {
+    webpubDir,
+    entryHtmlFile,
+    relManifestPath,
+    target,
+    epubVersion
+  });
+  const [tmpDir] = await useTmpDirectory();
+  fs6.mkdirSync(upath7.join(tmpDir, "META-INF"), { recursive: true });
+  await copy(webpubDir, upath7.join(tmpDir, "EPUB"));
+  const uid = `urn:uuid:${uuid()}`;
+  const entryHtmlRelPath = entryHtmlFile && upath7.relative(webpubDir, upath7.resolve(webpubDir, entryHtmlFile));
+  const findPublicationLink = (relType, list, filter) => [list].flat().find(
+    (e) => typeof e === "object" && e.rel === relType && (!filter || filter(e))
+  );
+  const tocResource = findPublicationLink("contents", [
+    ...[manifest.readingOrder || []].flat(),
+    ...[manifest.resources || []].flat()
+  ]);
+  const pageListResource = findPublicationLink("pagelist", [
+    ...[manifest.readingOrder || []].flat(),
+    ...[manifest.resources || []].flat()
+  ]);
+  const pictureCoverResource = findPublicationLink(
+    "cover",
+    manifest.resources,
+    (e) => COVER_IMAGE_MIMETYPES.includes(e.encodingFormat || mime2(e.url) || "")
+  );
+  const htmlCoverResource = findPublicationLink(
+    "cover",
+    [
+      ...[manifest.readingOrder || []].flat(),
+      ...[manifest.resources || []].flat()
+    ],
+    (e) => /\.html?$/.test(e.url)
+  );
+  const manifestItem = [
+    ...[manifest.links || []].flat(),
+    ...[manifest.readingOrder || []].flat(),
+    ...[manifest.resources || []].flat()
+  ].reduce(
+    (acc, val) => {
+      const { url, encodingFormat } = typeof val === "string" ? { url: val } : val;
+      try {
+        new URL(url);
+        return acc;
+      } catch (e) {
+      }
+      if (!fs6.existsSync(upath7.join(tmpDir, "EPUB", url))) {
+        return acc;
+      }
+      const mediaType = encodingFormat || mime2(url) || "text/plain";
+      acc[url] = {
+        href: url,
+        mediaType
+      };
+      if (/\.html?$/.test(url)) {
+        acc[url].href = changeExtname(url, ".xhtml");
+        acc[url].mediaType = "application/xhtml+xml";
+      }
+      if (url === pictureCoverResource?.url) {
+        acc[url].properties = "cover-image";
+      }
+      return acc;
+    },
+    {}
+  );
+  const htmlFiles = Object.keys(manifestItem).filter(
+    (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 : []);
+  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."
+    );
+    tocHtml = htmlFiles.find((f) => f === entryHtmlRelPath) || readingOrder[0].url;
+  }
+  const spineItems = readingOrder.map(({ url }) => ({
+    href: changeExtname(url, ".xhtml")
+  }));
+  if (!(tocHtml in manifestItem)) {
+    manifestItem[tocHtml] = {
+      href: changeExtname(tocHtml, ".xhtml"),
+      mediaType: "application/xhtml+xml"
+    };
+  }
+  appendManifestProperty(manifestItem[tocHtml], "nav");
+  const landmarks = [
+    {
+      type: "toc",
+      href: `${manifestItem[tocHtml].href}#${TOC_ID}`,
+      text: EPUB_LANDMARKS_TOC_ENTRY
+    }
+  ];
+  if (htmlCoverResource) {
+    landmarks.push({
+      type: "cover",
+      href: changeExtname(htmlCoverResource.url, ".xhtml"),
+      text: EPUB_LANDMARKS_COVER_ENTRY
+    });
+  }
+  const contextDir = upath7.join(tmpDir, "EPUB");
+  const processHtml = async (target2) => {
+    let parseResult;
+    try {
+      parseResult = await transpileHtmlToXhtml({
+        target: target2,
+        contextDir
+      });
+    } catch (error) {
+      const thrownError = error;
+      throw new DetailError(
+        `Failed to transpile document to XHTML: ${target2}`,
+        thrownError.stack ?? thrownError.message
+      );
+    }
+    if (parseResult.hasMathmlContent) {
+      appendManifestProperty(manifestItem[target2], "mathml");
+    }
+    if (parseResult.hasRemoteResources) {
+      appendManifestProperty(manifestItem[target2], "remote-resources");
+    }
+    if (parseResult.hasScriptedContent) {
+      appendManifestProperty(manifestItem[target2], "scripted");
+    }
+    if (parseResult.hasSvgContent) {
+      appendManifestProperty(manifestItem[target2], "svg");
+    }
+    return parseResult;
+  };
+  const processResult = {};
+  Logger.debug(`Transpiling ToC HTML to XHTML: ${tocHtml}`);
+  processResult[tocHtml] = await processHtml(tocHtml);
+  for (const target2 of htmlFiles.filter((f) => f !== tocHtml)) {
+    Logger.debug(`Transpiling HTML to XHTML: ${target2}`);
+    processResult[target2] = await processHtml(target2);
+  }
+  const { document: entryDocument } = processResult[tocHtml].dom.window;
+  const docLanguages = [manifest.inLanguage].flat().filter((v3) => Boolean(v3));
+  if (docLanguages.length === 0) {
+    docLanguages.push(entryDocument.documentElement.lang || "en");
+  }
+  const docTitle = normalizeLocalizableString(manifest.name, docLanguages) || entryDocument.title;
+  if (!docTitle) {
+    throw new Error("EPUB must have a title of one or more characters");
+  }
+  const { tocResourceTree } = await processTocDocument({
+    dom: processResult[tocHtml].dom,
+    target: tocHtml,
+    contextDir,
+    readingOrder,
+    docLanguages,
+    landmarks
+  });
+  const pageListHtml = pageListResource?.url || entryHtmlRelPath;
+  if (pageListHtml && pageListHtml in processResult) {
+    await processPagelistDocument({
+      dom: processResult[pageListHtml].dom,
+      target: pageListHtml,
+      contextDir
+    });
+  }
+  if (relManifestPath) {
+    await remove(upath7.join(tmpDir, "EPUB", relManifestPath));
+    delete manifestItem[relManifestPath];
+  }
+  fs6.writeFileSync(
+    upath7.join(tmpDir, "META-INF/container.xml"),
+    EPUB_CONTAINER_XML,
+    "utf8"
+  );
+  Logger.debug(`Generating content.opf`);
+  fs6.writeFileSync(
+    upath7.join(tmpDir, "EPUB/content.opf"),
+    buildEpubPackageDocument({
+      epubVersion,
+      uid,
+      docTitle,
+      docLanguages,
+      manifest,
+      spineItems,
+      manifestItems: Object.values(manifestItem)
+    }),
+    "utf8"
+  );
+  await compressEpub({ target, sourceDir: tmpDir });
+}
+async function writeAsXhtml(dom, absPath) {
+  const xhtml = `${XML_DECLARATION}
+${serializeToXml(dom.window.document)}`;
+  await fs6.promises.writeFile(changeExtname(absPath, ".xhtml"), xhtml, "utf8");
+}
+async function transpileHtmlToXhtml({
+  target,
+  contextDir
+}) {
+  const absPath = upath7.join(contextDir, target);
+  const dom = await getJsdomFromUrlOrFile({ src: absPath });
+  const { document } = dom.window;
+  document.documentElement.removeAttribute("xmlns");
+  document.documentElement.setAttribute("xmlns:epub", EPUB_NS);
+  document.querySelectorAll("a[href]").forEach((el) => {
+    const href = decodeURI(el.getAttribute("href"));
+    el.setAttribute("href", getRelativeHref(href, target, target));
+  });
+  await writeAsXhtml(dom, absPath);
+  await fs6.promises.unlink(absPath);
+  return {
+    dom,
+    // FIXME: Yes, I recognize this implementation is inadequate.
+    hasMathmlContent: !!document.querySelector("math"),
+    hasRemoteResources: !!document.querySelector(
+      '[src^="http://"], [src^="https://"]'
+    ),
+    hasScriptedContent: !!document.querySelector("script, form"),
+    hasSvgContent: !!document.querySelector("svg")
+  };
+}
+function replaceWithNavElement(dom, el) {
+  const nav = dom.window.document.createElement("nav");
+  while (el.firstChild) {
+    nav.appendChild(el.firstChild);
+  }
+  for (let i = 0; i < el.attributes.length; i++) {
+    nav.attributes.setNamedItem(el.attributes[i].cloneNode());
+  }
+  el.parentNode?.replaceChild(nav, el);
+  return nav;
+}
+async function processTocDocument({
+  dom,
+  target,
+  contextDir,
+  readingOrder,
+  docLanguages,
+  landmarks
+}) {
+  const { document } = dom.window;
+  let tocResourceTree = null;
+  if (!document.querySelector("nav[epub:type]")) {
+    tocResourceTree = parseTocDocument(dom);
+    if (tocResourceTree) {
+      const nav = replaceWithNavElement(dom, tocResourceTree.element);
+      nav.setAttribute("id", TOC_ID);
+      nav.setAttribute("epub:type", "toc");
+    } else {
+      Logger.debug(`Generating toc nav element: ${target}`);
+      const nav = document.createElement("nav");
+      nav.setAttribute("id", TOC_ID);
+      nav.setAttribute("role", "doc-toc");
+      nav.setAttribute("epub:type", "toc");
+      nav.setAttribute("hidden", "");
+      const h2 = document.createElement("h2");
+      h2.textContent = TOC_TITLE;
+      nav.appendChild(h2);
+      const ol = document.createElement("ol");
+      tocResourceTree = {
+        element: nav,
+        children: []
+      };
+      for (const content of readingOrder) {
+        let name = normalizeLocalizableString(content.name, docLanguages);
+        if (!name) {
+          const dom2 = await getJsdomFromUrlOrFile({
+            src: upath7.join(contextDir, changeExtname(content.url, ".xhtml"))
+          });
+          name = dom2.window.document.title;
+        }
+        const li = document.createElement("li");
+        const a = document.createElement("a");
+        a.textContent = name;
+        a.href = getRelativeHref(content.url, "", target);
+        li.appendChild(a);
+        ol.appendChild(li);
+        tocResourceTree.children.push({ element: li, label: a });
+      }
+      nav.appendChild(ol);
+      document.body.appendChild(nav);
+      Logger.debug("Generated toc nav element", nav.outerHTML);
+    }
+    if (landmarks.length > 0) {
+      Logger.debug(`Generating landmark nav element: ${target}`);
+      const nav = document.createElement("nav");
+      nav.setAttribute("epub:type", "landmarks");
+      nav.setAttribute("id", LANDMARKS_ID);
+      nav.setAttribute("hidden", "");
+      const h2 = document.createElement("h2");
+      h2.textContent = EPUB_LANDMARKS_TITLE;
+      nav.appendChild(h2);
+      const ol = document.createElement("ol");
+      for (const { type, href, text } of landmarks) {
+        const li = document.createElement("li");
+        const a = document.createElement("a");
+        a.setAttribute("epub:type", type);
+        a.setAttribute("href", getRelativeHref(href, "", target));
+        a.text = text;
+        li.appendChild(a);
+        ol.appendChild(li);
+      }
+      nav.appendChild(ol);
+      document.body.appendChild(nav);
+      Logger.debug("Generated landmark nav element", nav.outerHTML);
+    }
+  }
+  const publicationLinkEl = document.querySelector(
+    'link[href][rel="publication"]'
+  );
+  if (publicationLinkEl) {
+    const href = publicationLinkEl.getAttribute("href").trim();
+    if (href.startsWith("#")) {
+      const scriptEl = document.getElementById(href.slice(1));
+      if (scriptEl?.getAttribute("type") === "application/ld+json") {
+        scriptEl.parentNode?.removeChild(scriptEl);
+      }
+    }
+    publicationLinkEl.parentNode?.removeChild(publicationLinkEl);
+  }
+  const absPath = upath7.join(contextDir, target);
+  await writeAsXhtml(dom, absPath);
+  return { tocResourceTree };
+}
+async function processPagelistDocument({
+  dom,
+  target,
+  contextDir
+}) {
+  const pageListResourceTree = parsePageListDocument(dom);
+  if (pageListResourceTree) {
+    const nav = replaceWithNavElement(dom, pageListResourceTree.element);
+    nav.setAttribute("id", PAGELIST_ID);
+    nav.setAttribute("epub:type", "page-list");
+  }
+  const absPath = upath7.join(contextDir, target);
+  await writeAsXhtml(dom, absPath);
+  return { pageListResourceTree };
+}
+function buildEpubPackageDocument({
+  epubVersion,
+  manifest,
+  uid,
+  docTitle,
+  docLanguages,
+  spineItems,
+  manifestItems
+}) {
+  const slugger = new GithubSlugger();
+  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 transformContributor = (contributorMap) => Object.entries(contributorMap).flatMap(
+    ([type, contributor]) => contributor ? [contributor].flat().map((entry, index) => ({
+      _id: slugger.slug(`${type}-${index + 1}`),
+      "#text": typeof entry === "string" ? entry : normalizeLocalizableString(entry.name, docLanguages)
+    })) : []
+  );
+  const itemIdMap = /* @__PURE__ */ new Map();
+  manifestItems.forEach(({ href }) => {
+    itemIdMap.set(href, slugger.slug(href));
+  });
+  const builder = new XMLBuilder({
+    format: true,
+    ignoreAttributes: false,
+    attributeNamePrefix: "_"
+  });
+  return builder.build({
+    "?xml": {
+      _version: "1.0",
+      _encoding: "UTF-8"
+    },
+    package: {
+      _xmlns: "http://www.idpf.org/2007/opf",
+      _version: epubVersion,
+      "_unique-identifier": bookIdentifier,
+      "_xml:lang": docLanguages[0],
+      metadata: {
+        "_xmlns:dc": "http://purl.org/dc/elements/1.1/",
+        "dc:identifier": {
+          _id: bookIdentifier,
+          "#text": uid
+        },
+        "dc:title": docTitle,
+        "dc:language": docLanguages,
+        "dc:creator": transformContributor({
+          // TODO: Define proper order
+          author: manifest.author,
+          creator: manifest.creator,
+          editor: manifest.editor,
+          artist: manifest.artist,
+          illustrator: manifest.illustrator,
+          colorist: manifest.colorist,
+          penciler: manifest.penciler,
+          inker: manifest.inker,
+          letterer: manifest.letterer,
+          translator: manifest.translator,
+          readBy: manifest.readBy
+        }),
+        "dc:publisher": transformContributor({
+          publisher: manifest.publisher
+        }),
+        "dc:contributor": transformContributor({
+          contributor: manifest.contributor
+        }),
+        "dc:date": transformToGenericTextNode(
+          normalizeDate(manifest.datePublished)
+        ),
+        "dc:rights": transformToGenericTextNode(
+          manifest.copyrightHolder && `\xA9 ${manifest.copyrightYear ? `${manifest.copyrightYear} ` : ""}${manifest.copyrightHolder}`
+        ),
+        "dc:subject": transformToGenericTextNode(
+          manifest["dc:subject"] || manifest.subject
+        ),
+        meta: [
+          ...transformToGenericTextNode(
+            normalizeDate(manifest.dateModified || Date.now()),
+            {
+              _property: "dcterms:modified"
+            }
+          ),
+          ...(() => {
+            const coverImage = manifestItems.find(
+              (it) => it.properties === "cover-image"
+            );
+            return coverImage ? [{ _name: "cover", _content: itemIdMap.get(coverImage.href) }] : [];
+          })()
+        ]
+      },
+      manifest: {
+        item: manifestItems.map(({ href, mediaType, properties }) => ({
+          _id: itemIdMap.get(href),
+          _href: encodeURI(href),
+          "_media-type": mediaType,
+          ...properties ? { _properties: properties } : {}
+        }))
+      },
+      spine: {
+        ...manifest.readingProgression ? { "_page-progression-direction": manifest.readingProgression } : {},
+        itemref: [
+          ...spineItems.map(({ href }) => ({
+            _idref: itemIdMap.get(href)
+          }))
+        ]
+      }
+    }
+  });
+}
+async function compressEpub({
+  target,
+  sourceDir
+}) {
+  Logger.debug(`Compressing EPUB: ${target}`);
+  const output = fs6.createWriteStream(target);
+  const archive = archiver("zip", {
+    zlib: { level: 9 }
+    // Compression level
+  });
+  return new Promise((resolve, reject) => {
+    output.on("close", () => {
+      Logger.debug(`Compressed EPUB: ${target}`);
+      resolve();
+    });
+    output.on("error", reject);
+    archive.on("warning", reject);
+    archive.on("error", reject);
+    archive.pipe(output);
+    archive.append("application/epub+zip", {
+      name: "mimetype",
+      // mimetype should not be compressed
+      // 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.finalize();
+  });
+}
+
+// src/output/webbook.ts
+function sortManifestResources(manifest) {
+  if (!Array.isArray(manifest.resources)) {
+    return;
+  }
+  manifest.resources = [...manifest.resources].sort(
+    (a, b) => (typeof a === "string" ? a : a.url) > (typeof b === "string" ? b : b.url) ? 1 : -1
+  );
+}
+async function prepareWebPublicationDirectory({
+  outputDir
+}) {
+  if (fs7.existsSync(outputDir)) {
+    Logger.debug("going to remove existing webpub", outputDir);
+    await remove2(outputDir);
+  }
+  fs7.mkdirSync(outputDir, { recursive: true });
+}
+function transformPublicationManifest(entity, transformer) {
+  const { url: transformUrl } = transformer;
+  const transformUrlOrPublicationLinks = (e) => {
+    if (typeof e === "string") {
+      return transformUrl(e);
+    }
+    const ret2 = { ...e };
+    ret2.url = transformUrl(e.url);
+    return ret2;
+  };
+  const ret = { ...entity };
+  for (const [key, tr] of Object.entries({
+    conformsTo: transformUrl,
+    url: transformUrl,
+    readingOrder: transformUrlOrPublicationLinks,
+    resources: transformUrlOrPublicationLinks,
+    links: transformUrlOrPublicationLinks
+  })) {
+    if (key in ret) {
+      ret[key] = Array.isArray(ret[key]) ? ret[key].map(tr) : tr(ret[key]);
+    }
+  }
+  return ret;
+}
+function decodePublicationManifest(input) {
+  return transformPublicationManifest(input, {
+    url: decodeURI
+  });
+}
+function encodePublicationManifest(input) {
+  return transformPublicationManifest(input, {
+    url: encodeURI
+  });
+}
+function writePublicationManifest(output, options) {
+  const entries = options.entries.map((entry) => ({
+    url: entry.path,
+    ...entry.title && { name: entry.title },
+    ...entry.encodingFormat && { encodingFormat: entry.encodingFormat },
+    ...entry.rel && { rel: entry.rel },
+    ...(entry.rel === "contents" || entry.rel === "cover") && {
+      type: "LinkedResource"
+    }
+  }));
+  const links = [
+    options.links || []
+  ].flat();
+  const resources = [
+    options.resources || []
+  ].flat();
+  if (options.cover) {
+    const mimeType = mime3(options.cover.url);
+    if (mimeType) {
+      resources.push({
+        rel: "cover",
+        url: options.cover.url,
+        name: options.cover.name,
+        encodingFormat: mimeType
+      });
+    } else {
+      Logger.logWarn(
+        `Cover image "${options.cover}" was set in your configuration but couldn\u2019t detect the image metadata. Please check a valid cover file is placed.`
+      );
+    }
+  }
+  const publication = {
+    "@context": ["https://schema.org", "https://www.w3.org/ns/pub-context"],
+    type: "Book",
+    conformsTo: "https://github.com/vivliostyle/vivliostyle-cli",
+    ...options.title && { name: options.title },
+    ...options.author && { author: options.author },
+    ...options.language && { inLanguage: options.language },
+    ...options.readingProgression && {
+      readingProgression: options.readingProgression
+    },
+    dateModified: options.modified,
+    readingOrder: entries,
+    resources,
+    links
+  };
+  const encodedManifest = encodePublicationManifest(publication);
+  Logger.debug(
+    "writePublicationManifest path: %s content: %O",
+    output,
+    encodedManifest
+  );
+  try {
+    assertPubManifestSchema(encodedManifest);
+  } catch (error) {
+    const thrownError = error;
+    throw new DetailError(
+      `Validation of publication manifest failed. Please check the schema: ${output}`,
+      typeof thrownError === "string" ? thrownError : thrownError.stack ?? thrownError.message
+    );
+  }
+  fs7.mkdirSync(upath8.dirname(output), { recursive: true });
+  fs7.writeFileSync(output, JSON.stringify(encodedManifest, null, 2));
+  return publication;
+}
+async function retrieveWebbookEntry({
+  viewerInput,
+  outputDir
+}) {
+  const webbookEntryUrl = viewerInput.webbookPath ? pathToFileURL6(viewerInput.webbookPath).href : viewerInput.webbookEntryUrl;
+  if (/^https?:/i.test(webbookEntryUrl)) {
+    Logger.logUpdate("Fetching remote contents");
+  }
+  const resourceLoader = new ResourceLoader();
+  const dom = await getJsdomFromUrlOrFile({
+    src: webbookEntryUrl,
+    resourceLoader
+  });
+  const entryHtml = viewerInput.webbookPath ? upath8.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 retriever = new Map(resourceLoader.fetcherMap);
+  if (manifest && manifestUrl) {
+    [manifest.resources || []].flat().forEach((v3) => {
+      const url = typeof v3 === "string" ? v3 : v3.url;
+      const fullUrl = new URL(encodeURI(url), manifestUrl).href;
+      if (!pathContains2(fullUrl) || retriever.has(fullUrl)) {
+        return;
+      }
+      const fetchPromise = resourceLoader.fetch(fullUrl);
+      if (fetchPromise && !retriever.has(fullUrl)) {
+        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")) {
+        continue;
+      }
+      const fullUrl = new URL(encodeURI(url), manifestUrl).href;
+      if (!pathContains2(fullUrl) || fullUrl === webbookEntryUrl) {
+        continue;
+      }
+      const subpathResourceLoader = new ResourceLoader();
+      await getJsdomFromUrlOrFile({
+        src: fullUrl,
+        resourceLoader: subpathResourceLoader,
+        virtualConsole: createVirtualConsole((error) => {
+          Logger.logError(`Failed to fetch webbook resources: ${error.detail}`);
+        })
+      });
+      subpathResourceLoader.fetcherMap.forEach(
+        (v4, k) => !retriever.has(k) && retriever.set(k, v4)
+      );
+    }
+  }
+  const fetchedResources = await ResourceLoader.saveFetchedResources({
+    fetcherMap: retriever,
+    rootUrl: webbookEntryUrl,
+    outputDir,
+    /* v8 ignore next 4 */
+    onError: (error) => {
+      Logger.debug(error);
+      Logger.logError(`Failed to fetch webbook resources: ${error}`);
+    }
+  });
+  if (manifest) {
+    const referencedContents = [
+      ...[manifest.readingOrder || []].flat(),
+      ...[manifest.resources || []].flat()
+    ].map((v3) => typeof v3 === "string" ? v3 : v3.url);
+    manifest.resources = [
+      ...[manifest.resources || []].flat(),
+      ...fetchedResources.filter(
+        ({ url }) => !referencedContents.includes(url)
+      )
+    ];
+    sortManifestResources(manifest);
+  }
+  Logger.debug(
+    "Saved webbook resources",
+    fetchedResources.map((v3) => v3.url)
+  );
+  Logger.debug(
+    "Publication manifest from webbook",
+    manifest && JSON.stringify(manifest, null, 2)
+  );
+  return {
+    entryHtmlFile: upath8.join(outputDir, entryHtml),
+    manifest
+  };
+}
+async function supplyWebPublicationManifestForWebbook({
+  entryHtmlFile,
+  outputDir,
+  ...config
+}) {
+  Logger.debug(`Generating publication manifest from HTML: ${entryHtmlFile}`);
+  const dom = await getJsdomFromUrlOrFile({ src: entryHtmlFile });
+  const { document } = dom.window;
+  const language = config.language || document.documentElement.lang || void 0;
+  const title = config.title || document.title || "";
+  const author = config.author || document.querySelector('meta[name="author"]')?.getAttribute("content") || "";
+  const entry = upath8.relative(outputDir, entryHtmlFile);
+  const allFiles = await glob("**", {
+    cwd: outputDir
+  });
+  const manifest = writePublicationManifest(
+    upath8.join(outputDir, MANIFEST_FILENAME),
+    {
+      title,
+      author,
+      language,
+      readingProgression: config.readingProgression,
+      modified: (/* @__PURE__ */ new Date()).toISOString(),
+      entries: [{ path: entry }],
+      resources: allFiles.filter((f) => f !== entry)
+    }
+  );
+  sortManifestResources(manifest);
+  const link = document.createElement("link");
+  link.setAttribute("rel", "publication");
+  link.setAttribute("type", "application/ld+json");
+  link.setAttribute(
+    "href",
+    upath8.relative(
+      upath8.dirname(entryHtmlFile),
+      upath8.join(outputDir, MANIFEST_FILENAME)
+    )
+  );
+  document.head.appendChild(link);
+  await fs7.promises.writeFile(entryHtmlFile, dom.serialize(), "utf8");
+  Logger.debug(
+    "Generated publication manifest from HTML",
+    JSON.stringify(manifest, null, 2)
+  );
+  return manifest;
+}
+async function copyWebPublicationAssets({
+  exportAliases,
+  outputs,
+  copyAsset,
+  themesDir,
+  manifestPath,
+  input,
+  outputDir,
+  entries
+}) {
+  const relExportAliases = exportAliases.map(({ source, target }) => ({
+    source: upath8.relative(input, source),
+    target: upath8.relative(input, target)
+  })).filter(({ source }) => !source.startsWith(".."));
+  const allFiles = /* @__PURE__ */ new Set([
+    ...await globAssetFiles({
+      copyAsset,
+      cwd: input,
+      outputs,
+      themesDir,
+      entries
+    }),
+    ...await glob(
+      [
+        `**/${upath8.relative(input, manifestPath)}`,
+        "**/*.{html,htm,xhtml,xht,css}"
+      ],
+      {
+        cwd: input,
+        ignore: [
+          ...getIgnoreAssetPatterns({
+            cwd: input,
+            outputs,
+            entries
+          }),
+          ...getIgnoreThemeExamplePatterns({
+            cwd: input,
+            themesDir
+          }),
+          // Ignore node_modules in the root directory
+          "node_modules/**",
+          // only include dotfiles starting with `.vs-`
+          "**/.!(vs-*)/**"
+        ],
+        // follow symbolic links to copy local theme packages
+        followSymbolicLinks: true,
+        dot: true
+      }
+    )
+  ]);
+  for (const alias of relExportAliases) {
+    allFiles.delete(alias.target);
+  }
+  Logger.debug(
+    "webbook files",
+    JSON.stringify(
+      [...allFiles].map((file) => {
+        const alias = relExportAliases.find(({ source }) => source === file);
+        return alias ? `${file} (alias: ${alias.target})` : file;
+      }),
+      null,
+      2
+    )
+  );
+  const resources = [];
+  let actualManifestPath = upath8.join(
+    outputDir,
+    upath8.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)) {
+      actualManifestPath = target;
+    }
+  }
+  Logger.debug("webbook publication.json", actualManifestPath);
+  const manifest = decodePublicationManifest(
+    JSON.parse(fs7.readFileSync(actualManifestPath, "utf8"))
+  );
+  for (const entry of relExportAliases) {
+    const rewriteAliasPath = (e) => {
+      if (typeof e === "string") {
+        return pathEquals(e, entry.source) ? entry.source : e;
+      }
+      if (pathEquals(e.url, entry.source)) {
+        e.url = entry.target;
+      }
+      return e;
+    };
+    if (manifest.links) {
+      manifest.links = Array.isArray(manifest.links) ? manifest.links.map(rewriteAliasPath) : rewriteAliasPath(manifest.links);
+    }
+    if (manifest.readingOrder) {
+      manifest.readingOrder = Array.isArray(manifest.readingOrder) ? manifest.readingOrder.map(rewriteAliasPath) : rewriteAliasPath(manifest.readingOrder);
+    }
+    if (manifest.resources) {
+      manifest.resources = Array.isArray(manifest.resources) ? manifest.resources.map(rewriteAliasPath) : rewriteAliasPath(manifest.resources);
+    }
+  }
+  const normalizeToUrl = (val) => [val || []].flat().map((e) => typeof e === "string" ? e : e.url);
+  const preDefinedResources = [
+    ...normalizeToUrl(manifest.links),
+    ...normalizeToUrl(manifest.readingOrder),
+    ...normalizeToUrl(manifest.resources)
+  ];
+  manifest.resources = [
+    ...[manifest.resources || []].flat(),
+    ...resources.flatMap((file) => {
+      if (preDefinedResources.includes(file) || // Omit publication.json itself
+      pathEquals(file, upath8.relative(outputDir, actualManifestPath))) {
+        return [];
+      }
+      return file;
+    })
+  ];
+  sortManifestResources(manifest);
+  fs7.writeFileSync(
+    actualManifestPath,
+    JSON.stringify(encodePublicationManifest(manifest), null, 2)
+  );
+  return { manifest, actualManifestPath };
+}
+async function buildWebPublication({
+  target,
+  config
+}) {
+  let outputDir;
+  if (target.format === "webpub") {
+    outputDir = target.path;
+    await prepareWebPublicationDirectory({ outputDir });
+  } else {
+    [outputDir] = await useTmpDirectory();
+  }
+  let entryHtmlFile;
+  let manifest;
+  let actualManifestPath;
+  if (config.viewerInput.type === "webpub") {
+    const ret = await copyWebPublicationAssets({
+      ...config,
+      input: config.workspaceDir,
+      outputDir,
+      manifestPath: config.viewerInput.manifestPath
+    });
+    manifest = ret.manifest;
+    actualManifestPath = ret.actualManifestPath;
+    if (config.input.format === "markdown") {
+      const entry = [manifest.readingOrder].flat()[0];
+      if (entry) {
+        entryHtmlFile = upath8.join(
+          outputDir,
+          typeof entry === "string" ? entry : entry.url
+        );
+      }
+    }
+  } else if (isWebbookConfig(config)) {
+    const ret = await retrieveWebbookEntry({
+      viewerInput: config.viewerInput,
+      outputDir
+    });
+    entryHtmlFile = ret.entryHtmlFile;
+    manifest = ret.manifest || await supplyWebPublicationManifestForWebbook({
+      ...config,
+      entryHtmlFile: ret.entryHtmlFile,
+      outputDir
+    });
+  } else {
+    throw new Error("No entry specified");
+  }
+  if (target.format === "epub") {
+    await exportEpub({
+      webpubDir: outputDir,
+      entryHtmlFile,
+      manifest,
+      relManifestPath: actualManifestPath && upath8.relative(outputDir, actualManifestPath),
+      target: target.path,
+      epubVersion: target.version
+    });
+  }
+  return target.path;
+}
+
+// src/processor/theme.ts
+import Arborist from "@npmcli/arborist";
+import fs8 from "node:fs";
+async function checkThemeInstallationNecessity({
+  themesDir,
+  themeIndexes
+}) {
+  if (!fs8.existsSync(themesDir)) {
+    return [...themeIndexes].some((theme) => theme.type === "package");
+  }
+  const commonOpt = {
+    path: themesDir,
+    lockfileVersion: 3
+  };
+  const arb = new Arborist(commonOpt);
+  const tree = await arb.loadActual();
+  const pkgs = Array.from(tree.children.keys());
+  return [...themeIndexes].some(
+    (theme) => theme.type === "package" && !pkgs.includes(theme.name)
+  );
+}
+async function installThemeDependencies({
+  themesDir,
+  themeIndexes
+}) {
+  fs8.mkdirSync(themesDir, { recursive: true });
+  try {
+    const commonOpt = {
+      path: themesDir,
+      lockfileVersion: 3
+    };
+    const tree = await new Arborist(commonOpt).buildIdealTree();
+    const existing = Array.from(tree.children.keys());
+    const add = [
+      ...new Set(
+        [...themeIndexes].flatMap(
+          (theme) => theme.type === "package" ? [theme.specifier] : []
+        )
+      )
+    ];
+    const rm = existing.filter((v3) => !add.includes(v3));
+    const opt = { ...commonOpt, rm, add };
+    const arb = new Arborist(opt);
+    await arb.reify(opt);
+    return;
+  } catch (error) {
+    const thrownError = error;
+    throw new DetailError(
+      "An error occurred during the installation of the theme",
+      thrownError.stack ?? thrownError.message
+    );
+  }
+}
+
+// src/processor/compile.ts
+function locateThemePath(theme, from) {
+  if (theme.type === "uri") {
+    return theme.location;
+  }
+  if (theme.type === "file") {
+    return upath9.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)) {
+        throw new Error(
+          `Could not find a style path ${theme.importPath} for the theme: ${theme.name}.`
+        );
+      }
+      return upath9.relative(from, resolvedPath);
+    });
+  } else {
+    const pkgJsonPath = upath9.join(theme.location, "package.json");
+    const packageJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf8"));
+    const maybeStyle = packageJson?.vivliostyle?.theme?.style ?? packageJson.style ?? packageJson.main;
+    if (!maybeStyle) {
+      throw new DetailError(
+        `Could not find a style file for the theme: ${theme.name}.`,
+        "Please ensure this package satisfies a `vivliostyle.theme.style` property."
+      );
+    }
+    return upath9.relative(from, upath9.join(theme.location, maybeStyle));
+  }
+}
+async function cleanupWorkspace({
+  entryContextDir,
+  workspaceDir,
+  themesDir,
+  entries
+}) {
+  if (pathEquals(workspaceDir, entryContextDir) || pathContains(workspaceDir, entryContextDir) || entries.some(
+    (entry) => entry.source?.type === "file" && pathContains(workspaceDir, entry.source.pathname)
+  )) {
+    return;
+  }
+  Logger.debug("cleanup workspace files", workspaceDir);
+  let movedWorkspacePath;
+  if (pathContains(workspaceDir, themesDir) && fs9.existsSync(themesDir)) {
+    movedWorkspacePath = upath9.join(
+      upath9.dirname(workspaceDir),
+      `.vs-${Date.now()}`
+    );
+    const movedThemePath = upath9.join(
+      movedWorkspacePath,
+      upath9.relative(workspaceDir, themesDir)
+    );
+    fs9.mkdirSync(upath9.dirname(movedThemePath), { recursive: true });
+    registerExitHandler(
+      `Removing the moved workspace directory: ${movedWorkspacePath}`,
+      () => {
+        if (movedWorkspacePath && fs9.existsSync(movedWorkspacePath)) {
+          fs9.rmSync(movedWorkspacePath, { recursive: true, force: true });
+        }
+      }
+    );
+    await move(themesDir, movedThemePath);
+  }
+  await remove3(workspaceDir);
+  if (movedWorkspacePath) {
+    await move(movedWorkspacePath, workspaceDir);
+  }
+}
+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 (await checkThemeInstallationNecessity({ themesDir, themeIndexes })) {
+    Logger.startLogging("Installing theme files");
+    await installThemeDependencies({ themesDir, themeIndexes });
+  }
+  for (const theme of themeIndexes) {
+    if (theme.type === "file" && !pathEquals(theme.source, theme.location)) {
+      fs9.mkdirSync(upath9.dirname(theme.location), { recursive: true });
+      await copy3(theme.source, theme.location);
+    }
+  }
+}
+async function transformManuscript(entry, {
+  entryContextDir,
+  workspaceDir,
+  viewerInput: { manifestPath },
+  title,
+  entries,
+  language,
+  documentProcessorFactory,
+  vfmOptions
+}) {
+  const source = entry.rel === "contents" || entry.rel === "cover" ? entry.template : entry.source;
+  let content;
+  let resourceLoader;
+  const style = entry.themes.flatMap(
+    (theme) => locateThemePath(theme, upath9.dirname(entry.target))
+  );
+  if (source?.type === "file") {
+    if (source.contentType === "text/markdown") {
+      const vfile2 = await processMarkdown(
+        documentProcessorFactory,
+        source.pathname,
+        {
+          ...vfmOptions,
+          style,
+          title: entry.title,
+          language: language ?? void 0
+        }
+      );
+      content = getJsdomFromString({ html: String(vfile2) });
+    } else if (source.contentType === "text/html" || source.contentType === "application/xhtml+xml") {
+      content = await getJsdomFromUrlOrFile({ src: source.pathname });
+      content = await processManuscriptHtml(content, {
+        style,
+        title: entry.title,
+        contentType: source.contentType,
+        language
+      });
+    } else {
+      if (!pathEquals(source.pathname, entry.target)) {
+        await copy3(source.pathname, entry.target);
+      }
+    }
+  } else if (source?.type === "uri") {
+    resourceLoader = new ResourceLoader();
+    try {
+      await getJsdomFromUrlOrFile({
+        src: source.href,
+        resourceLoader,
+        virtualConsole: createVirtualConsole((error) => {
+          Logger.logError(`Failed to fetch resources: ${error.detail}`);
+        })
+      });
+    } catch (error) {
+      throw new DetailError(
+        `Failed to fetch the content from ${source.href}`,
+        error.stack ?? error.message
+      );
+    }
+    const contentFetcher = resourceLoader.fetcherMap.get(source.href);
+    if (contentFetcher) {
+      const buffer = await contentFetcher;
+      const contentType = contentFetcher.response?.headers["content-type"];
+      if (!contentType || new MIMEType2(contentType).essence !== "text/html") {
+        throw new Error(`The content is not an HTML document: ${source.href}`);
+      }
+      content = getJsdomFromString({ html: buffer.toString("utf8") });
+      content = await processManuscriptHtml(content, {
+        style,
+        title: entry.title,
+        contentType: "text/html",
+        language
+      });
+    }
+  } else if (entry.rel === "contents") {
+    content = getJsdomFromString({
+      html: generateDefaultTocHtml({
+        language,
+        title
+      })
+    });
+    content = await processManuscriptHtml(content, {
+      style,
+      title,
+      contentType: "text/html",
+      language
+    });
+  } else if (entry.rel === "cover") {
+    content = getJsdomFromString({
+      html: generateDefaultCoverHtml({ language, title: entry.title })
+    });
+    content = await processManuscriptHtml(content, {
+      style,
+      title: entry.title,
+      contentType: "text/html",
+      language
+    });
+  }
+  if (!content) {
+    return;
+  }
+  if (entry.rel === "contents") {
+    const contentsEntry = entry;
+    const manuscriptEntries = entries.filter(
+      (e) => "source" in e
+    );
+    content = await processTocHtml(content, {
+      entries: manuscriptEntries,
+      manifestPath,
+      distDir: upath9.dirname(contentsEntry.target),
+      tocTitle: contentsEntry.tocTitle,
+      sectionDepth: contentsEntry.sectionDepth,
+      styleOptions: contentsEntry,
+      transform: contentsEntry.transform
+    });
+  }
+  if (entry.rel === "cover") {
+    const coverEntry = entry;
+    content = await processCoverHtml(content, {
+      imageSrc: upath9.relative(
+        upath9.join(
+          entryContextDir,
+          upath9.relative(workspaceDir, coverEntry.target),
+          ".."
+        ),
+        coverEntry.coverImageSrc
+      ),
+      imageAlt: coverEntry.coverImageAlt,
+      styleOptions: coverEntry
+    });
+  }
+  const html = await prettier.format(content.serialize(), {
+    parser: "html",
+    plugins: [parserHtml]
+  });
+  const htmlBuffer = Buffer.from(html, "utf8");
+  if (!source || source.type === "file" && !pathEquals(source.pathname, entry.target)) {
+    writeFileIfChanged(entry.target, htmlBuffer);
+  }
+  if (source?.type === "uri" && resourceLoader) {
+    const { response } = resourceLoader.fetcherMap.get(source.href);
+    const contentFetcher = Promise.resolve(
+      htmlBuffer
+    );
+    contentFetcher.abort = () => {
+    };
+    contentFetcher.response = response;
+    resourceLoader.fetcherMap.set(source.href, contentFetcher);
+    await ResourceLoader.saveFetchedResources({
+      fetcherMap: resourceLoader.fetcherMap,
+      rootUrl: source.href,
+      outputDir: source.rootDir
+    });
+  }
+  return html;
+}
+async function generateManifest({
+  entryContextDir,
+  workspaceDir,
+  viewerInput: { manifestPath },
+  title,
+  author,
+  entries,
+  language,
+  readingProgression,
+  cover
+}) {
+  const manifestEntries = entries.map((entry) => ({
+    title: entry.rel === "contents" && entry.tocTitle || entry.title,
+    path: upath9.relative(workspaceDir, entry.target),
+    encodingFormat: !("contentType" in entry) || entry.contentType === "text/markdown" || entry.contentType === "text/html" ? void 0 : entry.contentType,
+    rel: entry.rel
+  }));
+  writePublicationManifest(manifestPath, {
+    title,
+    author,
+    language,
+    readingProgression,
+    cover: cover && {
+      url: upath9.relative(entryContextDir, cover.src),
+      name: cover.name
+    },
+    entries: manifestEntries,
+    modified: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function compile(config) {
+  const tocEntries = [];
+  for (const entry of config.entries) {
+    if (entry.rel === "contents") {
+      tocEntries.push(entry);
+      continue;
+    }
+    await transformManuscript(entry, config);
+  }
+  for (const entry of tocEntries) {
+    await transformManuscript(entry, config);
+  }
+  if (config.viewerInput.needToGenerateManifest) {
+    await generateManifest(config);
+  }
+}
+function getIgnoreThemeExamplePatterns({
+  themesDir,
+  cwd: cwd2
+}) {
+  return pathContains(cwd2, themesDir) ? [
+    `${upath9.relative(cwd2, themesDir)}/node_modules/*/example`,
+    `${upath9.relative(cwd2, themesDir)}/node_modules/*/*/example`
+  ] : [];
+}
+function getIgnoreAssetPatterns({
+  outputs,
+  entries,
+  cwd: cwd2
+}) {
+  return [
+    ...outputs.flatMap(
+      ({ format, path: p }) => !pathContains(cwd2, p) ? [] : format === "webpub" ? upath9.join(upath9.relative(cwd2, p), "**") : upath9.relative(cwd2, p)
+    ),
+    ...entries.flatMap(({ template }) => {
+      return template?.type === "file" && pathContains(cwd2, template.pathname) ? upath9.relative(cwd2, template.pathname) : [];
+    })
+  ];
+}
+function getAssetMatcherSettings({
+  copyAsset: { fileExtensions, includes, excludes },
+  outputs,
+  themesDir,
+  entries,
+  cwd: cwd2,
+  ignore = []
+}) {
+  const ignorePatterns = [
+    ...ignore,
+    ...excludes,
+    ...getIgnoreAssetPatterns({ outputs, entries, cwd: cwd2 })
+  ];
+  Logger.debug("globAssetFiles > ignorePatterns", ignorePatterns);
+  return [
+    // Step 1: Glob files with an extension in `fileExtension`
+    // Ignore files in node_modules directory, theme example files and files matched `excludes`
+    {
+      patterns: fileExtensions.map((ext) => `**/*.${ext}`),
+      ignore: [
+        "**/node_modules/**",
+        ...ignorePatterns,
+        ...getIgnoreThemeExamplePatterns({ themesDir, cwd: cwd2 })
+      ]
+    },
+    // Step 2: Glob files matched with `includes`
+    // Ignore only files matched `excludes`
+    {
+      patterns: includes,
+      ignore: ignorePatterns
+    }
+  ];
+}
+function getAssetMatcher(arg) {
+  const matchers = getAssetMatcherSettings(arg).map(
+    ({ patterns, ignore }) => picomatch(patterns, { ignore })
+  );
+  return (test) => matchers.some((matcher) => matcher(test));
+}
+async function globAssetFiles(arg) {
+  const settings = getAssetMatcherSettings(arg);
+  return new Set(
+    (await Promise.all(
+      settings.map(
+        ({ patterns, ignore }) => glob2(patterns, {
+          cwd: arg.cwd,
+          ignore,
+          followSymbolicLinks: true
+        })
+      )
+    )).flat()
+  );
+}
+async function copyAssets({
+  entryContextDir,
+  workspaceDir,
+  copyAsset,
+  outputs,
+  themesDir,
+  entries
+}) {
+  if (pathEquals(entryContextDir, workspaceDir)) {
+    return;
+  }
+  const relWorkspaceDir = upath9.relative(entryContextDir, workspaceDir);
+  const assets = await globAssetFiles({
+    copyAsset,
+    cwd: entryContextDir,
+    outputs,
+    themesDir,
+    entries,
+    ignore: [
+      // don't copy workspace itself
+      ...relWorkspaceDir ? [upath9.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);
+  }
+}
+
+// src/vite/plugin-util.ts
+var headStartTagRe = /<head[^>]*>/i;
+var prependToHead = (html, content) => html.replace(headStartTagRe, (match) => `${match}
+${content}`);
+async function reloadConfig(prevConfig, inlineConfig, resolvedViteConfig) {
+  let config = await loadVivliostyleConfig(inlineConfig) ?? setupConfigFromFlags(inlineConfig);
+  config = mergeInlineConfig(config, inlineConfig);
+  config = mergeConfig(config, {
+    temporaryFilePrefix: prevConfig.temporaryFilePrefix,
+    server: resolvedViteConfig?.server
+  });
+  const taskConfig = resolveTaskConfig(config.tasks[0], config.inlineOptions);
+  return taskConfig;
+}
+
+// src/vite/vite-plugin-dev-server.ts
+function createEntriesRouteLookup(entries, cwd2) {
+  const extns = ["", "html", "htm"];
+  const toAssume = (uri) => {
+    let i = 0, x, len = uri.length - 1;
+    if (uri.charCodeAt(len) === 47) {
+      uri = uri.substring(0, len);
+    }
+    let arr = [], tmp2 = `${uri}/index`;
+    for (; i < extns.length; i++) {
+      x = extns[i] ? `.${extns[i]}` : "";
+      if (uri) arr.push(uri + x);
+      arr.push(tmp2 + x);
+    }
+    return arr;
+  };
+  const cache = entries.reduce((acc, e) => {
+    acc[`/${upath10.relative(cwd2, e.target).normalize().replace(/\\+/g, "/")}`] = e;
+    return acc;
+  }, {});
+  return (uri) => {
+    let i = 0, data, arr = toAssume(uri);
+    for (; i < arr.length; i++) {
+      if (data = cache[arr[i]]) return [data, arr[i]];
+    }
+  };
+}
+function getWorkspaceMatcher({
+  workspaceDir,
+  themesDir,
+  viewerInput,
+  themeIndexes
+}) {
+  let entryFiles = [];
+  switch (viewerInput.type) {
+    case "webpub":
+      entryFiles = [upath10.relative(workspaceDir, viewerInput.manifestPath)];
+      break;
+    case "epub":
+      entryFiles = [
+        upath10.join(
+          upath10.relative(workspaceDir, viewerInput.epubTmpOutputDir),
+          "**"
+        )
+      ];
+      break;
+    case "epub-opf":
+    case "webbook":
+      entryFiles = ["**"];
+      break;
+    default:
+      entryFiles = viewerInput;
+  }
+  return picomatch2(
+    [
+      ...entryFiles,
+      ...pathContains(workspaceDir, themesDir) ? [upath10.join(upath10.relative(workspaceDir, themesDir), "**")] : [],
+      ...[...themeIndexes].flatMap(
+        (theme) => theme.type === "file" && pathContains(workspaceDir, theme.location) ? [upath10.relative(workspaceDir, theme.location)] : []
+      )
+    ],
+    { dot: true, ignore: ["node_modules/**"] }
+  );
+}
+function vsDevServerPlugin({
+  config: _config,
+  inlineConfig
+}) {
+  let config = _config;
+  let server;
+  let program;
+  const transformCache = /* @__PURE__ */ new Map();
+  const projectDeps = /* @__PURE__ */ new Set();
+  async function reload(forceUpdate = false) {
+    const prevConfig = config;
+    config = await reloadConfig(prevConfig, inlineConfig, server?.config);
+    transformCache.clear();
+    const needToUpdateManifest = forceUpdate || // FIXME: More precise comparison
+    JSON.stringify(prevConfig) !== JSON.stringify(config);
+    if (isWebPubConfig(config) && config.viewerInput.needToGenerateManifest && needToUpdateManifest) {
+      await generateManifest(config);
+    }
+    await prepareThemeDirectory(config);
+    const entriesLookup = createEntriesRouteLookup(
+      config.entries,
+      config.workspaceDir
+    );
+    const urlMatchRe = new RegExp(
+      `^${escapeRe(config.base)}(/[^?#]*)([?#].*)?$`
+    );
+    const serveWorkspace = sirv(config.workspaceDir, {
+      dev: true,
+      etag: false,
+      dotfiles: true,
+      extensions: []
+    });
+    const serveWorkspaceMatcher = getWorkspaceMatcher(config);
+    const serveAssets = sirv(config.entryContextDir, {
+      dev: true,
+      etag: false,
+      extensions: []
+    });
+    const serveAssetsMatcher = getAssetMatcher({
+      ...config,
+      cwd: config.entryContextDir
+    });
+    program = {
+      entriesLookup,
+      urlMatchRe,
+      serveWorkspace,
+      serveWorkspaceMatcher,
+      serveAssets,
+      serveAssetsMatcher
+    };
+    const configPath = locateVivliostyleConfig(inlineConfig);
+    if (configPath) {
+      projectDeps.add(configPath);
+      server?.watcher.add(configPath);
+    }
+    if (config.viewerInput.type === "webpub") {
+      projectDeps.add(config.viewerInput.manifestPath);
+      server?.watcher.add(config.viewerInput.manifestPath);
+    }
+  }
+  async function transform(entry, config2) {
+    const promise = (async () => {
+      try {
+        const html = await transformManuscript(entry, config2);
+        if (!html) {
+          transformCache.delete(entry.target);
+          return;
+        }
+        const etag = `W/"${Date.now()}"`;
+        if (entry.source?.type === "file") {
+          server?.watcher.add(entry.source.pathname);
+        }
+        return { content: html, etag };
+      } catch (error) {
+        console.error(getFormattedError(error));
+        transformCache.delete(entry.target);
+        return;
+      }
+    })();
+    transformCache.set(entry.target, promise);
+    return await promise;
+  }
+  async function invalidate(entry, config2) {
+    const cwd2 = pathToFileURL7(config2.workspaceDir);
+    const target = pathToFileURL7(entry.target);
+    if (target.href.indexOf(cwd2.href) !== 0) {
+      return;
+    }
+    transformCache.delete(entry.target);
+    config2.entries.filter((entry2) => entry2.rel === "contents").forEach((entry2) => {
+      transformCache.delete(entry2.target);
+    });
+    server?.ws.send({
+      type: "full-reload",
+      path: target.href.slice(cwd2.href.length)
+    });
+  }
+  const devServerMiddleware = async function vivliostyleDevServerMiddleware(req, res, next) {
+    if (!isWebPubConfig(config) || !program) {
+      return next();
+    }
+    const { entriesLookup, urlMatchRe } = program;
+    const [_, pathname, qs] = decodeURI(req.url).match(urlMatchRe) ?? [];
+    const match = pathname && entriesLookup(pathname);
+    if (!match) {
+      return next();
+    }
+    const [entry, expected] = match;
+    if (pathname !== expected) {
+      res.statusCode = 301;
+      res.setHeader("Location", `${expected}${qs || ""}`);
+      return res.end();
+    }
+    const cachePromise = transformCache.get(entry.target);
+    if (cachePromise) {
+      const cached = await cachePromise;
+      if (!cached) {
+        return next();
+      }
+      if (req.headers["if-none-match"] === cached.etag) {
+        res.statusCode = 304;
+        return res.end();
+      } else {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html;charset=utf-8");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Etag", cached.etag);
+        return res.end(cached.content);
+      }
+    }
+    if (entry.rel === "contents") {
+      const _config2 = { ...config };
+      await Promise.all(
+        _config2.entries.flatMap(
+          (e) => isWebPubConfig(_config2) && e.rel !== "contents" && e.rel !== "cover" ? transform(e, _config2) : []
+        )
+      );
+    }
+    const result = await transform(entry, config);
+    if (!result) {
+      return next();
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html;charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Etag", result.etag);
+    return res.end(result.content);
+  };
+  const serveWorkspaceMiddleware = async function vivliostyleServeWorkspaceMiddleware(req, res, next) {
+    if (!config || !program) {
+      return next();
+    }
+    const {
+      urlMatchRe,
+      serveWorkspace,
+      serveWorkspaceMatcher,
+      serveAssets,
+      serveAssetsMatcher
+    } = program;
+    const [_, pathname] = decodeURI(req.url).match(urlMatchRe) ?? [];
+    if (pathname && serveWorkspaceMatcher(pathname.slice(1))) {
+      req.url = req.url.slice(config.base.length);
+      return serveWorkspace(req, res, next);
+    }
+    if (pathname && serveAssetsMatcher(pathname.slice(1))) {
+      req.url = req.url.slice(config.base.length);
+      return serveAssets(req, res, next);
+    }
+    next();
+  };
+  return {
+    name: "vivliostyle:dev-server",
+    enforce: "pre",
+    configureServer(viteServer) {
+      server = viteServer;
+      const handleUpdate = async (pathname) => {
+        if (!projectDeps.has(pathname)) {
+          return;
+        }
+        await reload();
+        viteServer.ws.send({
+          type: "full-reload",
+          path: "*"
+        });
+      };
+      viteServer.watcher.on("add", handleUpdate);
+      viteServer.watcher.on("change", handleUpdate);
+      viteServer.watcher.on("unlink", handleUpdate);
+      return () => {
+        viteServer.middlewares.use(devServerMiddleware);
+        viteServer.middlewares.use(serveWorkspaceMiddleware);
+      };
+    },
+    configurePreviewServer(viteServer) {
+      return () => {
+        viteServer.middlewares.use(
+          config.base,
+          sirv(config.workspaceDir, { dev: true, etag: false, extensions: [] })
+        );
+      };
+    },
+    async buildStart() {
+      await reload(true);
+    },
+    async handleHotUpdate(ctx) {
+      const entry = config?.entries.find(
+        (e) => e.source?.type === "file" && e.source.pathname === ctx.file || !e.source && e.target === ctx.file
+      );
+      if (config && entry) {
+        await invalidate(entry, config);
+      }
+    }
+  };
+}
+
+// src/vite/vite-plugin-static-serve.ts
+import sirv2 from "sirv";
+import upath11 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
+        })
+      ]
+    )
+  );
+  return {
+    name: "vivliostyle:static-serve",
+    apply: () => Boolean(inlineConfig.enableStaticServe),
+    configureServer(viteServer) {
+      return () => {
+        createMiddlewares().forEach(([base, middleware]) => {
+          viteServer.middlewares.use(base, middleware);
+        });
+      };
+    },
+    configurePreviewServer(viteServer) {
+      return () => {
+        createMiddlewares().forEach(([base, middleware]) => {
+          viteServer.middlewares.use(base, middleware);
+        });
+      };
+    }
+  };
+}
+
+// src/vite/vite-plugin-viewer.ts
+import fs10 from "node:fs";
+import sirv3 from "sirv";
+import upath12 from "upath";
+var viewerClientId = "@vivliostyle:viewer:client";
+var viewerClientRequestPath = `/${viewerClientId}`;
+var viewerClientContent = (
+  /* js */
+  `
+if (import.meta.hot) {
+  import.meta.hot.on('vite:beforeFullReload', (e) => {
+    location.reload();
+  });
+}`
+);
+function vsViewerPlugin(_) {
+  const serveRootDir = upath12.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"),
+        `<script type="module" src="${viewerClientRequestPath}"></script>`
+      );
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html;charset=utf-8");
+      res.setHeader("Cache-Control", "no-cache");
+      return res.end(cachedIndexHtml);
+    } else {
+      return serve(req, res, next);
+    }
+  };
+  return {
+    name: "vivliostyle:viewer",
+    config() {
+      return {
+        optimizeDeps: { exclude: ["@vivliostyle/viewer"] }
+      };
+    },
+    configureServer(viteServer) {
+      viteServer.middlewares.use(VIEWER_ROOT_PATH, middleware);
+    },
+    configurePreviewServer(viteServer) {
+      viteServer.middlewares.use(VIEWER_ROOT_PATH, serve);
+    },
+    load(id) {
+      if (id === viewerClientRequestPath) {
+        return viewerClientContent;
+      }
+    }
+  };
+}
+
+// src/server.ts
+function getViewerParams(src, {
+  size,
+  cropMarks,
+  bleed,
+  cropOffset,
+  css,
+  customStyle,
+  customUserStyle,
+  singleDoc,
+  quick,
+  viewerParam
+}) {
+  const pageSizeValue = size && ("format" in size ? size.format : `${size.width} ${size.height}`);
+  function escapeParam(url) {
+    return url.replace(/&/g, "%26");
+  }
+  let viewerParams = src ? `src=${escapeParam(src)}` : "";
+  viewerParams += `&bookMode=${!singleDoc}&renderAllPages=${!quick}`;
+  if (customStyle) {
+    viewerParams += `&style=${escapeParam(customStyle)}`;
+  }
+  if (customUserStyle) {
+    viewerParams += `&userStyle=${escapeParam(customUserStyle)}`;
+  }
+  if (pageSizeValue || cropMarks || bleed || cropOffset || css) {
+    let pageStyle = "@page{";
+    if (pageSizeValue) {
+      pageStyle += `size:${pageSizeValue};`;
+    }
+    if (cropMarks) {
+      pageStyle += `marks:crop cross;`;
+    }
+    if (bleed || cropMarks) {
+      pageStyle += `bleed:${bleed ?? "3mm"};`;
+    }
+    if (cropOffset) {
+      pageStyle += `crop-offset:${cropOffset};`;
+    }
+    pageStyle += "}";
+    viewerParams += `&style=data:,/*<viewer>*/${encodeURIComponent(
+      pageStyle
+    )}/*</viewer>*/${encodeURIComponent(css ?? "")}`;
+  }
+  if (viewerParam) {
+    viewerParams += `&${viewerParam}`;
+  }
+  return viewerParams;
+}
+async function getSourceUrl({
+  viewerInput,
+  base,
+  workspaceDir,
+  rootUrl
+}) {
+  let input;
+  switch (viewerInput.type) {
+    case "webpub":
+      input = viewerInput.manifestPath;
+      break;
+    case "webbook":
+      input = viewerInput.webbookEntryUrl;
+      break;
+    case "epub-opf":
+      input = viewerInput.epubOpfPath;
+      break;
+    case "epub": {
+      if (!fs11.existsSync(viewerInput.epubTmpOutputDir)) {
+        await openEpub(viewerInput.epubPath, viewerInput.epubTmpOutputDir);
+      }
+      input = getDefaultEpubOpfPath(viewerInput.epubTmpOutputDir);
+      break;
+    }
+    default:
+      input = viewerInput;
+  }
+  return (isValidUri(input) ? new URL2(input) : new URL2(
+    upath13.posix.join(base, upath13.relative(workspaceDir, input)),
+    rootUrl
+  )).href;
+}
+async function getViewerFullUrl({
+  viewerInput,
+  base,
+  workspaceDir,
+  rootUrl,
+  viewer,
+  ...config
+}) {
+  const viewerUrl = viewer ? new URL2(viewer) : new URL2(`${VIEWER_ROOT_PATH}/index.html`, rootUrl);
+  const sourceUrl = await getSourceUrl({
+    viewerInput,
+    base,
+    workspaceDir,
+    rootUrl
+  });
+  const viewerParams = getViewerParams(
+    sourceUrl === EMPTY_DATA_URI ? void 0 : sourceUrl,
+    config
+  );
+  viewerUrl.hash = "";
+  return `${viewerUrl.href}#${viewerParams}`;
+}
+async function createViteServer({
+  config,
+  viteConfig,
+  inlineConfig,
+  mode
+}) {
+  const viteInlineConfig = {
+    clearScreen: false,
+    configFile: false,
+    appType: "custom",
+    plugins: [
+      vsDevServerPlugin({ config, inlineConfig }),
+      vsViewerPlugin({ config, inlineConfig }),
+      vsBrowserPlugin({ config, inlineConfig }),
+      vsStaticServePlugin({ config, inlineConfig })
+    ],
+    server: viteConfig.server,
+    preview: viteConfig.preview,
+    customLogger: viteConfig.customLogger,
+    cacheDir: viteConfig.cacheDir
+  };
+  Logger.debug("createViteServer > viteInlineConfig %O", viteInlineConfig);
+  if (config.context === config.workspaceDir) {
+    const { cacheDir } = viteInlineConfig;
+    registerExitHandler("Removing the Vite cacheDir", () => {
+      if (fs11.existsSync(cacheDir)) {
+        fs11.rmSync(cacheDir, { recursive: true });
+      }
+    });
+  }
+  if (mode === "preview") {
+    return await createServer(viteInlineConfig);
+  } else {
+    return await preview(viteInlineConfig);
+  }
+}
+
+// src/vite/vite-plugin-browser.ts
+function vsBrowserPlugin({
+  config: _config,
+  inlineConfig
+}) {
+  let config = _config;
+  let server;
+  let closeBrowser;
+  async function handlePageClose() {
+    await server?.close();
+    runExitHandlers();
+  }
+  async function openPreviewPage() {
+    const url = await getViewerFullUrl(config);
+    const { page, browser } = await launchPreview({
+      mode: "preview",
+      url,
+      config,
+      onPageOpen: async (page2) => {
+        page2.on("close", handlePageClose);
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        await page2.addInitScript(
+          `window.localStorage.setItem('i18nextLng', '${locale}');`
+        );
+      }
+    });
+    await page.bringToFront();
+    await page.locator("#vivliostyle-input-url").focus({ timeout: 0 });
+    closeBrowser = () => {
+      page.off("close", handlePageClose);
+      browser.close();
+    };
+  }
+  return {
+    name: "vivliostyle:browser",
+    apply: () => Boolean(inlineConfig.openViewer),
+    configureServer(viteServer) {
+      server = viteServer;
+      const _listen = viteServer.listen;
+      viteServer.listen = async (...args) => {
+        const server2 = await _listen(...args);
+        config = await reloadConfig(config, inlineConfig, server2.config);
+        await openPreviewPage();
+        return server2;
+      };
+    },
+    closeBundle() {
+      closeBrowser?.();
+    }
+  };
+}
+
+export {
+  cwd,
+  runExitHandlers,
+  gracefulError,
+  pathEquals,
+  isInContainer,
+  isUnicodeSupported,
+  randomBookSymbol,
+  Logger,
+  parseFlagsToInlineConfig,
+  setupConfigFromFlags,
+  loadVivliostyleConfig,
+  warnDeprecatedConfig,
+  mergeConfig,
+  mergeInlineConfig,
+  getFullBrowserName,
+  launchPreview,
+  vsBrowserPlugin,
+  buildWebPublication,
+  cleanupWorkspace,
+  prepareThemeDirectory,
+  compile,
+  copyAssets,
+  vsDevServerPlugin,
+  vsStaticServePlugin,
+  vsViewerPlugin,
+  getViewerFullUrl,
+  createViteServer,
+  CONTAINER_IMAGE,
+  toContainerPath,
+  collectVolumeArgs,
+  runContainer,
+  buildPDFWithContainer,
+  isWebPubConfig,
+  resolveTaskConfig
+};