@storyteller-platform/align 0.0.1

package/dist/markup/markup.cjs

@@ -0,0 +1,316 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var markup_exports = {};
+__export(markup_exports, {
+  appendTextNode: () => appendTextNode,
+  markup: () => markup,
+  markupChapter: () => markupChapter
+});
+module.exports = __toCommonJS(markup_exports);
+var import_promises = require("node:fs/promises");
+var import_posix = require("node:path/posix");
+var import_epub = require("@storyteller-platform/epub");
+var import_ghost_story = require("@storyteller-platform/ghost-story");
+var import_segmentation = require("./segmentation.cjs");
+var import_semantics = require("./semantics.cjs");
+async function markup(input, output, options) {
+  var _a, _b;
+  var _stack = [];
+  try {
+    const timing = (0, import_ghost_story.createAggregator)();
+    timing.setMetadata("granularity", options.granularity ?? "sentence");
+    await (0, import_promises.copyFile)(input, output);
+    const epub = __using(_stack, await import_epub.Epub.from(output));
+    const primaryLocale = options.primaryLocale ?? await epub.getLanguage();
+    const spine = await epub.getSpineItems();
+    for (let index = 0; index < spine.length; index++) {
+      (_a = options.onProgress) == null ? void 0 : _a.call(options, index / spine.length);
+      const spineItem = spine[index];
+      (_b = options.logger) == null ? void 0 : _b.info(
+        `Marking up epub item #${index}: ${(0, import_posix.basename)(spineItem.href)}`
+      );
+      const chapterId = spineItem.id;
+      const chapterXml = await epub.readXhtmlItemContents(chapterId);
+      const segmentation = await (0, import_segmentation.getXhtmlSegmentation)(
+        import_epub.Epub.getXhtmlBody(chapterXml),
+        { primaryLocale }
+      );
+      const { markedUp, timing: chapterTiming } = markupChapter(
+        chapterId,
+        chapterXml,
+        segmentation
+      );
+      timing.add(chapterTiming.summary());
+      await epub.writeXhtmlItemContents(chapterId, markedUp);
+    }
+    await epub.saveAndClose();
+    return timing;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function markupChapter(chapterId, chapterXml, segmentation) {
+  const timing = (0, import_ghost_story.createTiming)();
+  const html = import_epub.Epub.findXmlChildByName("html", chapterXml);
+  if (!html) throw new Error("Invalid XHTML document: no html element");
+  const body = import_epub.Epub.findXmlChildByName("body", html["html"]);
+  if (!body) throw new Error("Invalid XHTML document: No body element");
+  clearBodyElement(chapterXml);
+  const taggedHtml = import_epub.Epub.findXmlChildByName("html", chapterXml);
+  const taggedBody = import_epub.Epub.findXmlChildByName("body", taggedHtml["html"]);
+  taggedBody["body"] = [];
+  timing.time("mark up", () => {
+    markupBySegmentation(
+      chapterId,
+      {
+        currentSentenceIndex: 0,
+        currentNodeProgress: 0,
+        currentSentenceProgress: 0
+      },
+      segmentation,
+      body,
+      /* @__PURE__ */ new Set(),
+      [],
+      import_epub.Epub.getXmlChildren(taggedBody)
+    );
+  });
+  return { markedUp: chapterXml, timing };
+}
+function markupBySegmentation(chapterId, state, segmentation, currentNode, taggedSentences, marks, taggedXml) {
+  if (import_epub.Epub.isXmlTextNode(currentNode)) {
+    const remainingSentence = segmentation.sentences[state.currentSentenceIndex].text.slice(state.currentSentenceProgress);
+    const text = currentNode["#text"];
+    const remainingNodeText = text.slice(state.currentNodeProgress);
+    const index = remainingNodeText.indexOf(remainingSentence[0]);
+    if (index === -1) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText,
+        marks,
+        taggedSentences
+      );
+      return {
+        ...state,
+        currentNodeProgress: -1
+      };
+    }
+    if (remainingNodeText.slice(index).length < remainingSentence.length) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(0, index),
+        marks,
+        taggedSentences
+      );
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(index),
+        marks,
+        taggedSentences,
+        state.currentSentenceIndex
+      );
+      return {
+        ...state,
+        currentSentenceProgress: state.currentSentenceProgress + remainingNodeText.length - index,
+        currentNodeProgress: -1
+      };
+    }
+    appendTextNode(
+      chapterId,
+      taggedXml,
+      remainingNodeText.slice(0, index),
+      marks,
+      taggedSentences
+    );
+    appendTextNode(
+      chapterId,
+      taggedXml,
+      remainingSentence,
+      marks,
+      taggedSentences,
+      state.currentSentenceIndex
+    );
+    if (state.currentSentenceIndex + 1 === segmentation.sentences.length) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(index + remainingSentence.length),
+        marks,
+        taggedSentences
+      );
+    }
+    return {
+      currentSentenceIndex: state.currentSentenceIndex + 1,
+      currentSentenceProgress: 0,
+      currentNodeProgress: state.currentNodeProgress + remainingSentence.length + index
+    };
+  }
+  let nextState = {
+    ...state
+  };
+  const children = import_epub.Epub.getXmlChildren(currentNode);
+  for (const child of children) {
+    if (nextState.currentSentenceIndex > segmentation.sentences.length + 1) {
+      taggedXml.push(child);
+      continue;
+    }
+    nextState.currentNodeProgress = 0;
+    let nextTaggedXml = taggedXml;
+    const nextMarks = [...marks];
+    if (!import_epub.Epub.isXmlTextNode(child)) {
+      const childTagName = import_epub.Epub.getXmlElementName(child);
+      const isTextContent = import_semantics.BLOCKS.includes(childTagName.toLowerCase());
+      if (import_epub.Epub.getXmlChildren(child).length === 0) {
+        appendLeafNode(
+          chapterId,
+          taggedXml,
+          child,
+          nextMarks,
+          taggedSentences,
+          isTextContent || nextState.currentSentenceProgress === 0 ? void 0 : nextState.currentSentenceIndex
+        );
+        continue;
+      }
+      if (isTextContent) {
+        const block = {
+          [childTagName]: [],
+          ...child[":@"] && { ":@": child[":@"] }
+        };
+        nextTaggedXml.push(block);
+        nextTaggedXml = import_epub.Epub.getXmlChildren(block);
+      } else {
+        nextMarks.push({
+          elementName: childTagName,
+          attributes: child[":@"]
+        });
+      }
+    }
+    while (nextState.currentSentenceIndex < segmentation.sentences.length && nextState.currentNodeProgress !== -1) {
+      nextState = markupBySegmentation(
+        chapterId,
+        nextState,
+        segmentation,
+        child,
+        taggedSentences,
+        nextMarks,
+        nextTaggedXml
+      );
+    }
+  }
+  nextState.currentNodeProgress = -1;
+  return nextState;
+}
+function appendTextNode(chapterId, xml, text, marks, taggedSentences, sentenceId) {
+  if (text.length === 0) return;
+  const textNode = { "#text": text };
+  appendLeafNode(chapterId, xml, textNode, marks, taggedSentences, sentenceId);
+}
+function appendLeafNode(chapterId, xml, node, marks, taggedSentences, sentenceId) {
+  var _a, _b;
+  const tagId = `${chapterId}-s${sentenceId}`;
+  const markedNode = [...marks].reverse().reduce(
+    (acc, mark) => ({
+      [mark.elementName]: [acc],
+      ":@": mark.attributes
+    }),
+    node
+  );
+  const lastNode = xml[xml.length - 1];
+  if (lastNode && !import_epub.Epub.isXmlTextNode(lastNode) && ((_a = lastNode[":@"]) == null ? void 0 : _a["@_id"]) && lastNode[":@"]["@_id"] === tagId) {
+    const tagName = import_epub.Epub.getXmlElementName(lastNode);
+    (_b = lastNode[tagName]) == null ? void 0 : _b.push(markedNode);
+    return;
+  }
+  if (sentenceId === void 0 || taggedSentences.has(sentenceId)) {
+    xml.push(markedNode);
+    return;
+  }
+  const taggedNode = {
+    span: [markedNode],
+    ":@": { "@_id": tagId }
+  };
+  taggedSentences.add(sentenceId);
+  xml.push(taggedNode);
+}
+function clearBodyElement(xml) {
+  const html = import_epub.Epub.findXmlChildByName("html", xml);
+  if (!html) throw new Error("Invalid XHTML: Found no html element");
+  const bodyIndex = html["html"].findIndex((element) => "body" in element);
+  const body = html["html"][bodyIndex];
+  if (!body) throw new Error("Invalid XHTML: Found no body element");
+  html["html"].splice(bodyIndex, 1, {
+    ...body,
+    body: []
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendTextNode,
+  markup,
+  markupChapter
+});

package/dist/markup/markup.d.cts

@@ -0,0 +1,24 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { SegmentationResult } from '@echogarden/text-segmentation';
+import { Logger } from 'pino';
+import { ParsedXml, ElementName } from '@storyteller-platform/epub';
+
+interface MarkupOptions {
+    granularity?: "word" | "sentence";
+    primaryLocale?: Intl.Locale;
+    onProgress?: (progress: number) => void;
+    logger?: Logger;
+}
+declare function markup(input: string, output: string, options: MarkupOptions): Promise<TimingAggregator>;
+declare function markupChapter(chapterId: string, chapterXml: ParsedXml, segmentation: SegmentationResult): {
+    markedUp: ParsedXml;
+    timing: _storyteller_platform_ghost_story.Timing;
+};
+type Mark = {
+    elementName: ElementName;
+    attributes: Record<string, string> | undefined;
+};
+declare function appendTextNode(chapterId: string, xml: ParsedXml, text: string, marks: Mark[], taggedSentences: Set<number>, sentenceId?: number): void;
+
+export { type MarkupOptions, appendTextNode, markup, markupChapter };

package/dist/markup/markup.d.ts

@@ -0,0 +1,24 @@
+import * as _storyteller_platform_ghost_story from '@storyteller-platform/ghost-story';
+import { TimingAggregator } from '@storyteller-platform/ghost-story';
+import { SegmentationResult } from '@echogarden/text-segmentation';
+import { Logger } from 'pino';
+import { ParsedXml, ElementName } from '@storyteller-platform/epub';
+
+interface MarkupOptions {
+    granularity?: "word" | "sentence";
+    primaryLocale?: Intl.Locale;
+    onProgress?: (progress: number) => void;
+    logger?: Logger;
+}
+declare function markup(input: string, output: string, options: MarkupOptions): Promise<TimingAggregator>;
+declare function markupChapter(chapterId: string, chapterXml: ParsedXml, segmentation: SegmentationResult): {
+    markedUp: ParsedXml;
+    timing: _storyteller_platform_ghost_story.Timing;
+};
+type Mark = {
+    elementName: ElementName;
+    attributes: Record<string, string> | undefined;
+};
+declare function appendTextNode(chapterId: string, xml: ParsedXml, text: string, marks: Mark[], taggedSentences: Set<number>, sentenceId?: number): void;
+
+export { type MarkupOptions, appendTextNode, markup, markupChapter };

package/dist/markup/markup.js

@@ -0,0 +1,254 @@
+import {
+  __callDispose,
+  __using
+} from "../chunk-BIEQXUOY.js";
+import { copyFile } from "node:fs/promises";
+import { basename } from "node:path/posix";
+import {
+  Epub
+} from "@storyteller-platform/epub";
+import {
+  createAggregator,
+  createTiming
+} from "@storyteller-platform/ghost-story";
+import { getXhtmlSegmentation } from "./segmentation.js";
+import { BLOCKS } from "./semantics.js";
+async function markup(input, output, options) {
+  var _a, _b;
+  var _stack = [];
+  try {
+    const timing = createAggregator();
+    timing.setMetadata("granularity", options.granularity ?? "sentence");
+    await copyFile(input, output);
+    const epub = __using(_stack, await Epub.from(output));
+    const primaryLocale = options.primaryLocale ?? await epub.getLanguage();
+    const spine = await epub.getSpineItems();
+    for (let index = 0; index < spine.length; index++) {
+      (_a = options.onProgress) == null ? void 0 : _a.call(options, index / spine.length);
+      const spineItem = spine[index];
+      (_b = options.logger) == null ? void 0 : _b.info(
+        `Marking up epub item #${index}: ${basename(spineItem.href)}`
+      );
+      const chapterId = spineItem.id;
+      const chapterXml = await epub.readXhtmlItemContents(chapterId);
+      const segmentation = await getXhtmlSegmentation(
+        Epub.getXhtmlBody(chapterXml),
+        { primaryLocale }
+      );
+      const { markedUp, timing: chapterTiming } = markupChapter(
+        chapterId,
+        chapterXml,
+        segmentation
+      );
+      timing.add(chapterTiming.summary());
+      await epub.writeXhtmlItemContents(chapterId, markedUp);
+    }
+    await epub.saveAndClose();
+    return timing;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function markupChapter(chapterId, chapterXml, segmentation) {
+  const timing = createTiming();
+  const html = Epub.findXmlChildByName("html", chapterXml);
+  if (!html) throw new Error("Invalid XHTML document: no html element");
+  const body = Epub.findXmlChildByName("body", html["html"]);
+  if (!body) throw new Error("Invalid XHTML document: No body element");
+  clearBodyElement(chapterXml);
+  const taggedHtml = Epub.findXmlChildByName("html", chapterXml);
+  const taggedBody = Epub.findXmlChildByName("body", taggedHtml["html"]);
+  taggedBody["body"] = [];
+  timing.time("mark up", () => {
+    markupBySegmentation(
+      chapterId,
+      {
+        currentSentenceIndex: 0,
+        currentNodeProgress: 0,
+        currentSentenceProgress: 0
+      },
+      segmentation,
+      body,
+      /* @__PURE__ */ new Set(),
+      [],
+      Epub.getXmlChildren(taggedBody)
+    );
+  });
+  return { markedUp: chapterXml, timing };
+}
+function markupBySegmentation(chapterId, state, segmentation, currentNode, taggedSentences, marks, taggedXml) {
+  if (Epub.isXmlTextNode(currentNode)) {
+    const remainingSentence = segmentation.sentences[state.currentSentenceIndex].text.slice(state.currentSentenceProgress);
+    const text = currentNode["#text"];
+    const remainingNodeText = text.slice(state.currentNodeProgress);
+    const index = remainingNodeText.indexOf(remainingSentence[0]);
+    if (index === -1) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText,
+        marks,
+        taggedSentences
+      );
+      return {
+        ...state,
+        currentNodeProgress: -1
+      };
+    }
+    if (remainingNodeText.slice(index).length < remainingSentence.length) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(0, index),
+        marks,
+        taggedSentences
+      );
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(index),
+        marks,
+        taggedSentences,
+        state.currentSentenceIndex
+      );
+      return {
+        ...state,
+        currentSentenceProgress: state.currentSentenceProgress + remainingNodeText.length - index,
+        currentNodeProgress: -1
+      };
+    }
+    appendTextNode(
+      chapterId,
+      taggedXml,
+      remainingNodeText.slice(0, index),
+      marks,
+      taggedSentences
+    );
+    appendTextNode(
+      chapterId,
+      taggedXml,
+      remainingSentence,
+      marks,
+      taggedSentences,
+      state.currentSentenceIndex
+    );
+    if (state.currentSentenceIndex + 1 === segmentation.sentences.length) {
+      appendTextNode(
+        chapterId,
+        taggedXml,
+        remainingNodeText.slice(index + remainingSentence.length),
+        marks,
+        taggedSentences
+      );
+    }
+    return {
+      currentSentenceIndex: state.currentSentenceIndex + 1,
+      currentSentenceProgress: 0,
+      currentNodeProgress: state.currentNodeProgress + remainingSentence.length + index
+    };
+  }
+  let nextState = {
+    ...state
+  };
+  const children = Epub.getXmlChildren(currentNode);
+  for (const child of children) {
+    if (nextState.currentSentenceIndex > segmentation.sentences.length + 1) {
+      taggedXml.push(child);
+      continue;
+    }
+    nextState.currentNodeProgress = 0;
+    let nextTaggedXml = taggedXml;
+    const nextMarks = [...marks];
+    if (!Epub.isXmlTextNode(child)) {
+      const childTagName = Epub.getXmlElementName(child);
+      const isTextContent = BLOCKS.includes(childTagName.toLowerCase());
+      if (Epub.getXmlChildren(child).length === 0) {
+        appendLeafNode(
+          chapterId,
+          taggedXml,
+          child,
+          nextMarks,
+          taggedSentences,
+          isTextContent || nextState.currentSentenceProgress === 0 ? void 0 : nextState.currentSentenceIndex
+        );
+        continue;
+      }
+      if (isTextContent) {
+        const block = {
+          [childTagName]: [],
+          ...child[":@"] && { ":@": child[":@"] }
+        };
+        nextTaggedXml.push(block);
+        nextTaggedXml = Epub.getXmlChildren(block);
+      } else {
+        nextMarks.push({
+          elementName: childTagName,
+          attributes: child[":@"]
+        });
+      }
+    }
+    while (nextState.currentSentenceIndex < segmentation.sentences.length && nextState.currentNodeProgress !== -1) {
+      nextState = markupBySegmentation(
+        chapterId,
+        nextState,
+        segmentation,
+        child,
+        taggedSentences,
+        nextMarks,
+        nextTaggedXml
+      );
+    }
+  }
+  nextState.currentNodeProgress = -1;
+  return nextState;
+}
+function appendTextNode(chapterId, xml, text, marks, taggedSentences, sentenceId) {
+  if (text.length === 0) return;
+  const textNode = { "#text": text };
+  appendLeafNode(chapterId, xml, textNode, marks, taggedSentences, sentenceId);
+}
+function appendLeafNode(chapterId, xml, node, marks, taggedSentences, sentenceId) {
+  var _a, _b;
+  const tagId = `${chapterId}-s${sentenceId}`;
+  const markedNode = [...marks].reverse().reduce(
+    (acc, mark) => ({
+      [mark.elementName]: [acc],
+      ":@": mark.attributes
+    }),
+    node
+  );
+  const lastNode = xml[xml.length - 1];
+  if (lastNode && !Epub.isXmlTextNode(lastNode) && ((_a = lastNode[":@"]) == null ? void 0 : _a["@_id"]) && lastNode[":@"]["@_id"] === tagId) {
+    const tagName = Epub.getXmlElementName(lastNode);
+    (_b = lastNode[tagName]) == null ? void 0 : _b.push(markedNode);
+    return;
+  }
+  if (sentenceId === void 0 || taggedSentences.has(sentenceId)) {
+    xml.push(markedNode);
+    return;
+  }
+  const taggedNode = {
+    span: [markedNode],
+    ":@": { "@_id": tagId }
+  };
+  taggedSentences.add(sentenceId);
+  xml.push(taggedNode);
+}
+function clearBodyElement(xml) {
+  const html = Epub.findXmlChildByName("html", xml);
+  if (!html) throw new Error("Invalid XHTML: Found no html element");
+  const bodyIndex = html["html"].findIndex((element) => "body" in element);
+  const body = html["html"][bodyIndex];
+  if (!body) throw new Error("Invalid XHTML: Found no body element");
+  html["html"].splice(bodyIndex, 1, {
+    ...body,
+    body: []
+  });
+}
+export {
+  appendTextNode,
+  markup,
+  markupChapter
+};

package/dist/markup/parse.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  markupCommand: () => markupCommand
+});
+module.exports = __toCommonJS(parse_exports);
+var import_core = require("@optique/core");
+var import_valueparser = require("@optique/run/valueparser");
+var import_parse = require("../common/parse.cjs");
+const markupCommand = (0, import_core.command)(
+  "markup",
+  (0, import_core.merge)(
+    (0, import_core.object)({
+      action: (0, import_core.constant)("markup"),
+      input: (0, import_core.argument)(
+        (0, import_valueparser.path)({
+          mustExist: true,
+          type: "file",
+          extensions: [".epub"],
+          metavar: "INPUT_PATH"
+        })
+      ),
+      output: (0, import_core.argument)(
+        (0, import_valueparser.path)({ type: "file", extensions: [".epub"], metavar: "OUTPUT_PATH" })
+      )
+    }),
+    import_parse.granularityParser,
+    import_parse.languageParser,
+    import_parse.loggingParser
+  ),
+  {
+    description: import_core.message`Mark up an EPUB file at the provided granularity level`
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  markupCommand
+});

package/dist/markup/parse.d.cts

@@ -0,0 +1,17 @@
+import * as _optique_core from '@optique/core';
+
+declare const markupCommand: _optique_core.Parser<"sync", {
+    readonly action: "markup";
+    readonly input: string;
+    readonly output: string;
+} & {
+    readonly granularity: "word" | "sentence";
+} & {
+    readonly language: Intl.Locale | undefined;
+} & {
+    readonly noProgress: boolean;
+    readonly logLevel: "silent" | "debug" | "info" | "warn" | "error";
+    readonly time: boolean;
+}, ["matched", string] | ["parsing", Record<string | symbol, unknown>] | undefined>;
+
+export { markupCommand };