@gmb/bitmark-parser-generator 5.14.0 → 5.16.0

package/dist/cli/main.js

@@ -1176,6 +1176,7 @@ var propertyKeys = {
   property_availableClassifications: "@availableClassifications",
   property_brandColor: "@brandColor",
   property_brandColorName: "@brandColorName",
+  property_backgroundImage: "@backgroundImage",
   property_blockId: "@blockId",
   property_book: "@book",
   property_bookAlias: "@bookAlias",
@@ -1469,7 +1470,8 @@ var resourceKeys = {
   resource_imagePlaceholder: "&imagePlaceholder",
   resource_previewImage: "&previewImage",
   resource_previewVideo: "&previewVideo",
-  resource_coverImage: "&coverImage"
+  resource_coverImage: "&coverImage",
+  resource_backgroundImage: "&backgroundImage"
 };
 
 // src/utils/StringUtils.ts
@@ -1696,7 +1698,8 @@ var ResourceType = {
   platformBackgroundImage: "platformBackgroundImage",
   previewImage: "previewImage",
   previewVideo: "previewVideo",
-  coverImage: "coverImage"
+  coverImage: "coverImage",
+  backgroundImage: "backgroundImage"
 };
 function resourceTypeToConfigKey(type) {
   return `&${stringUtils.kebabToCamel(type)}`;
@@ -3735,6 +3738,22 @@ var GROUPS = {
           }
         ]
       },
+      {
+        key: ConfigKey.property_backgroundImage,
+        description: "The background image(s) of the book",
+        format: TagFormat.plainText,
+        maxCount: Count.infinity
+      },
+      {
+        key: ConfigKey.resource_backgroundImage,
+        description: "The background image of the book",
+        chain: [
+          {
+            key: ConfigKey.group_resourceImageCommon,
+            description: "Common image properties for the background image resource"
+          }
+        ]
+      },
       {
         key: ConfigKey.property_coverColor,
         description: "The cover color of the book",
@@ -10857,7 +10876,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.14.0",
+  "version": "5.16.0",
   "license": "ISC"};
 var Environment = {
   unknown: "",
@@ -11215,6 +11234,8 @@ var NodeType = {
   avatarImage: "avatarImage",
   backgroundWallpaper: "backgroundWallpaper",
   backgroundWallpaperValue: "backgroundWallpaperValue",
+  backgroundImage: "backgroundImage",
+  backgroundImageValue: "backgroundImageValue",
   bitLevel: "bitLevel",
   // bit level
   bitmarkAst: "bitmarkAst",
@@ -23339,6 +23360,7 @@ var ResourceBuilder = class extends BaseBuilder {
       case ResourceType.platformBackgroundImage:
       case ResourceType.previewImage:
       case ResourceType.coverImage:
+      case ResourceType.backgroundImage:
         node = this.imageResource(context, finalData, type);
         break;
       // case ResourceType.imageResponsive: {
@@ -24614,6 +24636,12 @@ var Builder = class extends BaseBuilder {
         data.coverColor,
         options
       ),
+      backgroundImage: typeof data.backgroundImage === "string" || Array.isArray(data.backgroundImage) ? this.toAstProperty(
+        bitType,
+        ConfigKey.property_backgroundImage,
+        instance4.asArray(data.backgroundImage),
+        options
+      ) : this.toImageResource(context, data.backgroundImage),
       publications: this.toAstProperty(
         bitType,
         ConfigKey.property_publications,
@@ -28671,6 +28699,62 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
       ignoreTrue: propertyConfig.defaultValue === "true"
     });
   }
+  // bitmarkAst -> bits -> bitsValue -> backgroundImage (when it's a resource object or property array)
+  enter_backgroundImage(node, route) {
+    const value = node.value;
+    if (value && typeof value === "object" && !Array.isArray(value) && "type" in value) {
+      const resource = value;
+      this.writeNL();
+      this.writePropertyStyleResource(node.key, resource);
+      return true;
+    }
+    if (Array.isArray(value)) {
+      if (value == null) return true;
+      const parent = this.getParentNode(route);
+      if (parent?.key !== NodeType.bitsValue) return true;
+      const bitType = this.getBitType(route);
+      if (!bitType) return true;
+      const config = instance2.getBitConfig(bitType);
+      const propertyConfig = instance2.getTagConfigForTag(
+        config.tags,
+        ConfigKey.property_backgroundImage
+      );
+      if (!propertyConfig) return true;
+      this.writeNL_IfNotChain(route);
+      this.writeProperty(propertyConfig.tag, value, route, {
+        format: propertyConfig.format ?? TagFormat.plainText,
+        array: propertyConfig.array ?? false,
+        writeEmpty: true,
+        ignoreFalse: propertyConfig.defaultValue === "false",
+        ignoreTrue: propertyConfig.defaultValue === "true"
+      });
+    }
+    return true;
+  }
+  // bitmarkAst -> bits -> bitsValue -> backgroundImage (when it's a property string)
+  // This is called when backgroundImage is a simple string value
+  leaf_backgroundImage(node, route) {
+    const value = node.value;
+    if (value == null) return;
+    const parent = this.getParentNode(route);
+    if (parent?.key !== NodeType.bitsValue) return;
+    const bitType = this.getBitType(route);
+    if (!bitType) return;
+    const config = instance2.getBitConfig(bitType);
+    const propertyConfig = instance2.getTagConfigForTag(
+      config.tags,
+      ConfigKey.property_backgroundImage
+    );
+    if (!propertyConfig) return;
+    this.writeNL_IfNotChain(route);
+    this.writeProperty(propertyConfig.tag, node.value, route, {
+      format: propertyConfig.format ?? TagFormat.plainText,
+      array: propertyConfig.array ?? false,
+      writeEmpty: true,
+      ignoreFalse: propertyConfig.defaultValue === "false",
+      ignoreTrue: propertyConfig.defaultValue === "true"
+    });
+  }
   exit_imagePlaceholder(_node, _route) {
   }
   // bitmarkAst -> bits -> bitsValue -> posterImage
@@ -30277,6 +30361,12 @@ var JsonGenerator = class extends AstWalkerGenerator {
       array: Array.isArray(node.value)
     });
   }
+  // bitmarkAst -> bits -> bitsValue -> backgroundImage
+  enter_backgroundImage(node, route) {
+    return this.standardHandler(node, route, NodeType.bitsValue, {
+      array: Array.isArray(node.value)
+    });
+  }
   // bitmarkAst -> bits -> bitsValue -> resources
   enter_resources(node, route) {
     const resources = node.value;
@@ -34645,7 +34735,7 @@ function resourceContentProcessor(context, _contentDepth, tagsConfig, content, t
     ...tags2
   });
   if (resource) {
-    if (configKey === ConfigKey.resource_backgroundWallpaper || configKey === ConfigKey.resource_imagePlaceholder || configKey === ConfigKey.resource_platformIcon || configKey === ConfigKey.resource_platformLogo || configKey === ConfigKey.resource_platformBackgroundImage || configKey === ConfigKey.resource_previewImage || configKey === ConfigKey.resource_previewVideo || configKey === ConfigKey.resource_coverImage) {
+    if (configKey === ConfigKey.resource_backgroundWallpaper || configKey === ConfigKey.resource_imagePlaceholder || configKey === ConfigKey.resource_platformIcon || configKey === ConfigKey.resource_platformLogo || configKey === ConfigKey.resource_platformBackgroundImage || configKey === ConfigKey.resource_previewImage || configKey === ConfigKey.resource_previewVideo || configKey === ConfigKey.resource_coverImage || configKey === ConfigKey.resource_backgroundImage) {
       if (target.propertyStyleResources) {
         if (target.propertyStyleResources[resourceType]) {
           if (!Array.isArray(target.propertyStyleResources[resourceType])) {
@@ -39204,6 +39294,265 @@ var JsonFileGenerator = class {
     this.generator.generateSync(_ast);
   }
 };
+
+// src/generator/plainText/PlainTextGenerator.ts
+var TEXT_NODE_TYPES = new Set(Object.values(TextNodeType));
+var PlainTextGenerator = class {
+  /**
+   * Generate plain text from a string or JSON object.
+   *
+   * @param input - A string (plain or JSON-encoded) or a parsed JSON value.
+   * @returns The extracted plain text.
+   */
+  generate(input) {
+    let data = input;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data);
+      } catch (_e) {
+        return data;
+      }
+    }
+    return this.walk(data).trim();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  walk(value) {
+    if (value == null) return "";
+    if (typeof value === "string") return value;
+    if (typeof value !== "object") return "";
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "";
+      if (this.isTextAst(value)) {
+        return this.textAstToPlainText(value);
+      }
+      return value.map((v) => this.walk(v)).filter(Boolean).join("\n");
+    }
+    const obj = value;
+    if (this.isTextNode(obj)) {
+      return this.textNodeToPlainText(obj);
+    }
+    if (this.isBitWrapper(obj)) {
+      return this.walk(obj["bit"]);
+    }
+    const parts = [];
+    for (const val of Object.values(obj)) {
+      if (val == null || typeof val !== "object") continue;
+      const text = this.walk(val);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  // -- Type guards -----------------------------------------------------------
+  isTextNode(obj) {
+    return typeof obj["type"] === "string" && TEXT_NODE_TYPES.has(obj["type"]);
+  }
+  isTextAst(arr) {
+    const first = arr[0];
+    return typeof first === "object" && first !== null && !Array.isArray(first) && this.isTextNode(first);
+  }
+  isBitWrapper(obj) {
+    return "bit" in obj && typeof obj["bit"] === "object" && obj["bit"] !== null && !Array.isArray(obj["bit"]);
+  }
+  // -- TextNode extraction ---------------------------------------------------
+  textAstToPlainText(ast) {
+    return ast.map((node) => this.textNodeToPlainText(node)).join("\n");
+  }
+  textNodeToPlainText(node) {
+    const { type, text, content } = node;
+    switch (type) {
+      case TextNodeType.text:
+        return this.textWithMarks(node);
+      case TextNodeType.hardBreak:
+        return "\n";
+      // Block elements whose children are joined without extra separator
+      case TextNodeType.paragraph:
+      case TextNodeType.heading:
+      case TextNodeType.section:
+      case TextNodeType.gap:
+      case TextNodeType.select:
+      case TextNodeType.highlight:
+      case TextNodeType.mark:
+      case TextNodeType.codeBlock:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+      // List items are handled by listToPlainText with indent context
+      case TextNodeType.listItem:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+      // Task item – handled by taskListToPlainText, but fallback if encountered standalone
+      case TextNodeType.taskItem: {
+        const checked = node.attrs?.checked ?? false;
+        const prefix = checked ? "[x] " : "[ ] ";
+        const itemText = content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+        return `${prefix}${itemText}`;
+      }
+      // List containers – rendered with indent-aware helper
+      case TextNodeType.noBulletList:
+      case TextNodeType.bulletList:
+      case TextNodeType.orderedList:
+      case TextNodeType.orderedListRoman:
+      case TextNodeType.orderedListRomanLower:
+      case TextNodeType.letteredList:
+      case TextNodeType.letteredListLower:
+        return this.listToPlainText(node, 0);
+      // Task list – rendered with indent-aware helper
+      case TextNodeType.taskList:
+        return this.taskListToPlainText(node, 0);
+      // Images – return alt text when available
+      case TextNodeType.image:
+      case TextNodeType.imageInline: {
+        const attrs = node.attrs;
+        return attrs?.alt ?? "";
+      }
+      // LaTeX – return the formula source
+      case TextNodeType.latex: {
+        const latexAttrs = node.attrs;
+        return latexAttrs?.formula ?? "";
+      }
+      default:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+    }
+  }
+  listToPlainText(node, depth) {
+    const { type, content } = node;
+    if (!content || content.length === 0) return "";
+    const indent = "  ".repeat(depth);
+    const start = node.attrs?.start ?? 1;
+    const displayStart = start < 1 ? start + 1 : start;
+    return content.map((child, i) => {
+      const { inline, nested } = this.splitListItemContent(child, depth);
+      const prefix = this.listItemPrefix(type, displayStart + i);
+      const line = `${indent}${prefix}${inline}`;
+      return nested ? `${line}
+${nested}` : line;
+    }).join("\n");
+  }
+  taskListToPlainText(node, depth) {
+    const { content } = node;
+    if (!content || content.length === 0) return "";
+    const indent = "  ".repeat(depth);
+    return content.map((child) => {
+      const checked = child.attrs?.checked ?? false;
+      const prefix = checked ? "[x] " : "[ ] ";
+      const { inline, nested } = this.splitListItemContent(child, depth);
+      const line = `${indent}${prefix}${inline}`;
+      return nested ? `${line}
+${nested}` : line;
+    }).join("\n");
+  }
+  splitListItemContent(item, depth) {
+    const children = item.content ?? [];
+    const inlineParts = [];
+    const nestedParts = [];
+    for (const child of children) {
+      if (this.isListType(child.type)) {
+        nestedParts.push(this.renderNestedList(child, depth + 1));
+      } else {
+        inlineParts.push(this.textNodeToPlainText(child));
+      }
+    }
+    return {
+      inline: inlineParts.join(""),
+      nested: nestedParts.join("\n")
+    };
+  }
+  isListType(type) {
+    return type === TextNodeType.bulletList || type === TextNodeType.orderedList || type === TextNodeType.orderedListRoman || type === TextNodeType.orderedListRomanLower || type === TextNodeType.letteredList || type === TextNodeType.letteredListLower || type === TextNodeType.noBulletList || type === TextNodeType.taskList;
+  }
+  renderNestedList(node, depth) {
+    if (node.type === TextNodeType.taskList) {
+      return this.taskListToPlainText(node, depth);
+    }
+    return this.listToPlainText(node, depth);
+  }
+  listItemPrefix(listType, index) {
+    switch (listType) {
+      case TextNodeType.bulletList:
+        return "\u2022 ";
+      case TextNodeType.orderedList:
+        return `${index}. `;
+      case TextNodeType.orderedListRoman:
+        return `${this.toRoman(index)}. `;
+      case TextNodeType.orderedListRomanLower:
+        return `${this.toRoman(index).toLowerCase()}. `;
+      case TextNodeType.letteredList:
+        return `${this.toLetter(index)}. `;
+      case TextNodeType.letteredListLower:
+        return `${this.toLetter(index).toLowerCase()}. `;
+      case TextNodeType.noBulletList:
+      default:
+        return "";
+    }
+  }
+  toRoman(num) {
+    const romanNumerals = [
+      [1e3, "M"],
+      [900, "CM"],
+      [500, "D"],
+      [400, "CD"],
+      [100, "C"],
+      [90, "XC"],
+      [50, "L"],
+      [40, "XL"],
+      [10, "X"],
+      [9, "IX"],
+      [5, "V"],
+      [4, "IV"],
+      [1, "I"]
+    ];
+    let result = "";
+    let remaining = num;
+    for (const [value, numeral] of romanNumerals) {
+      while (remaining >= value) {
+        result += numeral;
+        remaining -= value;
+      }
+    }
+    return result;
+  }
+  toLetter(num) {
+    let result = "";
+    let remaining = num;
+    while (remaining > 0) {
+      remaining--;
+      result = String.fromCharCode(65 + remaining % 26) + result;
+      remaining = Math.floor(remaining / 26);
+    }
+    return result;
+  }
+  textWithMarks(node) {
+    const { text, marks } = node;
+    const parts = [];
+    const linkMark = marks?.find((m) => m.type === "link");
+    const href = linkMark?.attrs?.href;
+    if (text && href && text !== href) {
+      const hrefBare = href.replace(/^https?:\/\//, "");
+      if (text.includes(hrefBare)) {
+        parts.push(text.replace(hrefBare, href));
+      } else if (text.includes(href)) {
+        parts.push(text);
+      } else {
+        parts.push(`${text} ${href}`);
+      }
+    } else if (text) {
+      parts.push(text);
+    } else if (href) {
+      parts.push(href);
+    }
+    if (marks) {
+      for (const mark of marks) {
+        if (mark.type === "footnote") {
+          const footnote = mark;
+          if (footnote.attrs?.content) {
+            const footnoteText = footnote.attrs.content.map((c) => this.textNodeToPlainText(c)).join("");
+            if (footnoteText) parts.push(footnoteText);
+          }
+        }
+      }
+    }
+    return parts.join(" ");
+  }
+};
 var normalizeCardKey = (cardSetKey) => stringUtils.camelToKebab(cardSetKey);
 var ConfigBuilder = class {
   build(options) {
@@ -39905,7 +40254,25 @@ var Output = {
   /**
    * Output AST as a plain JS object, or a file
    */
-  ast: "ast"
+  ast: "ast",
+  /**
+   * Output plain text as a string, or a file
+   */
+  text: "text"
+};
+var InputFormat = {
+  /**
+   * Input is bitmark
+   */
+  bitmark: "bitmark",
+  /**
+   * Input is bitmarkText
+   */
+  bitmarkText: "bitmarkText",
+  /**
+   * Input is plain text
+   */
+  plainText: "plainText"
 };
 var BitmarkParserGenerator = class {
   ast = new Ast();
@@ -39989,6 +40356,12 @@ var BitmarkParserGenerator = class {
    * - input(JSON/AST) ==> output(bitmark)
    * - input(bitmark)  ==> output(JSON)
    *
+   * Output type can be overridden to one of the following:
+   * - bitmark: output bitmark string
+   * - json: output JSON as a plain JS object, or a file
+   * - ast: output AST as a plain JS object, or a file
+   * - text: output plain text as a string, or a file
+   *
    * By default, the result is returned as a string for bitmark, or a plain JS object for JSON/AST.
    *
    * The options can be used to write the output to a file and to set conversion options or override defaults.
@@ -40011,6 +40384,7 @@ var BitmarkParserGenerator = class {
     const outputBitmark = outputFormat === Output.bitmark;
     const outputJson = outputFormat === Output.json;
     const outputAst = outputFormat === Output.ast;
+    const outputText = outputFormat === Output.text;
     const bitmarkParserType = BitmarkParserType.peggy;
     let inStr = input;
     const inputIsString = typeof input === "string";
@@ -40057,6 +40431,22 @@ var BitmarkParserGenerator = class {
         }
       }
     };
+    const bitmarkToText = (bitmarkStr) => {
+      ast = this.bitmarkParser.toAst(bitmarkStr, {
+        parserType: bitmarkParserType
+      });
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(ast);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const astToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
@@ -40079,6 +40469,19 @@ var BitmarkParserGenerator = class {
         res = this.jsonStringifyPrettify(json, jsonOptions);
       }
     };
+    const astToText = (astJson) => {
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(astJson);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const jsonToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
@@ -40091,6 +40494,19 @@ var BitmarkParserGenerator = class {
     const jsonToAst = (astJson) => {
       res = this.jsonStringifyPrettify(astJson, jsonOptions);
     };
+    const jsonToText = (astJson) => {
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(astJson);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const jsonToJson = (astJson) => {
       astToJson(astJson);
     };
@@ -40099,6 +40515,8 @@ var BitmarkParserGenerator = class {
         bitmarkToBitmark(inStr);
       } else if (outputAst) {
         bitmarkToAst(inStr);
+      } else if (outputText) {
+        bitmarkToText(inStr);
       } else {
         bitmarkToJson(inStr);
       }
@@ -40108,6 +40526,8 @@ var BitmarkParserGenerator = class {
         astToAst(ast);
       } else if (outputJson) {
         astToJson(ast);
+      } else if (outputText) {
+        astToText(ast);
       } else {
         astToBitmark(ast);
       }
@@ -40117,6 +40537,8 @@ var BitmarkParserGenerator = class {
         jsonToJson(ast);
       } else if (outputAst) {
         jsonToAst(ast);
+      } else if (outputText) {
+        jsonToText(ast);
       } else {
         jsonToBitmark(ast);
       }
@@ -40245,7 +40667,7 @@ var BitmarkParserGenerator = class {
     return res;
   }
   /**
-   * Convert bitmark text from JSON, or JSON to bitmark text.
+   * Convert bitmark text to JSON, or JSON to bitmark text.
    *
    * Input type is detected automatically and may be:
    * - string: bitmark text or JSON
@@ -40319,6 +40741,54 @@ var BitmarkParserGenerator = class {
     }
     return res;
   }
+  extractPlainText(input, options) {
+    const dataIn = input;
+    const inputFormat = options?.inputFormat;
+    const isString2 = typeof input === "string";
+    let data;
+    const parseAutomatically = () => {
+      let dataOut = dataIn;
+      if (typeof dataIn === "string") {
+        try {
+          dataOut = JSON.parse(dataIn);
+        } catch (_e) {
+          let isBitmark = false;
+          const bitmarkData = this.convert(dataIn, {
+            outputFormat: Output.json
+          });
+          if (bitmarkData.length > 0) {
+            const isError = bitmarkData[0].bit.type === BitType._error;
+            if (!isError) {
+              isBitmark = true;
+              dataOut = bitmarkData;
+            }
+          }
+          if (!isBitmark) {
+            dataOut = this.convertText(dataIn, {
+              textFormat: TextFormat.bitmarkText
+            });
+          }
+        }
+      }
+      return dataOut;
+    };
+    if (inputFormat === InputFormat.bitmark) {
+      data = this.convert(dataIn, {
+        outputFormat: Output.json
+      });
+    } else if (inputFormat === InputFormat.bitmarkText) {
+      data = this.convertText(dataIn, {
+        textFormat: TextFormat.bitmarkText
+      });
+    } else if (inputFormat === InputFormat.plainText) {
+      if (isString2) data = String(input);
+    } else {
+      data = parseAutomatically();
+    }
+    const generator = new PlainTextGenerator();
+    const res = generator.generate(data);
+    return res;
+  }
   /**
    * Breakscape bitmark text.
    *
@@ -40426,6 +40896,16 @@ var BitmarkParserGenerator = class {
     }
     return;
   }
+  textAstToPlainText(textAst, _options) {
+    const textGenerator = new TextGenerator(BitmarkVersion.v3, {
+      //
+    });
+    const res = textGenerator.generateSync(textAst, TextFormat.bitmarkText, TextLocation.body, {
+      noBreakscaping: true,
+      noMarkup: true
+    });
+    return res;
+  }
   /**
    * Stringify / prettify a plain JS object to a JSON string, depending on the JSON options
    *
@@ -40683,6 +41163,42 @@ Examples:
   );
   return cmd;
 }
+var INPUT_FORMAT_CHOICES = enumChoices(InputFormat);
+function createExtractPlainTextCommand() {
+  const bpg = new BitmarkParserGenerator();
+  const cmd = new Command("extractPlainText").description("Extract plain text from bitmark, bitmark text, or JSON").argument(
+    "[input]",
+    "file to read, or text or json string. If not specified, input will be from <stdin>"
+  ).addOption(
+    new Option(
+      "-f, --inputFormat <format>",
+      "force input format (auto-detected by default)"
+    ).choices([...INPUT_FORMAT_CHOICES])
+  ).option("-a, --append", "append to the output file (default is to overwrite)").option("-o, --output <file>", "output file. If not specified, output will be to <stdout>").action(async (input, options) => {
+    try {
+      const dataIn = await readInput(input);
+      const result = bpg.extractPlainText(dataIn, {
+        inputFormat: Enum(InputFormat).fromValue(options.inputFormat)
+      });
+      await writeOutput(result ?? "", options.output, options.append);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }).addHelpText(
+    "after",
+    `
+Examples:
+  $ bitmark-parser extractPlainText '[{"type":"paragraph","content":[{"text":"Hello World","type":"text"}],"attrs":{}}]'
+
+  $ bitmark-parser extractPlainText input.json
+
+  $ bitmark-parser extractPlainText input.json -o output.txt
+
+  $ bitmark-parser extractPlainText -f bitmark input.bitmark`
+  );
+  return cmd;
+}
 var INFO_TYPE_CHOICES = (() => {
   const choices = new Set(enumChoices(InfoType));
   const ordered = [];
@@ -40810,6 +41326,7 @@ async function asyncInit() {
   });
   program.addCommand(createConvertCommand());
   program.addCommand(createConvertTextCommand());
+  program.addCommand(createExtractPlainTextCommand());
   program.addCommand(createBreakscapeCommand());
   program.addCommand(createUnbreakscapeCommand());
   program.addCommand(createInfoCommand());