scribe.js-ocr 0.7.4 → 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/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, getStyleLookup } 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;
 }
@@ -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.
@@ -344,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];
@@ -375,7 +385,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);
 
@@ -413,9 +423,9 @@ 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';
       }
     }
@@ -426,10 +436,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 +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(),

package/js/fontContainerMain.js

@@ -15,9 +15,9 @@ import { gs } from './generalWorkerMain.js';
  */
 export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
   // Return early if the font set is already loaded, or a superset of the requested set is loaded.
-  if (FontCont.glyphSet === glyphSet || FontCont.glyphSet === 'all' && glyphSet === 'latin') return;
+  if (FontCont.state.glyphSet === glyphSet || FontCont.state.glyphSet === 'all' && glyphSet === 'latin') return;
 
-  FontCont.glyphSet = glyphSet;
+  FontCont.state.glyphSet = glyphSet;
 
   // Note: this function is intentionally verbose, and should not be refactored to generate the paths dynamically.
   // Build systems will not be able to resolve the paths if they are generated dynamically.
@@ -213,15 +213,15 @@ export async function loadChiSimFont() {
 export async function enableFontOpt(enableOpt, forceOpt) {
   let change = false;
   if (enableOpt === true || enableOpt === false) {
-    if (FontCont.enableOpt !== enableOpt) {
+    if (FontCont.state.enableOpt !== enableOpt) {
       change = true;
-      FontCont.enableOpt = enableOpt;
+      FontCont.state.enableOpt = enableOpt;
     }
   }
   if (forceOpt === true || forceOpt === false) {
-    if (FontCont.forceOpt !== forceOpt) {
+    if (FontCont.state.forceOpt !== forceOpt) {
       change = true;
-      FontCont.forceOpt = forceOpt;
+      FontCont.state.forceOpt = forceOpt;
     }
   }
 
@@ -286,11 +286,11 @@ export async function updateFontContWorkerMain(params = {}) {
     const res = worker.updateFontContWorker({
       rawMetrics: FontCont.rawMetrics,
       optMetrics: FontCont.optMetrics,
-      sansDefaultName: FontCont.sansDefaultName,
-      serifDefaultName: FontCont.serifDefaultName,
-      defaultFontName: FontCont.defaultFontName,
-      enableOpt: FontCont.enableOpt,
-      forceOpt: FontCont.forceOpt,
+      sansDefaultName: FontCont.state.sansDefaultName,
+      serifDefaultName: FontCont.state.serifDefaultName,
+      defaultFontName: FontCont.state.defaultFontName,
+      enableOpt: FontCont.state.enableOpt,
+      forceOpt: FontCont.state.forceOpt,
     });
     resArr.push(res);
   }
@@ -336,11 +336,11 @@ export async function setUploadFontsWorker(scheduler) {
     const res = worker.updateFontContWorker({
       rawMetrics: FontCont.rawMetrics,
       optMetrics: FontCont.optMetrics,
-      sansDefaultName: FontCont.sansDefaultName,
-      serifDefaultName: FontCont.serifDefaultName,
-      defaultFontName: FontCont.defaultFontName,
-      enableOpt: FontCont.enableOpt,
-      forceOpt: FontCont.forceOpt,
+      sansDefaultName: FontCont.state.sansDefaultName,
+      serifDefaultName: FontCont.state.serifDefaultName,
+      defaultFontName: FontCont.state.defaultFontName,
+      enableOpt: FontCont.state.enableOpt,
+      forceOpt: FontCont.state.forceOpt,
     });
     resArr.push(res);
   }
@@ -351,23 +351,23 @@ export async function setUploadFontsWorker(scheduler) {
  * Automatically sets the default font to whatever font is most common in the provided font metrics.
  *
  */
-export function setDefaultFontAuto(fontMetricsObj) {
-  const multiFontMode = checkMultiFontMode(fontMetricsObj);
+export function setDefaultFontAuto(charMetricsObj) {
+  const multiFontMode = checkMultiFontMode(charMetricsObj);
 
   // Return early if the OCR data does not contain font info.
   if (!multiFontMode) return;
 
   // Change default font to whatever named font appears more
-  if ((fontMetricsObj.SerifDefault?.obs || 0) > (fontMetricsObj.SansDefault?.obs || 0)) {
-    FontCont.defaultFontName = 'SerifDefault';
+  if ((charMetricsObj.SerifDefault?.obs || 0) > (charMetricsObj.SansDefault?.obs || 0)) {
+    FontCont.state.defaultFontName = 'SerifDefault';
   } else {
-    FontCont.defaultFontName = 'SansDefault';
+    FontCont.state.defaultFontName = 'SansDefault';
   }
 
   if (gs.schedulerInner) {
     for (let i = 0; i < gs.schedulerInner.workers.length; i++) {
       const worker = gs.schedulerInner.workers[i];
-      worker.updateFontContWorker({ defaultFontName: FontCont.defaultFontName });
+      worker.updateFontContWorker({ defaultFontName: FontCont.state.defaultFontName });
     }
   }
 }
@@ -375,39 +375,39 @@ export function setDefaultFontAuto(fontMetricsObj) {
 /**
  *
  * @param {FontContainerFamilyBuiltIn} fontFamily
- * @param {Object.<string, FontMetricsFamily>} fontMetricsObj
+ * @param {Object.<string, CharMetricsFamily>} charMetricsObj
  */
-export async function optimizeFontContainerFamily(fontFamily, fontMetricsObj) {
+export async function optimizeFontContainerFamily(fontFamily, charMetricsObj) {
   // When we have metrics for individual fonts families, those are used to optimize the appropriate fonts.
   // Otherwise, the "default" metric is applied to whatever font the user has selected as the default font.
-  const multiFontMode = checkMultiFontMode(fontMetricsObj);
-  let fontMetricsType = 'Default';
+  const multiFontMode = checkMultiFontMode(charMetricsObj);
+  let charMetricsType = 'Default';
   if (multiFontMode) {
     if (fontFamily.normal.type === 'sans') {
-      fontMetricsType = 'SansDefault';
+      charMetricsType = 'SansDefault';
     } else {
-      fontMetricsType = 'SerifDefault';
+      charMetricsType = 'SerifDefault';
     }
   }
 
   // If there are no statistics to use for optimization, create "optimized" font by simply copying the raw font without modification.
   // This should only occur when `multiFontMode` is true, but a document contains no sans words or no serif words.
-  if (!fontMetricsObj[fontMetricsType] || !fontMetricsObj[fontMetricsType][fontFamily.normal.style] || fontMetricsObj[fontMetricsType][fontFamily.normal.style].obs < 200) {
+  if (!charMetricsObj[charMetricsType] || !charMetricsObj[charMetricsType][fontFamily.normal.style] || charMetricsObj[charMetricsType][fontFamily.normal.style].obs < 200) {
     return null;
   }
 
-  const metricsNormal = fontMetricsObj[fontMetricsType][fontFamily.normal.style];
-  const normalOptFont = gs.optimizeFont({ fontData: fontFamily.normal.src, fontMetricsObj: metricsNormal, style: fontFamily.normal.style })
+  const metricsNormal = charMetricsObj[charMetricsType][fontFamily.normal.style];
+  const normalOptFont = gs.optimizeFont({ fontData: fontFamily.normal.src, charMetricsObj: metricsNormal, style: fontFamily.normal.style })
     .then(async (x) => {
       const font = await loadOpentype(x.fontData, x.kerningPairs);
       return new FontContainerFont(fontFamily.normal.family, fontFamily.normal.style, x.fontData, true, font);
     });
 
-  const metricsItalic = fontMetricsObj[fontMetricsType][fontFamily.italic.style];
+  const metricsItalic = charMetricsObj[charMetricsType][fontFamily.italic.style];
   /** @type {?FontContainerFont|Promise<FontContainerFont>} */
   let italicOptFont = null;
   if (metricsItalic && metricsItalic.obs >= 200) {
-    italicOptFont = gs.optimizeFont({ fontData: fontFamily.italic.src, fontMetricsObj: metricsItalic, style: fontFamily.italic.style })
+    italicOptFont = gs.optimizeFont({ fontData: fontFamily.italic.src, charMetricsObj: metricsItalic, style: fontFamily.italic.style })
       .then(async (x) => {
         const font = await loadOpentype(x.fontData, x.kerningPairs);
         return new FontContainerFont(fontFamily.italic.family, fontFamily.italic.style, x.fontData, true, font);
@@ -424,16 +424,16 @@ export async function optimizeFontContainerFamily(fontFamily, fontMetricsObj) {
  * Optimize all fonts.
  * If a font cannot be optimized, then the raw font is returned.
  * @param {Object<string, FontContainerFamilyBuiltIn>} fontPrivate
- * @param {Object.<string, FontMetricsFamily>} fontMetricsObj
+ * @param {Object.<string, CharMetricsFamily>} charMetricsObj
  */
-export async function optimizeFontContainerAll(fontPrivate, fontMetricsObj) {
-  const carlitoPromise = optimizeFontContainerFamily(fontPrivate.Carlito, fontMetricsObj);
-  const centuryPromise = optimizeFontContainerFamily(fontPrivate.Century, fontMetricsObj);
-  const garamondPromise = optimizeFontContainerFamily(fontPrivate.Garamond, fontMetricsObj);
-  const palatinoPromise = optimizeFontContainerFamily(fontPrivate.Palatino, fontMetricsObj);
-  const nimbusRomanPromise = optimizeFontContainerFamily(fontPrivate.NimbusRoman, fontMetricsObj);
-  const nimbusSansPromise = optimizeFontContainerFamily(fontPrivate.NimbusSans, fontMetricsObj);
-  const nimbusMonoPromise = optimizeFontContainerFamily(fontPrivate.NimbusMono, fontMetricsObj);
+export async function optimizeFontContainerAll(fontPrivate, charMetricsObj) {
+  const carlitoPromise = optimizeFontContainerFamily(fontPrivate.Carlito, charMetricsObj);
+  const centuryPromise = optimizeFontContainerFamily(fontPrivate.Century, charMetricsObj);
+  const garamondPromise = optimizeFontContainerFamily(fontPrivate.Garamond, charMetricsObj);
+  const palatinoPromise = optimizeFontContainerFamily(fontPrivate.Palatino, charMetricsObj);
+  const nimbusRomanPromise = optimizeFontContainerFamily(fontPrivate.NimbusRoman, charMetricsObj);
+  const nimbusSansPromise = optimizeFontContainerFamily(fontPrivate.NimbusSans, charMetricsObj);
+  const nimbusMonoPromise = optimizeFontContainerFamily(fontPrivate.NimbusMono, charMetricsObj);
 
   const results = await Promise.all([carlitoPromise, centuryPromise, garamondPromise, palatinoPromise, nimbusRomanPromise, nimbusSansPromise, nimbusMonoPromise]);
 

package/js/fontEval.js

@@ -1,4 +1,4 @@
-import { fontMetricsObj, pageMetricsArr } from './containers/dataContainer.js';
+import { pageMetricsArr } from './containers/dataContainer.js';
 import { FontCont } from './containers/fontContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
 import {
@@ -132,16 +132,16 @@ const calcBestFonts = (fontMetrics) => {
 export async function runFontOptimization(ocrArr) {
   await loadBuiltInFontsRaw();
 
-  const calculateOpt = fontMetricsObj && Object.keys(fontMetricsObj).length > 0;
+  const calculateOpt = FontCont.state.charMetrics && Object.keys(FontCont.state.charMetrics).length > 0;
 
   let enableOptSerif = false;
   let enableOptSans = false;
 
   let optimizeFontContainerAllPromise;
   if (calculateOpt) {
-    setDefaultFontAuto(fontMetricsObj);
+    setDefaultFontAuto(FontCont.state.charMetrics);
 
-    optimizeFontContainerAllPromise = optimizeFontContainerAll(FontCont.raw, fontMetricsObj)
+    optimizeFontContainerAllPromise = optimizeFontContainerAll(FontCont.raw, FontCont.state.charMetrics)
       .then((res) => {
         FontCont.opt = res;
       });
@@ -167,28 +167,28 @@ export async function runFontOptimization(ocrArr) {
       // This ensures that switching on/off "font optimization" does not change the font, which would be confusing.
       if (FontCont.optMetrics[bestMetricsOpt.minKeySans] < FontCont.rawMetrics[bestMetricsRaw.minKeySans]) {
         enableOptSans = true;
-        FontCont.sansDefaultName = bestMetricsOpt.minKeySans;
+        FontCont.state.sansDefaultName = bestMetricsOpt.minKeySans;
       } else {
-        FontCont.sansDefaultName = bestMetricsRaw.minKeySans;
+        FontCont.state.sansDefaultName = bestMetricsRaw.minKeySans;
       }
 
       // Repeat for serif fonts
       if (FontCont.optMetrics[bestMetricsOpt.minKeySerif] < FontCont.rawMetrics[bestMetricsRaw.minKeySerif]) {
         enableOptSerif = true;
-        FontCont.serifDefaultName = bestMetricsOpt.minKeySerif;
+        FontCont.state.serifDefaultName = bestMetricsOpt.minKeySerif;
       } else {
-        FontCont.serifDefaultName = bestMetricsRaw.minKeySerif;
+        FontCont.state.serifDefaultName = bestMetricsRaw.minKeySerif;
       }
     } else {
-      FontCont.sansDefaultName = bestMetricsRaw.minKeySans;
-      FontCont.serifDefaultName = bestMetricsRaw.minKeySerif;
+      FontCont.state.sansDefaultName = bestMetricsRaw.minKeySans;
+      FontCont.state.serifDefaultName = bestMetricsRaw.minKeySerif;
     }
 
-    FontCont.enableOpt = enableOptSerif || enableOptSans;
+    FontCont.state.enableOpt = enableOptSerif || enableOptSans;
 
     // Send updated state to all workers.
     await updateFontContWorkerMain();
   }
 
-  return FontCont.enableOpt;
+  return FontCont.state.enableOpt;
 }