scribe.js-ocr 0.7.3 → 0.8.0

package/cli/scribe.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 import { Command, Option } from 'commander';
 
 import {

package/js/clear.js

@@ -1,7 +1,6 @@
 import { inputData } from './containers/app.js';
 import {
   convertPageWarn,
-  fontMetricsObj,
   layoutDataTables,
   layoutRegions,
   ocrAll,
@@ -10,18 +9,18 @@ import {
 } from './containers/dataContainer.js';
 import { FontCont } from './containers/fontContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
-import { replaceObjectProperties } from './utils/miscUtils.js';
+import { clearObjectProperties } from './utils/miscUtils.js';
 
 export function clearData() {
   inputData.clear();
-  replaceObjectProperties(ocrAll, { active: [] });
-  replaceObjectProperties(ocrAllRaw, { active: [] });
+  clearObjectProperties(ocrAll);
+  ocrAll.active = [];
+  clearObjectProperties(ocrAllRaw);
+  ocrAllRaw.active = [];
   layoutRegions.pages.length = 0;
   layoutDataTables.pages.length = 0;
   pageMetricsArr.length = 0;
   convertPageWarn.length = 0;
   ImageCache.clear();
-  // Clear optimized font data and reset fontAll to raw data.
-  replaceObjectProperties(fontMetricsObj);
   FontCont.clear();
 }

package/js/containers/app.js

@@ -1,5 +1,5 @@
 export class opt {
-  static ligatures = true;
+  static ligatures = false;
 
   static kerning = true;
 

package/js/containers/dataContainer.js

@@ -1,9 +1,6 @@
 // This file contains various objects that are imported by other modules.
 // Everything here is essentially a global variable; none of them are technically "containers".
 
-/** @type {Object.<string, FontMetricsFamily>} */
-export const fontMetricsObj = {};
-
 export class layoutRegions {
   /** @type {Array<LayoutPage>} */
   static pages = [];

package/js/containers/fontContainer.js

@@ -5,7 +5,7 @@
 
 // Node.js case
 import opentype from '../../lib/opentype.module.js';
-import { determineSansSerif } from '../utils/miscUtils.js';
+import { determineSansSerif, getStyleLookup, clearObjectProperties } from '../utils/miscUtils.js';
 import { ca } from '../canvasAdapter.js';
 
 if (typeof process === 'object') {
@@ -21,7 +21,7 @@ if (typeof process === 'object') {
 
 /**
  * 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;
 }
@@ -104,26 +104,26 @@ export function loadFontFace(fontFamily, fontStyle, fontWeight, src) {
  * Load font from source and return a FontContainerFont object.
  * This function is used to load the Chinese font.
  * @param {string} family
- * @param {string} style
+ * @param {StyleLookup} styleLookup
  * @param {("sans"|"serif")} type
  * @param {ArrayBuffer} src
  * @param {boolean} opt
  *
  */
-export async function loadFont(family, style, type, src, opt) {
+export async function loadFont(family, styleLookup, type, src, opt) {
   const fontObj = await loadOpentype(src);
-  return new FontContainerFont(family, style, src, opt, fontObj);
+  return new FontContainerFont(family, styleLookup, src, opt, fontObj);
 }
 
 /**
  *
  * @param {string} family
- * @param {string} style
+ * @param {StyleLookup} styleLookup
  * @param {ArrayBuffer} src
  * @param {boolean} opt
  * @param {opentype.Font} opentypeObj - Kerning paris to re-apply
  * @property {string} family -
- * @property {string} style -
+ * @property {StyleLookup} style -
  * @property {ArrayBuffer} src
  * @property {opentype.Font} opentype -
  * @property {string} fontFaceName -
@@ -135,7 +135,7 @@ export async function loadFont(family, style, type, src, opt) {
  * First, it is not necessary.  Setting the font on a canvas (the only reason loading a `FontFace` is needed) is done through refering `fontFaceName` and `fontFaceStyle`.
  * Second, it results in errors being thrown when used in Node.js, as `FontFace` will be undefined in this case.
  */
-export function FontContainerFont(family, style, src, opt, opentypeObj) {
+export function FontContainerFont(family, styleLookup, src, opt, opentypeObj) {
   // As FontFace objects are included in the document FontFaceSet object,
   // they need to all have unique names.
   let fontFaceName = family;
@@ -143,8 +143,8 @@ export function FontContainerFont(family, style, src, opt, opentypeObj) {
 
   /** @type {string} */
   this.family = family;
-  /** @type {string} */
-  this.style = style;
+  /** @type {StyleLookup} */
+  this.style = styleLookup;
   /** @type {boolean} */
   this.opt = opt;
   /** @type {ArrayBuffer} */
@@ -154,9 +154,9 @@ export function FontContainerFont(family, style, src, opt, opentypeObj) {
   /** @type {string} */
   this.fontFaceName = fontFaceName;
   /** @type {('normal'|'italic')} */
-  this.fontFaceStyle = this.style === 'italic' ? 'italic' : 'normal';
+  this.fontFaceStyle = ['italic', 'boldItalic'].includes(this.style) ? 'italic' : 'normal';
   /** @type {('normal'|'bold')} */
-  this.fontFaceWeight = this.style === 'bold' ? 'bold' : 'normal';
+  this.fontFaceWeight = ['bold', 'boldItalic'].includes(this.style) ? 'bold' : 'normal';
   /** @type {("sans"|"serif")} */
   this.type = determineSansSerif(this.family) === 'SansDefault' ? 'sans' : 'serif';
   this.smallCapsMult = 0.75;
@@ -185,27 +185,27 @@ export async function loadFontContainerFamily(family, src, opt = false) {
     normal: null,
     italic: null,
     bold: null,
+    boldItalic: null,
   };
 
   /**
    *
-   * @param {('normal'|'bold'|'italic')} type
+   * @param {StyleLookup} styleLookup
    * @returns
    */
-  const loadType = (type) => new Promise((resolve) => {
-    const srcType = (src[type]);
+  const loadType = (styleLookup) => new Promise((resolve) => {
+    const srcType = (src[styleLookup]);
     if (!srcType) {
       resolve(false);
       return;
     }
-    // const scrNormal = typeof srcType === 'string' ? getFontAbsPath(srcType) : srcType;
     loadOpentype(srcType).then((font) => {
-      res[type] = new FontContainerFont(family, type, srcType, opt, font);
+      res[styleLookup] = new FontContainerFont(family, styleLookup, srcType, opt, font);
       resolve(true);
     });
   });
 
-  Promise.allSettled([loadType('normal'), loadType('italic'), loadType('bold')]);
+  Promise.allSettled([loadType('normal'), loadType('italic'), loadType('bold'), loadType('boldItalic')]);
 
   return res;
 }
@@ -250,33 +250,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.
@@ -300,11 +310,13 @@ export class FontCont {
 
     const fontNameEmbedded = fontObj.names.postScriptName.en;
 
-    let fontStyle = 'normal';
-    if (fontNameEmbedded.match(/italic/i)) {
-      fontStyle = 'italic';
+    let styleLookup = /** @type {StyleLookup} */ ('normal');
+    if (fontNameEmbedded.match(/boldit|bdit/i)) {
+      styleLookup = 'boldItalic';
+    } else if (fontNameEmbedded.match(/italic/i)) {
+      styleLookup = 'italic';
     } else if (fontNameEmbedded.match(/bold/i)) {
-      fontStyle = 'bold';
+      styleLookup = 'bold';
     }
 
     // mupdf makes changes to font names, so we need to do the same.
@@ -312,9 +324,9 @@ export class FontCont {
     // Spaces are replaced with underscores.
     const fontName = fontNameEmbedded.replace(/[^+]+\+/g, '').replace(/\s/g, '_');
 
-    if (!FontCont.doc?.[fontName]?.[fontStyle]) {
+    if (!FontCont.doc?.[fontName]?.[styleLookup]) {
       try {
-        const fontContainer = new FontContainerFont(fontName, fontStyle, fontData, false, fontObj);
+        const fontContainer = new FontContainerFont(fontName, styleLookup, fontData, false, fontObj);
 
         if (!FontCont.doc) {
           FontCont.doc = {};
@@ -324,12 +336,12 @@ export class FontCont {
           FontCont.doc[fontName] = {};
         }
 
-        FontCont.doc[fontName][fontStyle] = fontContainer;
+        FontCont.doc[fontName][styleLookup] = fontContainer;
       } catch (error) {
-        console.error(`Error loading font ${fontName} ${fontStyle}.`);
+        console.error(`Error loading font ${fontName} ${styleLookup}.`);
       }
     } else {
-      console.warn(`Font ${fontName} ${fontStyle} already exists.`);
+      console.warn(`Font ${fontName} ${styleLookup} already exists.`);
     }
   };
 
@@ -342,15 +354,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];
@@ -368,14 +380,17 @@ export class FontCont {
    * Gets a font object.  Unlike accessing the font containers directly,
    * this method allows for special values 'Default', 'SansDefault', and 'SerifDefault' to be used.
    *
-   * @param {('Default'|'SansDefault'|'SerifDefault'|string)} family - Font family name.
-   * @param {('normal'|'italic'|'bold'|string)} [style='normal']
+   * @param {Partial<Style>} style
    * @param {string} [lang='eng']
    * @returns {FontContainerFont}
    */
-  static getFont = (family, style = 'normal', lang = 'eng') => {
-    if (FontCont.doc?.[family]?.[style] && !FontCont.doc?.[family]?.[style]?.disable) {
-      return FontCont.doc[family][style];
+  static getFont = (style, lang = 'eng') => {
+    let family = style.font || FontCont.state.defaultFontName;
+
+    const styleLookup = getStyleLookup(style);
+
+    if (FontCont.doc?.[family]?.[styleLookup] && !FontCont.doc?.[family]?.[styleLookup]?.disable) {
+      return FontCont.doc[family][styleLookup];
     }
 
     if (lang === 'chi_sim') {
@@ -387,7 +402,7 @@ export class FontCont {
 
     // Option 1: If we have access to the font, use it.
     // Option 2: If we do not have access to the font, but it closely resembles a built-in font, use the built-in font.
-    if (!FontCont.raw?.[family]?.[style]) {
+    if (!FontCont.raw?.[family]?.[styleLookup]) {
       if (/NimbusRom/i.test(family)) {
         family = 'NimbusRoman';
       } else if (/Times/i.test(family)) {
@@ -408,29 +423,29 @@ export class FontCont {
         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';
       }
     }
 
     // Option 3: If the font still is not identified, use the default sans/serif font.
-    if (!FontCont.raw?.[family]?.[style]) {
+    if (!FontCont.raw?.[family]?.[styleLookup]) {
       family = determineSansSerif(family);
     }
 
     // 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]?.[style];
-    if (!fontRes) throw new Error(`Font container does not contain ${family} (${style}).`);
+    let fontRes = FontCont.raw?.[family]?.[styleLookup];
+    if (!fontRes) throw new Error(`Font container does not contain ${family} (${styleLookup}).`);
 
-    const opt = FontCont.opt?.[family]?.[style];
+    const opt = FontCont.opt?.[family]?.[styleLookup];
     const useOpt = FontCont.useOptFamily(family);
     if (opt && useOpt) fontRes = opt;
 
@@ -441,10 +456,7 @@ export class FontCont {
    *
    * @param {OcrWord} word
    */
-  static getWordFont = (word) => {
-    const wordFontFamily = word.font || FontCont.defaultFontName;
-    return FontCont.getFont(wordFontFamily, word.style, word.lang);
-  };
+  static getWordFont = (word) => FontCont.getFont(word.style, word.lang);
 
   /**
    * Reset font container to original state but do not unload default resources.
@@ -454,16 +466,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/export/export.js

@@ -9,11 +9,14 @@ import { writePdf } from './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>}
@@ -183,9 +186,9 @@ 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(ocrDownload, minPage, maxPage);
   } else if (format === 'html') {
-    content = writeHtml(ocrAll.active, minPage, maxPage, opt.reflow, opt.removeMargins);
+    content = writeHtml(ocrDownload, minPage, maxPage, opt.reflow, opt.removeMargins);
   } else if (format === 'txt') {
     content = writeText(ocrDownload, minPage, maxPage, opt.reflow, false);
   // Defining `DISABLE_DOCX_XLSX` disables docx/xlsx exports when using build tools.
@@ -199,6 +202,18 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
     // 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);
+  } 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 +222,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/writeHocr.js

@@ -1,6 +1,6 @@
 import { opt } from '../containers/app.js';
 import {
-  fontMetricsObj, layoutDataTables, layoutRegions, pageMetricsArr,
+  layoutDataTables, layoutRegions, pageMetricsArr,
 } from '../containers/dataContainer.js';
 import { FontCont } from '../containers/fontContainer.js';
 import ocr from '../objects/ocrObjects.js';
@@ -17,10 +17,10 @@ export function writeHocr(ocrData, minValue, maxValue) {
   if (maxValue === null || maxValue === undefined || maxValue < 0) maxValue = ocrData.length - 1;
 
   const meta = {
-    'font-metrics': fontMetricsObj,
-    'default-font': FontCont.defaultFontName,
-    'sans-font': FontCont.sansDefaultName,
-    'serif-font': FontCont.serifDefaultName,
+    'font-metrics': FontCont.state.charMetrics,
+    'default-font': FontCont.state.defaultFontName,
+    'sans-font': FontCont.state.sansDefaultName,
+    'serif-font': FontCont.state.serifDefaultName,
     'enable-opt': opt.enableOpt,
     layout: layoutRegions.pages,
     'layout-data-table': layoutDataTables.serialize(),
@@ -75,38 +75,40 @@ export function writeHocr(ocrData, minValue, maxValue) {
         hocrOut += `bbox ${Math.round(wordObj.bbox.left)} ${Math.round(wordObj.bbox.top)} ${Math.round(wordObj.bbox.right)} ${Math.round(wordObj.bbox.bottom)}`;
         hocrOut += `;x_wconf ${wordObj.conf}`;
 
-        if (wordObj.font && wordObj.font !== 'Default') {
-          hocrOut += `;x_font ${wordObj.font}`;
+        if (wordObj.style.font && wordObj.style.font !== 'Default') {
+          hocrOut += `;x_font ${wordObj.style.font}`;
         }
 
-        if (wordObj.size) {
-          hocrOut += `;x_fsize ${wordObj.size}`;
+        if (wordObj.style.size) {
+          hocrOut += `;x_fsize ${wordObj.style.size}`;
         }
 
         hocrOut += "'";
 
         // Tesseract HOCR specifies default language for a paragraph in the "ocr_par" element,
         // however as ScribeOCR does not currently have a paragarph object, every word must have its language specified.
-        hocrOut += ` lang='${wordObj.lang}'`;
+        if (wordObj.lang) hocrOut += ` lang='${wordObj.lang}'`;
 
         // TODO: Why are we representing font family and style using the `style` HTML element here?
         // This is not how Tesseract does things, and our own parsing script does not appear to be written to re-import it properly.
         // Add "style" attribute (if applicable)
-        if (['italic', 'bold'].includes(wordObj.style) || wordObj.smallCaps || (wordObj.font && wordObj.font !== 'Default')) {
+        if (wordObj.style.bold || wordObj.style.italic || wordObj.style.smallCaps || (wordObj.style.font && wordObj.style.font !== 'Default')) {
           hocrOut += ' style=\'';
 
-          if (wordObj.style === 'italic') {
+          if (wordObj.style.italic) {
             hocrOut += 'font-style:italic;';
-          } else if (wordObj.style === 'bold') {
+          }
+
+          if (wordObj.style.bold) {
             hocrOut += 'font-weight:bold;';
           }
 
-          if (wordObj.smallCaps) {
+          if (wordObj.style.smallCaps) {
             hocrOut += 'font-variant:small-caps;';
           }
 
-          if (wordObj.font && wordObj.font !== 'Default') {
-            hocrOut += `font-family:${wordObj.font}`;
+          if (wordObj.style.font && wordObj.style.font !== 'Default') {
+            hocrOut += `font-family:${wordObj.style.font}`;
           }
 
           hocrOut += '\'>';
@@ -115,9 +117,9 @@ export function writeHocr(ocrData, minValue, maxValue) {
         }
 
         // Add word text, along with any formatting that uses nested elements rather than attributes
-        if (wordObj.sup) {
+        if (wordObj.style.sup) {
           hocrOut += `<sup>${ocr.escapeXml(wordObj.text)}</sup>`;
-        } else if (wordObj.dropcap) {
+        } else if (wordObj.style.dropcap) {
           hocrOut += `<span class='ocr_dropcap'>${ocr.escapeXml(wordObj.text)}</span>`;
         } else {
           hocrOut += ocr.escapeXml(wordObj.text);

package/js/export/writeHtml.js

@@ -175,7 +175,7 @@ export function writeHtml(ocrCurrent, minpage = 0, maxpage = -1, reflowText = fa
         // Therefore, we handle small caps by making all text print as uppercase using the `text-transform` CSS property,
         // and then wrapping each letter in a span with a smaller font size.
         let innerHTML;
-        if (wordObj.smallCaps) {
+        if (wordObj.style.smallCaps) {
           styleStr += 'text-transform:uppercase;';
           innerHTML = makeSmallCapsDivs(wordStr, fontSizeHTMLSmallCaps);
         } else {