@muhammara/native-core 7.0.0-alpha.1 → 7.0.0-beta.1

package/index.js

@@ -23,6 +23,51 @@ exports.createMuhammara = function createMuhammara(muhammara) {
     eventParams.writer = this;
     this.getEvents().emit(eventName, eventParams);
   };
+  muhammara.PDFWriter.prototype.replaceObject = function (
+    pageIndex,
+    sourceObjectId,
+    replacementObjectId,
+    options,
+  ) {
+    if (options && options.scope === "global") {
+      var copyingContext = this.createPDFCopyingContextForModifiedFile();
+      var pageCount = copyingContext.getSourceDocumentParser().getPagesCount();
+
+      copyingContext.end();
+      for (var index = 0; index < pageCount; ++index) {
+        this.replaceObject(index, sourceObjectId, replacementObjectId);
+      }
+      return this;
+    }
+
+    var copyingContext = this.createPDFCopyingContextForModifiedFile();
+    var parser = copyingContext.getSourceDocumentParser();
+    var pageObjectId = parser.getPageObjectID(pageIndex);
+    var pageObject = parser.parsePage(pageIndex).getDictionary().toJSObject();
+    var objectsContext = this.getObjectsContext();
+    var pageDictionary;
+
+    objectsContext.startModifiedIndirectObject(pageObjectId);
+    pageDictionary = objectsContext.startDictionary();
+
+    Object.getOwnPropertyNames(pageObject).forEach(function (key) {
+      var value = pageObject[key];
+
+      pageDictionary.writeKey(key);
+      if (
+        value.getType() === muhammara.ePDFObjectIndirectObjectReference &&
+        value.toPDFIndirectObjectReference().getObjectID() === sourceObjectId
+      ) {
+        pageDictionary.writeObjectReferenceValue(replacementObjectId);
+      } else {
+        copyingContext.copyDirectObjectAsIs(value);
+      }
+    });
+
+    objectsContext.endDictionary(pageDictionary).endIndirectObject();
+    copyingContext.end();
+    return this;
+  };
   muhammara.PDFStreamForResponse = require("./lib/PDFStreamForResponse");
   muhammara.PDFWStreamForFile = require("./lib/PDFWStreamForFile");
   muhammara.PDFRStreamForFile = require("./lib/PDFRStreamForFile");

package/lib/Recipe.js

@@ -11,7 +11,7 @@ const streams = require("memory-streams");
  * @param {string|Buffer} src - The file path or Buffer of the source file.
  * @param {string} [output] - The path of the output file uses src if its not a buffer.
  * @param {Object} [options] - The options for pdfDoc
- * @param {number} [options.version] - The pdf version
+ * @param {number} [options.version] - The pdf version: 1.0 through 1.7 or 2.0, defaults to 1.7
  * @param {string} [options.author] - The author
  * @param {string} [options.title] - The title
  * @param {string} [options.subject] - The subject
@@ -121,7 +121,7 @@ class Recipe {
   }
 
   _getVersion(version) {
-    const supportedVersions = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7];
+    const supportedVersions = [1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 2.0];
     if (!supportedVersions.includes(version)) {
       version = 1.7;
     }
@@ -149,12 +149,14 @@ class Recipe {
    */
   read(inSrc) {
     const isForExternal = inSrc ? true : false;
+    let pdfReader = null;
+    let isAdopted = false;
     try {
       let src = isForExternal ? inSrc : this.src;
       if (this.isBufferSrc) {
         src = new muhammara.PDFRStreamForBuffer(this.src);
       }
-      const pdfReader = muhammara.createReader(src, this.encryptOptions);
+      pdfReader = muhammara.createReader(src, this.encryptOptions);
       const pages = pdfReader.getPagesCount();
       if (pages == 0) {
         // broken or modify password protected
@@ -206,13 +208,50 @@ class Recipe {
         metadata[page.pageNumber] = page;
       }
       if (!isForExternal) {
+        this._releaseReader();
         this.pdfReader = pdfReader;
         this.metadata = metadata;
+        isAdopted = true;
       }
       return metadata;
     } catch (err) {
       throw new Error(err);
+    } finally {
+      // Only the recipe source reader outlives read(); anything else would keep
+      // the file open until the process exits.
+      if (pdfReader && !isAdopted) {
+        pdfReader.end();
+      }
+    }
+  }
+
+  /**
+   * Release the source reader and the file handle it holds.
+   * @private
+   * @returns {void}
+   */
+  _releaseReader() {
+    const pdfReader = this.pdfReader;
+    if (!pdfReader) {
+      return;
     }
+    this.pdfReader = null;
+    pdfReader.end();
+  }
+
+  /**
+   * Get the source reader, which endPDF() releases.
+   * @private
+   * @returns {Object} The source PDF reader.
+   * @throws {Error} If the reader was already released by endPDF().
+   */
+  _getReader() {
+    if (!this.pdfReader) {
+      throw new Error(
+        "The source PDF reader has been released by endPDF(). Read the source before ending the document.",
+      );
+    }
+    return this.pdfReader;
   }
 
   /**
@@ -256,6 +295,12 @@ class Recipe {
       this._writeInfo();
       this.writer.end();
     }
+
+    // Every step above may still read the source; _insertPages() and _encrypt()
+    // below rename the output, which is the source itself when no separate
+    // output was given, and Windows refuses that while the reader holds it.
+    this._releaseReader();
+
     if (this.needToInsertPages) {
       if (this.isBufferSrc) {
         // eslint-disable-next-line no-console

package/lib/recipe/appendPage.js

@@ -1,5 +1,5 @@
 const muhammara = require("../muhammara");
-const hummusUtils = require("./utils");
+const utils = require("./utils");
 
 /**
  * Append pages from the other pdf to the current pdf
@@ -16,10 +16,19 @@ exports.appendPage = function appendPage(pdfSrc, pages = []) {
   }
   // Using stream so it can be closed to release reader resource (Issue #61)
   const instream = new muhammara.PDFRStreamForFile(pdfSrc);
-  const pdfReader = muhammara.createReader(instream);
-  const pageCount = pdfReader.getPagesCount();
-  pdfReader.end();
-  instream.close();
+  let pageCount;
+  try {
+    const pdfReader = muhammara.createReader(instream);
+    try {
+      pageCount = pdfReader.getPagesCount();
+    } finally {
+      pdfReader.end();
+    }
+  } finally {
+    // An unreadable source must not leave the file open, which would keep it
+    // locked on Windows for the life of the process.
+    instream.close();
+  }
 
   // prevent unmatched pagenumber
   const transformPageNumber = (pageNum) => {
@@ -35,11 +44,11 @@ exports.appendPage = function appendPage(pdfSrc, pages = []) {
     }
   });
   if (pages.length > 0) {
-    hummusUtils.appendPDFPagesFromPDFWithAnnotations(this.writer, pdfSrc, {
+    utils.appendPDFPagesFromPDFWithAnnotations(this.writer, pdfSrc, {
       specificRanges: pages,
     });
   } else {
-    hummusUtils.appendPDFPagesFromPDFWithAnnotations(this.writer, pdfSrc);
+    utils.appendPDFPagesFromPDFWithAnnotations(this.writer, pdfSrc);
   }
   return this;
 };

package/lib/recipe/info.js

@@ -33,60 +33,63 @@ exports._readInfo = function _readInfo() {
       ? new muhammara.PDFRStreamForBuffer(this.src)
       : this.src;
     const copyCtx = this.writer.createPDFCopyingContext(copyFrom);
-    const infoDict = copyCtx
-      .getSourceDocumentParser()
-      .queryDictionaryObject(
-        copyCtx.getSourceDocumentParser().getTrailer(),
-        "Info",
-      );
+    try {
+      const infoDict = copyCtx
+        .getSourceDocumentParser()
+        .queryDictionaryObject(
+          copyCtx.getSourceDocumentParser().getTrailer(),
+          "Info",
+        );
 
-    const oldInfo =
-      infoDict && infoDict.toJSObject ? infoDict.toJSObject() : null;
+      const oldInfo =
+        infoDict && infoDict.toJSObject ? infoDict.toJSObject() : null;
 
-    if (oldInfo) {
-      this.infoDictionary = {};
-      Object.getOwnPropertyNames(oldInfo).forEach((key) => {
-        if (!oldInfo[key]) {
-          return;
-        }
-        const oldInforSrc = this._parseObjectByType(oldInfo[key]);
-        if (!oldInforSrc) {
-          return;
-        }
-        switch (key) {
-          case "Trapped":
-            if (oldInforSrc && oldInforSrc.value) {
-              this.infoDictionary.trapped = oldInforSrc.value;
-            }
-            break;
-          case "CreationDate":
-            if (oldInforSrc && oldInforSrc.value) {
-              this.infoDictionary.creationDate = oldInforSrc.value;
-            }
-            break;
-          case "ModDate":
-            if (oldInforSrc && oldInforSrc.value) {
-              this.infoDictionary.modDate = oldInforSrc.value;
-            }
-            break;
-          case "Creator":
-            if (oldInforSrc && oldInforSrc.toText) {
-              this.infoDictionary.creator = oldInforSrc.toText();
-            }
-            break;
-          case "Producer":
-            if (oldInforSrc && oldInforSrc.toText) {
-              this.infoDictionary.producer = oldInforSrc.toText();
-            }
-            break;
-          default:
-            if (oldInforSrc && oldInforSrc.toText) {
-              this.infoDictionary[key.toLowerCase()] = oldInforSrc.toText();
-            }
-        }
-      });
+      if (oldInfo) {
+        this.infoDictionary = {};
+        Object.getOwnPropertyNames(oldInfo).forEach((key) => {
+          if (!oldInfo[key]) {
+            return;
+          }
+          const oldInforSrc = this._parseObjectByType(oldInfo[key]);
+          if (!oldInforSrc) {
+            return;
+          }
+          switch (key) {
+            case "Trapped":
+              if (oldInforSrc && oldInforSrc.value) {
+                this.infoDictionary.trapped = oldInforSrc.value;
+              }
+              break;
+            case "CreationDate":
+              if (oldInforSrc && oldInforSrc.value) {
+                this.infoDictionary.creationDate = oldInforSrc.value;
+              }
+              break;
+            case "ModDate":
+              if (oldInforSrc && oldInforSrc.value) {
+                this.infoDictionary.modDate = oldInforSrc.value;
+              }
+              break;
+            case "Creator":
+              if (oldInforSrc && oldInforSrc.toText) {
+                this.infoDictionary.creator = oldInforSrc.toText();
+              }
+              break;
+            case "Producer":
+              if (oldInforSrc && oldInforSrc.toText) {
+                this.infoDictionary.producer = oldInforSrc.toText();
+              }
+              break;
+            default:
+              if (oldInforSrc && oldInforSrc.toText) {
+                this.infoDictionary[key.toLowerCase()] = oldInforSrc.toText();
+              }
+          }
+        });
+      }
+    } finally {
+      copyCtx.end();
     }
-    copyCtx.end();
   }
 
   return this.infoDictionary;
@@ -168,7 +171,7 @@ exports._writeInfo = function _writeInfo() {
   infoDictionary.producer =
     "MuhammaraJS (https://github.com/julianhille/MuhammaraJS)";
   infoDictionary.creator =
-    "Hummus-Recipe (https://github.com/chunyenHuang/hummusRecipe)";
+    "Muhammara-Recipe (https://github.com/julianhille/MuhammaraJS)";
 
   fields.forEach((item) => {
     let value = options[item.key];
@@ -225,7 +228,7 @@ exports.structure = function structure(output) {
   // const outputFileType = path.extname(output);
   const outputFile = fs.openSync(output, "w");
   const muhammara = this.muhammara;
-  const pdfReader = this.pdfReader;
+  const pdfReader = this._getReader();
 
   const tabWidth = "  ";
   const structures = [
@@ -331,7 +334,7 @@ exports._parseObjectByType = function _parseObjectByType(inObject) {
     return;
   }
   const muhammara = this.muhammara;
-  const pdfReader = this.pdfReader;
+  const pdfReader = this._getReader();
   const type = inObject.getType();
   const label = muhammara.getTypeLabel(type);
   const saveToObject = this.pdfStructure || {};

package/lib/recipe/insertPage.js

@@ -1,6 +1,6 @@
 const muhammara = require("../muhammara");
 const fs = require("fs");
-const hummusUtils = require("./utils");
+const utils = require("./utils");
 /**
  * Insert a page from the other pdf
  * @name insertPage
@@ -53,7 +53,7 @@ exports._insertPages = function _insertPages() {
     const toAppendPage = pageNumber - 1;
     if (toAppendPage >= 0) {
       const specificRanges = [[lastInsertedOriginal, toAppendPage]];
-      hummusUtils.appendPDFPagesFromPDFWithAnnotations(pdfWriter, tmp, {
+      utils.appendPDFPagesFromPDFWithAnnotations(pdfWriter, tmp, {
         specificRanges,
       });
     }
@@ -65,11 +65,9 @@ exports._insertPages = function _insertPages() {
         const specificRanges = [
           [info.srcPageNumber - 1, info.srcPageNumber - 1],
         ];
-        hummusUtils.appendPDFPagesFromPDFWithAnnotations(
-          pdfWriter,
-          info.pdfSrc,
-          { specificRanges },
-        );
+        utils.appendPDFPagesFromPDFWithAnnotations(pdfWriter, info.pdfSrc, {
+          specificRanges,
+        });
       });
     }
   });

package/lib/recipe/replaceText.js

@@ -0,0 +1,64 @@
+function escapePDFLiteralString(value) {
+  return value.replace(/([\\()])/g, "\\$1");
+}
+
+/**
+ * Replace literal text-showing operands in a page's single content stream.
+ *
+ * @name replaceText
+ * @function
+ * @memberof Recipe#
+ * @param {string} text Text to replace.
+ * @param {string} replacement Replacement text.
+ * @param {number} [pageNumber=1] One-based page number.
+ */
+exports.replaceText = function replaceText(text, replacement, pageNumber) {
+  pageNumber = pageNumber || 1;
+
+  if (typeof text !== "string" || typeof replacement !== "string") {
+    throw new TypeError("replaceText expects text and replacement strings");
+  }
+
+  var pageIndex = pageNumber - 1;
+  var page = this.pdfReader.parsePage(pageIndex).getDictionary();
+  var contents = page.queryObject("Contents");
+
+  if (
+    !contents ||
+    contents.getType() !== this.muhammara.ePDFObjectIndirectObjectReference
+  ) {
+    throw new Error("replaceText supports pages with one content stream");
+  }
+
+  var contentsObjectId = contents.toPDFIndirectObjectReference().getObjectID();
+  var stream = this.pdfReader.parseNewObject(contentsObjectId).toPDFStream();
+  var streamReader = this.pdfReader.startReadingFromStream(stream);
+  var chunks = [];
+
+  while (streamReader.notEnded()) {
+    chunks.push(Buffer.from(streamReader.read(65536)));
+  }
+
+  var source = Buffer.concat(chunks).toString("latin1");
+  var textPattern = new RegExp(
+    "\\(" + escapePDFLiteralString(text) + "\\)(\\s+Tj\\b)",
+    "g",
+  );
+  var replaced = source.replace(
+    textPattern,
+    "(" + escapePDFLiteralString(replacement) + ")$1",
+  );
+
+  if (replaced === source) {
+    return this;
+  }
+
+  var objectsContext = this.writer.getObjectsContext();
+  var replacementObjectId = objectsContext.startNewIndirectObject();
+  var replacementStream = objectsContext.startUnfilteredPDFStream();
+
+  replacementStream.getWriteStream().write(Array.from(Buffer.from(replaced)));
+  objectsContext.endPDFStream(replacementStream).endIndirectObject();
+  this.writer.replaceObject(pageIndex, contentsObjectId, replacementObjectId);
+  return this;
+};

package/lib/recipe/split.js

@@ -1,6 +1,6 @@
 const muhammara = require("../muhammara");
 const path = require("path");
-const hummusUtils = require("./utils");
+const utils = require("./utils");
 
 /**
  * Split the pdf
@@ -16,11 +16,7 @@ exports.split = function split(outputDir = "", prefix) {
   for (let i = 0; i < this.metadata.pages; i++) {
     const newPdf = path.join(outputDir, `${prefix}-${i + 1}.pdf`);
     const pdfWriter = muhammara.createWriter(newPdf);
-    hummusUtils.appendPDFPageFromPDFWithAnnotations(
-      pdfWriter,
-      this.pdfReader,
-      i,
-    );
+    utils.appendPDFPageFromPDFWithAnnotations(pdfWriter, this._getReader(), i);
     pdfWriter.end();
   }
   return this;

package/lib/recipe/utils.js

@@ -14,28 +14,30 @@ function appendPDFPageFromPDFWithAnnotations(
   pageNumber,
 ) {
   const cpyCxt = pdfWriter.createPDFCopyingContext(sourcePDFPath);
-  const cpyCxtParser = cpyCxt.getSourceDocumentParser();
-  const pageDictionary = cpyCxtParser.parsePageDictionary(pageNumber);
+  try {
+    const cpyCxtParser = cpyCxt.getSourceDocumentParser();
+    const pageDictionary = cpyCxtParser.parsePageDictionary(pageNumber);
 
-  if (!pageDictionary.exists(ANNOTATION_PREFIX)) {
-    cpyCxt.appendPDFPageFromPDF(pageNumber);
-  } else {
-    let reffedObjects;
-    pdfWriter.getEvents().once("OnPageWrite", (params) => {
-      params.pageDictionaryContext.writeKey(ANNOTATION_PREFIX);
-      reffedObjects = cpyCxt.copyDirectObjectWithDeepCopy(
-        pageDictionary.queryObject(ANNOTATION_PREFIX),
-      );
-    });
+    if (!pageDictionary.exists(ANNOTATION_PREFIX)) {
+      cpyCxt.appendPDFPageFromPDF(pageNumber);
+    } else {
+      let reffedObjects;
+      pdfWriter.getEvents().once("OnPageWrite", (params) => {
+        params.pageDictionaryContext.writeKey(ANNOTATION_PREFIX);
+        reffedObjects = cpyCxt.copyDirectObjectWithDeepCopy(
+          pageDictionary.queryObject(ANNOTATION_PREFIX),
+        );
+      });
 
-    cpyCxt.appendPDFPageFromPDF(pageNumber);
+      cpyCxt.appendPDFPageFromPDF(pageNumber);
 
-    if (reffedObjects && reffedObjects.length > 0) {
-      cpyCxt.copyNewObjectsForDirectObject(reffedObjects);
+      if (reffedObjects && reffedObjects.length > 0) {
+        cpyCxt.copyNewObjectsForDirectObject(reffedObjects);
+      }
     }
+  } finally {
+    cpyCxt.end();
   }
-
-  cpyCxt.end();
 }
 
 /**
@@ -51,21 +53,23 @@ function appendPDFPagesFromPDFWithAnnotations(
   options = {},
 ) {
   const cpyCxt = pdfWriter.createPDFCopyingContext(sourcePDFPath);
-  const cpyCxtParser = cpyCxt.getSourceDocumentParser();
+  try {
+    const cpyCxtParser = cpyCxt.getSourceDocumentParser();
 
-  if (options.specificRanges && options.specificRanges.length) {
-    for (const [start, end] of options.specificRanges) {
-      for (let i = start; i <= end; ++i) {
+    if (options.specificRanges && options.specificRanges.length) {
+      for (const [start, end] of options.specificRanges) {
+        for (let i = start; i <= end; ++i) {
+          appendPDFPageFromPDFWithAnnotations(pdfWriter, sourcePDFPath, i);
+        }
+      }
+    } else {
+      for (let i = 0; i < cpyCxtParser.getPagesCount(); ++i) {
         appendPDFPageFromPDFWithAnnotations(pdfWriter, sourcePDFPath, i);
       }
     }
-  } else {
-    for (let i = 0; i < cpyCxtParser.getPagesCount(); ++i) {
-      appendPDFPageFromPDFWithAnnotations(pdfWriter, sourcePDFPath, i);
-    }
+  } finally {
+    cpyCxt.end();
   }
-
-  cpyCxt.end();
 }
 
 exports.ANNOTATION_PREFIX = ANNOTATION_PREFIX;

package/muhammara.d.ts

@@ -327,6 +327,16 @@ declare namespace muhammara {
   export type PDFObjectType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
   export function getTypeLabel(type: PDFObjectType): string;
 
+  export const ePDFPageContentItemText = 0;
+  export const ePDFPageContentItemPath = 1;
+  export const ePDFPageContentItemXObject = 2;
+  export const ePDFPageContentItemShading = 3;
+  export type PDFPageContentItemType =
+    | typeof ePDFPageContentItemText
+    | typeof ePDFPageContentItemPath
+    | typeof ePDFPageContentItemXObject
+    | typeof ePDFPageContentItemShading;
+
   export const ePDFPageBoxMediaBox = 0;
   export const ePDFPageBoxCropBox = 1;
   export const ePDFPageBoxBleedBox = 2;
@@ -400,6 +410,28 @@ declare namespace muhammara {
     textMatrix: [number, number, number, number, number, number];
   }
 
+  /** A content-stream operation that produces a page mark. */
+  export interface PDFPageContentItem {
+    type: PDFPageContentItemType;
+    operation: string;
+  }
+
+  /**
+   * Per-call extraction budget. Every field is clamped to a built-in ceiling,
+   * so a caller may tighten a limit but never raise it above the default.
+   * Omitted fields keep the ceiling.
+   */
+  export interface PDFExtractionLimits {
+    /** Extracted elements or items. Default and ceiling: 100000. */
+    maxElements?: number;
+    /** Pending operands per operator. Default and ceiling: 1024. */
+    maxOperands?: number;
+    /** Total extracted text. Default and ceiling: 16777216 (16 MiB). */
+    maxTextBytes?: number;
+    /** Content-stream objects parsed. Default and ceiling: 1000000. */
+    maxParsedObjects?: number;
+  }
+
   export interface RectangleDimension {
     width: Width;
     height: Height;
@@ -444,15 +476,33 @@ declare namespace muhammara {
     ): undefined | PDFObject;
     parseNewObject(objectId: number): PDFObject;
     getPageObjectID(objectId: number): number;
-    parsePageDictionary(objectId: number): PDFDictionary;
-    parsePage(page: number): PDFPageInput;
+    parsePageDictionary(pageIndex: number): PDFDictionary;
+    parsePage(pageIndex: number): PDFPageInput;
     /**
      * Returns text-showing operations in PDF content-stream drawing order.
-     * Does not decode font character maps or calculate glyph bounds. For safety,
-     * extraction rejects pages with more than 1,000,000 content objects, 100,000 text
-     * operations, or 16 MiB of text.
+     * Does not decode font character maps or calculate glyph bounds.
+     *
+     * Throws when the page exceeds the extraction budget. `limits` may only
+     * tighten the defaults: higher values are clamped to the built-in ceilings
+     * of 1,000,000 content objects, 100,000 text operations, 1024 operands, and
+     * 16 MiB of text.
+     */
+    extractPageText(
+      pageIndex: number,
+      limits?: PDFExtractionLimits,
+    ): PDFTextElement[];
+    /**
+     * Returns every direct content-stream operation that produces a page mark.
+     * White-on-white content is included; non-painting operations are excluded.
+     *
+     * Shares `extractPageText`'s budget and clamping. `limits.maxTextBytes` is
+     * accepted for signature parity but has no effect here, because items carry
+     * an operator name rather than extracted text.
      */
-    extractPageText(pageIndex: number): PDFTextElement[];
+    extractPageContentItems(
+      pageIndex: number,
+      limits?: PDFExtractionLimits,
+    ): PDFPageContentItem[];
     getObjectsCount(): number;
     isEncrypted(): boolean;
     getXrefSize(): number;
@@ -747,6 +797,16 @@ declare namespace muhammara {
   export type inInterPagesCallback = () => {};
 
   export interface PDFWriter {
+    /**
+     * Replace direct references to an object in a page dictionary.
+     * Available only when modifying an existing PDF.
+     */
+    replaceObject(
+      pageIndex: number,
+      sourceObjectId: number,
+      replacementObjectId: number,
+      options?: ObjectReplacementOptions,
+    ): this;
     end(): PDFWriter;
     createPage(x: PosX, y: PosY, width: Width, height: Height): PDFPage;
     createPage(): PDFPage;
@@ -845,6 +905,10 @@ declare namespace muhammara {
     ): void;
   }
 
+  export interface ObjectReplacementOptions {
+    scope?: "global";
+  }
+
   namespace Recipe {
     type CommentOptionsFlag =
       | "invisible"
@@ -1179,6 +1243,8 @@ declare namespace muhammara {
 
     editPage(pageNumber: number): Recipe;
 
+    replaceText(text: string, replacement: string, pageNumber?: number): Recipe;
+
     pageInfo(pageNumber: number): {
       width: number;
       height: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhammara/native-core",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-beta.1",
   "description": "Shared JavaScript API for MuhammaraJS native packages",
   "homepage": "https://muhammarajs.readthedocs.io/",
   "license": "Apache-2.0",