scribe.js-ocr 0.7.4 → 0.9.0

package/js/containers/fontContainer.js

@@ -5,23 +5,23 @@
 
 // Node.js case
 import opentype from '../../lib/opentype.module.js';
-import { determineSansSerif, getStyleLookup } from '../utils/miscUtils.js';
+import { determineSansSerif, getStyleLookup, clearObjectProperties } from '../utils/miscUtils.js';
 import { ca } from '../canvasAdapter.js';
 
 if (typeof process === 'object') {
   // @ts-ignore
   globalThis.self = globalThis;
   // @ts-ignore
-  const { createRequire } = await import('module');
+  const { createRequire } = await import('node:module');
   globalThis.require = createRequire(import.meta.url);
-  const { fileURLToPath } = await import('url');
-  const { dirname } = await import('path');
+  const { fileURLToPath } = await import('node:url');
+  const { dirname } = await import('node:path');
   globalThis.__dirname = dirname(fileURLToPath(import.meta.url));
 }
 
 /**
  * Checks whether `multiFontMode` should be enabled or disabled.
- * @param {Object.<string, FontMetricsFamily>} fontMetricsObj
+ * @param {Object.<string, CharMetricsFamily>} charMetricsObj
  *
  * Usually (including when the built-in OCR engine is used) we will have metrics for individual font families,
  * which are used to optimize the appropriate fonts ("multiFontMode" is `true` in this case).
@@ -29,12 +29,12 @@ if (typeof process === 'object') {
  * but no font identification information for most or all words.
  * If this is encountered the "default" metric is applied to the default font ("multiFontMode" is `false` in this case).
  */
-export function checkMultiFontMode(fontMetricsObj) {
+export function checkMultiFontMode(charMetricsObj) {
   let defaultFontObs = 0;
   let namedFontObs = 0;
-  if (fontMetricsObj.Default?.obs) { defaultFontObs += (fontMetricsObj.Default?.obs || 0); }
-  if (fontMetricsObj.SerifDefault?.obs) { namedFontObs += (fontMetricsObj.SerifDefault?.obs || 0); }
-  if (fontMetricsObj.SansDefault?.obs) { namedFontObs += (fontMetricsObj.SansDefault?.obs || 0); }
+  if (charMetricsObj.Default?.obs) { defaultFontObs += (charMetricsObj.Default?.obs || 0); }
+  if (charMetricsObj.SerifDefault?.obs) { namedFontObs += (charMetricsObj.SerifDefault?.obs || 0); }
+  if (charMetricsObj.SansDefault?.obs) { namedFontObs += (charMetricsObj.SansDefault?.obs || 0); }
 
   return namedFontObs > defaultFontObs;
 }
@@ -191,7 +191,6 @@ export async function loadFontContainerFamily(family, src, opt = false) {
   /**
    *
    * @param {StyleLookup} styleLookup
-   * @returns
    */
   const loadType = (styleLookup) => new Promise((resolve) => {
     const srcType = (src[styleLookup]);
@@ -250,33 +249,43 @@ export class FontCont {
     chi_sim: null,
   };
 
-  /** Optimized fonts will be used when believed to improve quality. */
-  static enableOpt = false;
+  /**
+   * This object contains all data that is saved and restored from intermediate .scribe files.
+   * Anything outside of this object is not saved or restored.
+   * @type {FontState}
+   */
+  static state = {
+    /** Optimized fonts will be used when believed to improve quality. */
+    enableOpt: false,
 
-  /** Optimized fonts will always be used when they exist, even if believed to reduce quality. */
-  static forceOpt = false;
+    /** Optimized fonts will always be used when they exist, even if believed to reduce quality. */
+    forceOpt: false,
 
-  /** @type {?Awaited<ReturnType<import('../fontEval.js').evaluateFonts>>} */
-  static rawMetrics = null;
+    /**
+     * If `false`, 'Courier' will not be cleaned to Nimbus Mono.
+     * This setting is useful because Tesseract sometimes misidentifies fonts as Courier, and when not the document default, Nimbus Mono is almost always incorrect.
+     * Even with this setting `false`, Nimbus Mono will still be used when the font is exactly 'NimbusMono' and Nimbus Mono can still be the document default font.
+     */
+    enableCleanToNimbusMono: false,
 
-  /** @type {?Awaited<ReturnType<import('../fontEval.js').evaluateFonts>>} */
-  static optMetrics = null;
+    defaultFontName: 'SerifDefault',
 
-  static defaultFontName = 'SerifDefault';
+    serifDefaultName: 'NimbusRoman',
 
-  static serifDefaultName = 'NimbusRoman';
+    sansDefaultName: 'NimbusSans',
 
-  static sansDefaultName = 'NimbusSans';
+    glyphSet: null,
 
-  /**
-   * If `false`, 'Courier' will not be cleaned to Nimbus Mono.
-   * This setting is useful because Tesseract sometimes misidentifies fonts as Courier, and when not the document default, Nimbus Mono is almost always incorrect.
-   * Even with this setting `false`, Nimbus Mono will still be used when the font is exactly 'NimbusMono' and Nimbus Mono can still be the document default font.
-   */
-  static enableCleanToNimbusMono = false;
+    /** @type {Object.<string, CharMetricsFamily>} */
+    charMetrics: {},
 
-  /** @type {?('latin'|'all')} */
-  static glyphSet = null;
+  };
+
+  /** @type {?Awaited<ReturnType<import('../fontEval.js').evaluateFonts>>} */
+  static rawMetrics = null;
+
+  /** @type {?Awaited<ReturnType<import('../fontEval.js').evaluateFonts>>} */
+  static optMetrics = null;
 
   /**
    * Load fonts from an ArrayBuffer containing arbitrary font data.
@@ -344,15 +353,15 @@ export class FontCont {
     const raw = FontCont.raw?.[family]?.normal;
     if (!raw) return false;
     const opt = FontCont.opt?.[family]?.normal;
-    if (opt && FontCont.forceOpt) {
+    if (opt && FontCont.state.forceOpt) {
       return true;
     // If optimized fonts are enabled (but not forced), the optimized version of a font will be used if:
     // (1) The optimized version exists
     // (2) The optimized version has a better metric (so quality should improve).
     // (3) The optimized version of the default sans/serif font also has a better metric.
     // This last condition avoids font optimization being enabled in the UI when it only improves an unused font.
-    } if (opt && FontCont.enableOpt) {
-      const defaultFamily = raw.type === 'serif' ? FontCont.serifDefaultName : FontCont.sansDefaultName;
+    } if (opt && FontCont.state.enableOpt) {
+      const defaultFamily = raw.type === 'serif' ? FontCont.state.serifDefaultName : FontCont.state.sansDefaultName;
 
       const rawMetricDefault = FontCont.rawMetrics?.[defaultFamily];
       const optMetricDefault = FontCont.optMetrics?.[defaultFamily];
@@ -375,7 +384,7 @@ export class FontCont {
    * @returns {FontContainerFont}
    */
   static getFont = (style, lang = 'eng') => {
-    let family = style.font || FontCont.defaultFontName;
+    let family = style.font || FontCont.state.defaultFontName;
 
     const styleLookup = getStyleLookup(style);
 
@@ -403,19 +412,23 @@ export class FontCont {
         family = 'NimbusSans';
       } else if (/Arial/i.test(family)) {
         family = 'NimbusSans';
-      } else if (/Century/i.test(family)) {
+      } else if (/CenturySch/i.test(family)) {
         family = 'Century';
       } else if (/Palatino/i.test(family)) {
         family = 'Palatino';
       } else if (/Garamond/i.test(family)) {
         family = 'Garamond';
+      } else if (/CenturyGothic/i.test(family)) {
+        family = 'Gothic';
+      } else if (/AvantGarde/i.test(family)) {
+        family = 'Gothic';
       } else if (/Carlito/i.test(family)) {
         family = 'Carlito';
       } else if (/Calibri/i.test(family)) {
         family = 'Carlito';
-      } else if (/Courier/i.test(family) && FontCont.enableCleanToNimbusMono) {
+      } else if (/Courier/i.test(family) && FontCont.state.enableCleanToNimbusMono) {
         family = 'NimbusMono';
-      } else if (/NimbusMono/i.test(family) && FontCont.enableCleanToNimbusMono) {
+      } else if (/NimbusMono/i.test(family) && FontCont.state.enableCleanToNimbusMono) {
         family = 'NimbusMono';
       }
     }
@@ -426,10 +439,10 @@ export class FontCont {
     }
 
     // This needs to come first as `defaultFontName` maps to either 'SerifDefault' or 'SansDefault'.
-    if (family === 'Default') family = FontCont.defaultFontName;
+    if (family === 'Default') family = FontCont.state.defaultFontName;
 
-    if (family === 'SerifDefault') family = FontCont.serifDefaultName;
-    if (family === 'SansDefault') family = FontCont.sansDefaultName;
+    if (family === 'SerifDefault') family = FontCont.state.serifDefaultName;
+    if (family === 'SansDefault') family = FontCont.state.sansDefaultName;
 
     /** @type {FontContainerFont} */
     let fontRes = FontCont.raw?.[family]?.[styleLookup];
@@ -456,16 +469,18 @@ export class FontCont {
     FontCont.rawMetrics = null;
     FontCont.optMetrics = null;
 
-    FontCont.enableCleanToNimbusMono = false;
+    FontCont.state.enableCleanToNimbusMono = false;
+
+    FontCont.state.defaultFontName = 'SerifDefault';
+    FontCont.state.serifDefaultName = 'NimbusRoman';
+    FontCont.state.sansDefaultName = 'NimbusSans';
 
-    FontCont.defaultFontName = 'SerifDefault';
-    FontCont.serifDefaultName = 'NimbusRoman';
-    FontCont.sansDefaultName = 'NimbusSans';
+    clearObjectProperties(FontCont.state.charMetrics);
   };
 
   static terminate = () => {
     FontCont.clear();
     FontCont.raw = null;
-    FontCont.glyphSet = null;
+    FontCont.state.glyphSet = null;
   };
 }

package/js/containers/imageContainer.js

@@ -5,7 +5,7 @@ import {
 import { initMuPDFWorker } from '../../mupdf/mupdf-async.js';
 
 import { updateFontContWorkerMain } from '../fontContainerMain.js';
-import { pageMetricsArr } from './dataContainer.js';
+import { pageMetricsAll } from './dataContainer.js';
 import {
   FontCont,
   FontContainerFont,
@@ -13,7 +13,7 @@ import {
 } from './fontContainer.js';
 
 import { gs } from '../generalWorkerMain.js';
-import { imageUtils } from '../objects/imageObjects.js';
+import { imageUtils, ImageWrapper } from '../objects/imageObjects.js';
 import { range } from '../utils/miscUtils.js';
 import { opt } from './app.js';
 
@@ -42,32 +42,6 @@ export class MuPDFScheduler {
   }
 }
 
-export class ImageWrapper {
-  /**
-   * @param {number} n - Page number
-   * @param {string} imageStr - Base-64 encoded image string. Should start with "data:image/png" or "data:image/jpeg".
-   * @param {string} colorMode - Color mode ("color", "gray", or "binary").
-   * @param {boolean} rotated - Whether image has been rotated.
-   * @param {boolean} upscaled - Whether image has been upscaled.
-   *
-   * All properties of this object must be serializable, as ImageWrapper objects are sent between threads.
-   * This means that no promises can be used.
-   */
-  constructor(n, imageStr, colorMode, rotated = false, upscaled = false) {
-    this.n = n;
-    this.src = imageStr;
-    const format0 = imageStr.match(/^data:image\/(png|jpeg)/)?.[1];
-    if (!format0 || !['png', 'jpeg'].includes(format0)) throw new Error(`Invalid image format: ${format0}`);
-    this.format = format0;
-    this._dims = null;
-    this.rotated = rotated;
-    this.upscaled = upscaled;
-    this.colorMode = colorMode;
-    /** @type {?ImageBitmap} */
-    this.imageBitmap = null;
-  }
-}
-
 /**
  * @typedef {Object} ImageProperties
  * @property {boolean} [rotated]
@@ -126,7 +100,7 @@ export class ImageCache {
       colorMode = color ? 'color' : 'gray';
     }
 
-    let pageAngle = pageMetricsArr[n].angle || 0;
+    let pageAngle = pageMetricsAll[n].angle || 0;
     if (Math.abs(pageAngle) < 0.05) pageAngle = 0;
 
     // If no preference is specified for rotation, default to true.
@@ -213,7 +187,7 @@ export class ImageCache {
     if (ImageCache.inputModes.image) {
       return ImageCache.nativeSrc[n];
     } if (ImageCache.inputModes.pdf) {
-      const pageMetrics = pageMetricsArr[n];
+      const pageMetrics = pageMetricsAll[n];
       const targetWidth = pageMetrics.dims.width;
       const dpi = 300 * (targetWidth / ImageCache.pdfDims300[n].width);
       const muPDFScheduler = await ImageCache.getMuPDFScheduler();
@@ -232,7 +206,7 @@ export class ImageCache {
    * @param {boolean} [saveNativeImage=true] - Whether the native image should be saved.
    */
   static transformImage = async (inputImage, n, props, saveNativeImage = true) => {
-    let pageAngle = pageMetricsArr[n].angle || 0;
+    let pageAngle = pageMetricsAll[n].angle || 0;
     if (Math.abs(pageAngle) < 0.05) pageAngle = 0;
 
     // If no preference is specified for rotation, default to true.
@@ -245,8 +219,8 @@ export class ImageCache {
     await gs.getGeneralScheduler();
 
     const resPromise = (async () => {
-    // Wait for non-rotated version before replacing with promise
-      if (typeof process === 'undefined') await gs.initTesseract({ anyOk: true });
+      // Wait for non-rotated version before replacing with promise
+      await gs.initTesseract({ anyOk: true });
       return gs.recognize({
         image: inputImage.src,
         options: { rotateRadians: angleArg, upscale: upscaleArg },
@@ -276,7 +250,11 @@ export class ImageCache {
    * @param {boolean} [nativeOnly=true]
    */
   static getImages = (n, props, nativeOnly = true) => {
-    const significantRotation = Math.abs(pageMetricsArr[n].angle || 0) > 0.05;
+    if (!ImageCache.inputModes.image && !ImageCache.inputModes.pdf) {
+      return { native: undefined, binary: undefined };
+    }
+
+    const significantRotation = Math.abs(pageMetricsAll[n].angle || 0) > 0.05;
 
     const newNative = !ImageCache.native[n] || !imageUtils.compatible(ImageCache.nativeProps[n], props, significantRotation);
     const newBinary = !nativeOnly && (!ImageCache.binary[n] || !imageUtils.compatible(ImageCache.binaryProps[n], props, significantRotation));
@@ -422,7 +400,7 @@ export class ImageCache {
 
     ImageCache.pdfDims300.forEach((x, i) => {
       const pageDims = { width: Math.round(x.width * pageDPI[i] / 300), height: Math.round(x.height * pageDPI[i] / 300) };
-      pageMetricsArr[i] = new PageMetrics(pageDims);
+      pageMetricsAll[i] = new PageMetrics(pageDims);
     });
 
     // WIP: Extract fonts embedded in PDFs.

package/js/coordinates.js

@@ -3,7 +3,7 @@
 // Image Coordinate Space: coordinate space of a particular image
 // Canvas Coordinate Space: coordinate space of canvas, used for user interactions
 
-import { pageMetricsArr } from './containers/dataContainer.js';
+import { pageMetricsAll } from './containers/dataContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
 
 /**
@@ -27,7 +27,7 @@ function rotateBoundingBox(boundingBox, rotateAngle, n) {
   let angleAdjXRect = 0;
   let angleAdjYRect = 0;
 
-  const pageDims = pageMetricsArr[n].dims;
+  const pageDims = pageMetricsAll[n].dims;
 
   const sinAngle = Math.sin(rotateAngle * (Math.PI / 180));
   const cosAngle = Math.cos(rotateAngle * (Math.PI / 180));
@@ -103,7 +103,7 @@ async function ocrToImage(ocrCoords, n, binary = false) {
 
   if (imageN.rotated) {
   // Otherwise, we must also account for rotation applied by the canvas
-    const rotateAngle = (pageMetricsArr[n].angle || 0) * -1;
+    const rotateAngle = (pageMetricsAll[n].angle || 0) * -1;
 
     rotateBoundingBox(ocrCoords, rotateAngle, n);
   }

package/js/debug.js

@@ -1,5 +1,5 @@
 import { opt } from './containers/app.js';
-import { pageMetricsArr } from './containers/dataContainer.js';
+import { pageMetricsAll } from './containers/dataContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
 import { gs } from './generalWorkerMain.js';
 import { loadImageElem } from './utils/imageUtils.js';
@@ -125,7 +125,7 @@ export async function renderPageStatic(page) {
   const res = gs.renderPageStaticImp({
     page,
     image,
-    angle: pageMetricsArr[page.n].angle,
+    angle: pageMetricsAll[page.n].angle,
   });
 
   return res;

package/js/export/export.js

@@ -1,19 +1,22 @@
 import { inputData, opt } from '../containers/app.js';
 import {
-  layoutDataTables, layoutRegions, ocrAll, pageMetricsArr,
+  layoutDataTables, layoutRegions, ocrAll, pageMetricsAll,
 } from '../containers/dataContainer.js';
 import { ImageCache } from '../containers/imageContainer.js';
 import { reorderOcrPage } from '../modifyOCR.js';
 import { saveAs } from '../utils/miscUtils.js';
-import { writePdf } from './writePdf.js';
+import { writePdf } from './pdf/writePdf.js';
 import { writeHocr } from './writeHocr.js';
 import { writeText } from './writeText.js';
 import { writeHtml } from './writeHtml.js';
+import { removeCircularRefsOcr } from '../objects/ocrObjects.js';
+import { removeCircularRefsDataTables } from '../objects/layoutObjects.js';
+import { FontCont } from '../containers/fontContainer.js';
 
 /**
  * Export active OCR data to specified format.
  * @public
- * @param {'pdf'|'hocr'|'docx'|'html'|'xlsx'|'txt'|'text'} [format='txt']
+ * @param {'pdf'|'hocr'|'docx'|'html'|'xlsx'|'txt'|'text'|'scribe'} [format='txt']
  * @param {number} [minPage=0] - First page to export.
  * @param {number} [maxPage=-1] - Last page to export (inclusive). -1 exports through the last page.
  * @returns {Promise<string|ArrayBuffer>}
@@ -42,8 +45,8 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
     const dimsLimit = { width: -1, height: -1 };
     if (opt.standardizePageSize) {
       for (let i = minPage; i <= maxPage; i++) {
-        dimsLimit.height = Math.max(dimsLimit.height, pageMetricsArr[i].dims.height);
-        dimsLimit.width = Math.max(dimsLimit.width, pageMetricsArr[i].dims.width);
+        dimsLimit.height = Math.max(dimsLimit.height, pageMetricsAll[i].dims.height);
+        dimsLimit.width = Math.max(dimsLimit.width, pageMetricsAll[i].dims.width);
       }
     }
 
@@ -55,10 +58,30 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
 
       const rotateText = !rotateBackground;
 
+      const includeImages = false;
+      /** @type {ImageWrapper[]} */
+      let images = [];
+      if (includeImages) {
+        images = await Promise.all(ImageCache.nativeSrc);
+      }
+
       // Page sizes should not be standardized at this step, as the overlayText/overlayTextImage functions will perform this,
       // and assume that the overlay PDF is the same size as the input images.
-      const pdfStr = await writePdf(ocrDownload, minPage, maxPage, opt.displayMode, rotateText, rotateBackground,
-        { width: -1, height: -1 }, opt.confThreshHigh, opt.confThreshMed, opt.overlayOpacity / 100);
+      const pdfStr = await writePdf({
+        ocrArr: ocrDownload,
+        pageMetricsArr: pageMetricsAll,
+        minpage: minPage,
+        maxpage: maxPage,
+        textMode: opt.displayMode,
+        rotateText,
+        rotateBackground,
+        dimsLimit: { width: -1, height: -1 },
+        confThreshHigh: opt.confThreshHigh,
+        confThreshMed: opt.confThreshMed,
+        proofOpacity: opt.overlayOpacity / 100,
+        images,
+        includeImages,
+      });
 
       const enc = new TextEncoder();
       const pdfEnc = enc.encode(pdfStr);
@@ -118,7 +141,7 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
 
         await w.convertImageStart({ humanReadable: opt.humanReadablePDF });
         for (let i = minPage; i < maxPage + 1; i++) {
-          /** @type {import('../containers/imageContainer.js').ImageWrapper} */
+          /** @type {ImageWrapper} */
           let image;
           if (binary) {
             image = await ImageCache.getBinary(i, props);
@@ -131,7 +154,7 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
           // Angle the PDF viewer is instructed to rotated the image by.
           // This method is currently only used when rotation is needed but the user's (unrotated) source images are being used.
           // If the images are being rendered, then rotation is expected to be applied within the rendering process.
-          const angleImagePdf = rotateBackground && !renderImage ? (pageMetricsArr[i].angle || 0) * -1 : 0;
+          const angleImagePdf = rotateBackground && !renderImage ? (pageMetricsAll[i].angle || 0) * -1 : 0;
 
           await w.convertImageAddPage({
             image: image.src, i, pagewidth: dimsLimit.width, pageheight: dimsLimit.height, angle: angleImagePdf,
@@ -154,8 +177,19 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
 
       w.freeDocument(pdfOverlay);
     } else {
-      const pdfStr = await writePdf(ocrDownload, minPage, maxPage, opt.displayMode, false, true, dimsLimit, opt.confThreshHigh, opt.confThreshMed,
-        opt.overlayOpacity / 100);
+      const pdfStr = await writePdf({
+        ocrArr: ocrDownload,
+        pageMetricsArr: pageMetricsAll,
+        minpage: minPage,
+        maxpage: maxPage,
+        textMode: opt.displayMode,
+        rotateText: false,
+        rotateBackground: true,
+        dimsLimit,
+        confThreshHigh: opt.confThreshHigh,
+        confThreshMed: opt.confThreshMed,
+        proofOpacity: opt.overlayOpacity / 100,
+      });
 
       // The PDF is still run through muPDF, even thought in eBook mode no background layer is added.
       // This is because muPDF cleans up the PDF we made in the previous step, including:
@@ -183,22 +217,73 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
       w.freeDocument(pdf);
     }
   } else if (format === 'hocr') {
-    content = writeHocr(ocrAll.active, minPage, maxPage);
+    content = writeHocr({ ocrData: ocrDownload, minValue: minPage, maxValue: maxPage });
   } else if (format === 'html') {
-    content = writeHtml(ocrAll.active, minPage, maxPage, opt.reflow, opt.removeMargins);
+    const images = /** @type {Array<ImageWrapper>} */ ([]);
+    if (opt.includeImages) {
+      const props = { rotated: opt.autoRotate, upscaled: false, colorMode: opt.colorMode };
+      const binary = opt.colorMode === 'binary';
+
+      // An image could be rendered if either (1) binary is selected or (2) the input data is a PDF.
+      // Otherwise, the images uploaded by the user are used.
+      const renderImage = binary || inputData.pdfMode;
+
+      // Pre-render to benefit from parallel processing, since the loop below is synchronous.
+      if (renderImage) await ImageCache.preRenderRange(minPage, maxPage, binary, props);
+
+      for (let i = minPage; i < maxPage + 1; i++) {
+        /** @type {ImageWrapper} */
+        let image;
+        if (binary) {
+          image = await ImageCache.getBinary(i, props);
+        } else if (inputData.pdfMode) {
+          image = await ImageCache.getNative(i, props);
+        } else {
+          image = await ImageCache.nativeSrc[i];
+        }
+        images.push(image);
+      }
+    }
+
+    content = writeHtml({
+      ocrPages: ocrDownload, images, minpage: minPage, maxpage: maxPage, reflowText: opt.reflow, removeMargins: opt.removeMargins,
+    });
   } else if (format === 'txt') {
-    content = writeText(ocrDownload, minPage, maxPage, opt.reflow, false);
+    content = writeText({
+      ocrCurrent: ocrDownload,
+      minpage: minPage,
+      maxpage: maxPage,
+      reflowText: opt.reflow,
+      docxMode: false,
+    });
   // Defining `DISABLE_DOCX_XLSX` disables docx/xlsx exports when using build tools.
   // @ts-ignore
   } else if (typeof DISABLE_DOCX_XLSX === 'undefined' && format === 'docx') {
     // Less common export formats are loaded dynamically to reduce initial load time.
     const writeDocx = (await import('./writeDocx.js')).writeDocx;
-    content = await writeDocx(ocrDownload, minPage, maxPage);
+    content = await writeDocx({ hocrCurrent: ocrDownload, minpage: minPage, maxpage: maxPage });
   // @ts-ignore
   } else if (typeof DISABLE_DOCX_XLSX === 'undefined' && format === 'xlsx') {
     // Less common export formats are loaded dynamically to reduce initial load time.
     const writeXlsx = (await import('./writeTabular.js')).writeXlsx;
-    content = await writeXlsx(ocrDownload, layoutDataTables.pages, minPage, maxPage);
+    content = await writeXlsx({
+      ocrPageArr: ocrDownload,
+      layoutPageArr: layoutDataTables.pages,
+      minpage: minPage,
+      maxpage: maxPage,
+    });
+  } else if (format === 'scribe') {
+    const data = {
+      ocr: removeCircularRefsOcr(ocrDownload),
+      fontState: FontCont.state,
+      layoutRegions: layoutRegions.pages,
+      layoutDataTables: removeCircularRefsDataTables(layoutDataTables.pages),
+    };
+    const contentStr = JSON.stringify(data);
+
+    const pako = await import('../../lib/pako.esm.mjs');
+    const enc = new TextEncoder();
+    content = pako.gzip(enc.encode(contentStr))?.buffer;
   }
 
   return content;
@@ -207,14 +292,14 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
 /**
  * Runs `exportData` and saves the result as a download (browser) or local file (Node.js).
  * @public
- * @param {'pdf'|'hocr'|'docx'|'xlsx'|'txt'|'text'|'html'} format
+ * @param {'pdf'|'hocr'|'docx'|'xlsx'|'txt'|'text'|'html'|'scribe'} format
  * @param {string} fileName
  * @param {number} [minPage=0] - First page to export.
  * @param {number} [maxPage=-1] - Last page to export (inclusive). -1 exports through the last page.
  */
 export async function download(format, fileName, minPage = 0, maxPage = -1) {
   if (format === 'text') format = 'txt';
-  fileName = fileName.replace(/\.\w{1,4}$/, `.${format}`);
+  fileName = fileName.replace(/\.\w{1,6}$/, `.${format}`);
   const content = await exportData(format, minPage, maxPage);
   await saveAs(content, fileName);
 }

package/js/export/exportDebugCsv.js

@@ -39,11 +39,12 @@ export const convertToCsv = (data) => {
 
 /**
  *
- * @param {Array<OcrPage>} pages
- * @param {string} fileName
+ * @param {Object} params
+ * @param {Array<OcrPage>} params.pages
+ * @param {string} params.fileName
  * @returns
  */
-export const writeDebugCsv = (pages, fileName) => {
+export const writeDebugCsv = ({ pages, fileName }) => {
   let csvStr = '';
 
   for (let i = 0; i < pages.length; i++) {