@vivliostyle/cli 9.0.1 → 9.0.2

package/dist/chunk-S2Q2FDUM.js

@@ -0,0 +1,1138 @@
+import {
+  VivliostyleInlineConfig
+} from "./chunk-WFLNEE7C.js";
+import {
+  EMPTY_DATA_URI
+} from "./chunk-4IIM6RSG.js";
+
+// src/util.ts
+import { codeFrameColumns } from "@babel/code-frame";
+import {
+  evaluate,
+  parse
+} from "@humanwhocodes/momoa";
+import { Ajv } from "ajv";
+import formatsPlugin from "ajv-formats";
+import { XMLParser } from "fast-xml-parser";
+import StreamZip from "node-stream-zip";
+import fs from "node:fs";
+import readline from "node:readline";
+import util from "node:util";
+import tmp from "tmp";
+import upath from "upath";
+import { gray as gray2, red, redBright as redBright2 } from "yoctocolors";
+
+// src/logger.ts
+import debug from "debug";
+import yoctoSpinner from "yocto-spinner";
+import {
+  blueBright,
+  gray,
+  greenBright,
+  redBright,
+  yellowBright
+} from "yoctocolors";
+var isUnicodeSupported = process.platform !== "win32" || Boolean(process.env.WT_SESSION);
+var randomBookSymbol = ["\u{1F4D5}", "\u{1F4D7}", "\u{1F4D8}", "\u{1F4D9}"][Math.floor(Math.random() * 4)];
+var infoSymbol = blueBright("INFO");
+var successSymbol = greenBright("SUCCESS");
+var warnSymbol = yellowBright("WARN");
+var errorSymbol = redBright("ERROR");
+var Logger = class _Logger {
+  /**
+   * 0: silent 1: info 2: verbose 3: debug
+   */
+  static #logLevel = 0;
+  static #loggerInstance;
+  static #nonBlockingLogPrinted = false;
+  static #customLogger;
+  static debug = debug("vs-cli");
+  static get #spinner() {
+    return this.#loggerInstance && this.#loggerInstance.#_spinner;
+  }
+  static get isInteractive() {
+    return Boolean(
+      !this.#customLogger && process.stderr.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env) && !import.meta.env?.VITEST && !debug.enabled("vs-cli") && // Prevent stream output in docker container so that not to spawn process
+      !isInContainer()
+    );
+  }
+  static startLogging(text) {
+    if (this.#logLevel === 0) {
+      return;
+    }
+    if (!this.isInteractive) {
+      this.logInfo(text);
+      return;
+    }
+    if (this.#loggerInstance) {
+      this.#loggerInstance.#_spinner.text = text;
+      return this.#loggerInstance;
+    }
+    this.#loggerInstance = new _Logger();
+    this.#loggerInstance.#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;
+  #_disposeSpinnerExitHandler;
+  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;
+  }
+  #start(text) {
+    this.#_spinner.start(text);
+    this.#_disposeSpinnerExitHandler = registerExitHandler(
+      "Stopping spinner",
+      () => {
+        this.#_spinner.stop();
+      }
+    );
+  }
+  [Symbol.dispose]() {
+    this.#_disposeSpinnerExitHandler?.();
+    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) => {
+  const callback = () => {
+    Logger.debug(debugMessage);
+    handler();
+  };
+  beforeExitHandlers.push(callback);
+  return () => {
+    const index = beforeExitHandlers.indexOf(callback);
+    if (index !== -1) {
+      beforeExitHandlers.splice(index, 1);
+    }
+  };
+};
+function runExitHandlers() {
+  while (beforeExitHandlers.length) {
+    try {
+      beforeExitHandlers.shift()?.();
+    } catch (e) {
+    }
+  }
+}
+var exitSignals = ["exit", "SIGINT", "SIGTERM"];
+exitSignals.forEach((sig) => {
+  process.once(sig, (signal, exitCode) => {
+    runExitHandlers();
+    if (process.exitCode === void 0) {
+      process.exitCode = exitCode !== void 0 ? 128 + exitCode : Number(signal);
+    }
+    process.exit();
+  });
+});
+if (process.platform === "win32") {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.on("SIGINT", () => {
+    runExitHandlers();
+    process.exit(1);
+  });
+  registerExitHandler("Closing readline interface", () => {
+    rl.close();
+  });
+}
+var DetailError = class extends Error {
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+  }
+};
+function getFormattedError(err) {
+  return err instanceof DetailError ? `${err.message}
+${err.detail}` : err.stack || `${err.message}`;
+}
+function gracefulError(err) {
+  console.log(`${redBright2("ERROR")} ${getFormattedError(err)}
+
+${gray2("If you think this is a bug, please report at https://github.com/vivliostyle/vivliostyle-cli/issues")}`);
+  process.exit(1);
+}
+function readJSON(path) {
+  try {
+    return JSON.parse(fs.readFileSync(path, "utf8"));
+  } catch (err) {
+    return void 0;
+  }
+}
+function statFileSync(filePath, {
+  errorMessage = "Specified input does not exist"
+} = {}) {
+  try {
+    return fs.statSync(filePath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(`${errorMessage}: ${filePath}`);
+    }
+    throw err;
+  }
+}
+async function inflateZip(filePath, dest) {
+  return await new Promise((res, rej) => {
+    try {
+      const zip = new StreamZip({
+        file: filePath,
+        storeEntries: true
+      });
+      zip.on("error", (err) => {
+        rej(err);
+      });
+      zip.on("ready", async () => {
+        await util.promisify(zip.extract)(null, dest);
+        await util.promisify(zip.close)();
+        Logger.debug(`Unzipped ${filePath} to ${dest}`);
+        res();
+      });
+    } catch (err) {
+      rej(err);
+    }
+  });
+}
+function useTmpDirectory() {
+  return new Promise((res, rej) => {
+    tmp.dir({ unsafeCleanup: true }, (err, path, clear) => {
+      if (err) {
+        return rej(err);
+      }
+      Logger.debug(`Created the temporary directory: ${path}`);
+      if (import.meta.env?.VITEST) {
+        return res([path, () => {
+        }]);
+      }
+      const callback = () => {
+        fs.rmSync(path, { force: true, recursive: true });
+      };
+      registerExitHandler(
+        `Removing the temporary directory: ${path}`,
+        callback
+      );
+      res([path, callback]);
+    });
+  });
+}
+function touchTmpFile(path) {
+  fs.mkdirSync(upath.dirname(path), { recursive: true });
+  fs.closeSync(fs.openSync(path, "a"));
+  Logger.debug(`Created the temporary file: ${path}`);
+  const callback = () => {
+    fs.rmSync(path, { force: true, recursive: true });
+  };
+  registerExitHandler(`Removing the temporary file: ${path}`, callback);
+  return callback;
+}
+function pathEquals(path1, path2) {
+  return upath.relative(path1, path2) === "";
+}
+function pathContains(parentPath, childPath) {
+  const rel = upath.relative(parentPath, childPath);
+  return rel !== "" && !rel.startsWith("..");
+}
+function isValidUri(str) {
+  return /^(https?|file|data):/i.test(str);
+}
+function isInContainer() {
+  return fs.existsSync("/opt/vivliostyle-cli/.vs-cli-version");
+}
+function isRunningOnWSL() {
+  return fs.existsSync("/proc/version") && fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+}
+async function openEpub(epubPath, tmpDir) {
+  await inflateZip(epubPath, tmpDir);
+  Logger.debug(`Created the temporary EPUB directory: ${tmpDir}`);
+  const deleteEpub = () => {
+    fs.rmSync(tmpDir, { force: true, recursive: true });
+  };
+  registerExitHandler(
+    `Removing the temporary EPUB directory: ${tmpDir}`,
+    deleteEpub
+  );
+  return deleteEpub;
+}
+function getDefaultEpubOpfPath(epubDir) {
+  const containerXmlPath = upath.join(epubDir, "META-INF/container.xml");
+  const xmlParser = new XMLParser({
+    ignoreAttributes: false
+  });
+  const { container } = xmlParser.parse(
+    fs.readFileSync(containerXmlPath, "utf8")
+  );
+  const rootfile = [container.rootfiles.rootfile].flat()[0];
+  const epubOpfPath = upath.join(epubDir, rootfile["@_full-path"]);
+  return epubOpfPath;
+}
+function getEpubRootDir(epubOpfPath) {
+  function traverse(dir) {
+    const files = fs.readdirSync(dir);
+    if (files.includes("META-INF") && pathEquals(epubOpfPath, getDefaultEpubOpfPath(dir))) {
+      return dir;
+    }
+    const next = upath.dirname(dir);
+    if (pathEquals(dir, next)) {
+      return;
+    }
+    return traverse(next);
+  }
+  return traverse(upath.dirname(epubOpfPath));
+}
+var getAjvValidatorFunction = (schema, refSchemas) => (obj) => {
+  const ajv = new Ajv({ strict: false });
+  const addFormats = formatsPlugin;
+  addFormats(ajv);
+  if (refSchemas) {
+    ajv.addSchema(refSchemas);
+  }
+  const validate = ajv.compile(schema);
+  const valid = validate(obj);
+  if (!valid) {
+    throw validate.errors?.[0] || new Error();
+  }
+  return true;
+};
+var assertPubManifestSchema = getAjvValidatorFunction(
+  publication_schema_default,
+  publicationSchemas
+);
+function parseJsonc(rawJsonc) {
+  const ast = parse(rawJsonc, {
+    mode: "jsonc",
+    ranges: false,
+    tokens: false
+  });
+  return evaluate(ast);
+}
+function prettifySchemaError(rawJsonc, issues) {
+  const parsed = parse(rawJsonc, {
+    mode: "jsonc",
+    ranges: false,
+    tokens: false
+  });
+  function traverse(issues2, depth) {
+    return issues2.flatMap((issue) => {
+      const p = issue.path?.length || 0;
+      if (!issue.issues) {
+        return [[[issue], depth + p]];
+      }
+      return traverse(issue.issues, depth + p).map(([i, d]) => [
+        [issue, ...i],
+        d
+      ]);
+    });
+  }
+  const all = traverse(issues, 0);
+  const maxDepth = Math.max(...all.map(([, d]) => d));
+  const issuesTraversed = all.find(([, d]) => d === maxDepth)[0];
+  let jsonValue = parsed.body;
+  for (const p of issuesTraversed.flatMap((v2) => v2.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;
+}
+
+export {
+  cwd,
+  registerExitHandler,
+  runExitHandlers,
+  DetailError,
+  getFormattedError,
+  gracefulError,
+  readJSON,
+  statFileSync,
+  useTmpDirectory,
+  touchTmpFile,
+  pathEquals,
+  pathContains,
+  isValidUri,
+  isInContainer,
+  isRunningOnWSL,
+  openEpub,
+  getDefaultEpubOpfPath,
+  getEpubRootDir,
+  assertPubManifestSchema,
+  parseJsonc,
+  prettifySchemaError,
+  writeFileIfChanged,
+  isUnicodeSupported,
+  randomBookSymbol,
+  Logger,
+  parseFlagsToInlineConfig,
+  setupConfigFromFlags
+};
+//# sourceMappingURL=chunk-S2Q2FDUM.js.map