scribe.js-ocr 0.2.4 → 0.2.5

package/js/fontContainerMain.js

@@ -1,6 +1,6 @@
 import {
   checkMultiFontMode,
-  fontAll,
+  FontCont,
   FontContainerFont,
   loadFont,
   loadFontsFromSource,
@@ -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 (fontAll.glyphSet === glyphSet || fontAll.glyphSet === 'all' && glyphSet === 'latin') return;
+  if (FontCont.glyphSet === glyphSet || FontCont.glyphSet === 'all' && glyphSet === 'latin') return;
 
-  fontAll.glyphSet = glyphSet;
+  FontCont.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.
@@ -110,14 +110,14 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
     NimbusSans: { normal: await nimbusSansNormal, italic: await nimbusSansItalic, bold: await nimbusSansBold },
   };
 
-  fontAll.raw = await /** @type {FontContainer} */(/** @type {any} */(loadFontsFromSource(srcObj)));
-  if (!fontAll.active || (!fontAll.active.NimbusSans.normal.opt && !fontAll.active.NimbusRomNo9L.normal.opt)) fontAll.active = fontAll.raw;
+  FontCont.raw = await /** @type {FontContainer} */(/** @type {any} */(loadFontsFromSource(srcObj)));
 
   if (typeof process === 'undefined') {
     // This assumes that the scheduler `init` method has at least started.
     if (gs.schedulerReady === null) console.warn('Failed to load fonts to workers as workers have not been initialized yet.');
     await gs.schedulerReady;
-    await setBuiltInFontsWorker(gs.schedulerInner, true);
+    // If this is running, presumably a new glyphset is being loaded, so the fonts should be forced to be updated.
+    await updateFontContWorkerMain({ loadRaw: true });
   }
 
   return;
@@ -144,7 +144,7 @@ export async function loadChiSimFont() {
     chiSimSrc = readFile(new URL('../fonts/NotoSansSC-Regular.ttf', import.meta.url)).then((res) => res.buffer);
   }
 
-  fontAll.supp.chi_sim = await loadFont('NotoSansSC', 'normal', 'sans', await chiSimSrc, false);
+  FontCont.supp.chi_sim = await loadFont('NotoSansSC', 'normal', 'sans', await chiSimSrc, false);
 
   chiReadyRes();
 
@@ -152,102 +152,89 @@ export async function loadChiSimFont() {
 }
 
 /**
- *
- * @param {boolean} enable
- * @param {boolean} [useInitial=false]
- * @param {boolean} [forceWorkerUpdate=false] - If true, forces the worker to update the font data even if the font data of this type is already loaded.
- *    This should be used when switching from unvalidated to validated optimized fonts.
+ * Enable or disable font optimization settings.
+ * This function is used rather than exposing the settings using the `opt` object, as these settings exist on the font container in both the main thread and the worker threads.
+ * @param {boolean} enableOpt
+ * @param {boolean} [forceOpt]
  */
-export async function enableFontOpt(enable, useInitial = false, forceWorkerUpdate = false) {
-  // Enable/disable optimized font
-  if (enable && useInitial && fontAll.optInitial) {
-    fontAll.active = fontAll.optInitial;
-  } else if (enable && fontAll.opt) {
-    fontAll.active = fontAll.opt;
-  } else {
-    fontAll.active = fontAll.raw;
+export async function enableFontOpt(enableOpt, forceOpt) {
+  let change = false;
+  if (enableOpt === true || enableOpt === false) {
+    if (FontCont.enableOpt !== enableOpt) {
+      change = true;
+      FontCont.enableOpt = enableOpt;
+    }
+  }
+  if (forceOpt === true || forceOpt === false) {
+    if (FontCont.forceOpt !== forceOpt) {
+      change = true;
+      FontCont.forceOpt = forceOpt;
+    }
   }
 
-  // Enable/disable optimized font in workers
-  if (typeof process === 'undefined') {
-    await setBuiltInFontsWorker(gs.schedulerInner, forceWorkerUpdate);
-  } else {
-    // const { setFontAll } = await import('./worker/compareOCRModule.js');
-    // setFontAll(fontAll);
+  if (typeof process === 'undefined' && change) {
+    await updateFontContWorkerMain();
   }
 }
 
 /**
- *
- * @param {*} scheduler
- * @param {boolean} [force=false] - If true, forces the worker to update the font data even if the font data of this type is already loaded.
+ * @param {Object} [params]
+ * @param {boolean} [params.loadRaw] - By default, raw fonts are loaded if they have not been loaded before.
+ *    Set `loadRaw` to `true` or `false` to force the raw fonts to be loaded or not loaded, respectively.
+ * @param {boolean} [params.loadOpt] - By default, optimized fonts are loaded if they have not been loaded before.
+ *   Set `loadOpt` to `true` or `false` to force the optimized fonts to be loaded or not loaded, respectively.
+ * @param {boolean} [params.updateProps]
  */
-export async function setBuiltInFontsWorker(scheduler, force = false) {
-  if (!fontAll.active) return;
-
-  const opt = fontAll.active.Carlito.normal.opt || fontAll.active.NimbusRomNo9L.normal.opt;
-
-  const loadedBuiltIn = (!opt && fontAll.loadedBuiltInRawWorker) || (opt && fontAll.loadedBuiltInOptWorker);
+export async function updateFontContWorkerMain(params = {}) {
+  const loadRaw = params.loadRaw === true || (params.loadRaw !== false && FontCont.raw && !gs.loadedBuiltInRawWorker);
+  const loadOpt = params.loadOpt === true || (params.loadOpt !== false && FontCont.opt && !gs.loadedBuiltInOptWorker);
 
   // If the active font data is not already loaded, load it now.
   // This assumes that only one version of the raw/optimized fonts ever exist--
   // it does not check whether the current optimized font changed since it was last loaded.
-  if (!loadedBuiltIn || force) {
+  for (const [type, load] of [['raw', loadRaw], ['opt', loadOpt]]) {
+    if (!load) continue;
+
     const resArr = [];
-    for (let i = 0; i < scheduler.workers.length; i++) {
-      const worker = scheduler.workers[i];
-      const res = worker.loadFontsWorker({
-        src: {
-          Carlito: {
-            normal: fontAll.active.Carlito.normal.src,
-            italic: fontAll.active.Carlito.italic.src,
-            bold: fontAll.active.Carlito.bold.src,
-          },
-          Century: {
-            normal: fontAll.active.Century.normal.src,
-            italic: fontAll.active.Century.italic.src,
-            bold: fontAll.active.Century.bold.src,
-          },
-          Garamond: {
-            normal: fontAll.active.Garamond.normal.src,
-            italic: fontAll.active.Garamond.italic.src,
-            bold: fontAll.active.Garamond.bold.src,
-          },
-          Palatino: {
-            normal: fontAll.active.Palatino.normal.src,
-            italic: fontAll.active.Palatino.italic.src,
-            bold: fontAll.active.Palatino.bold.src,
-          },
-          NimbusRomNo9L: {
-            normal: fontAll.active.NimbusRomNo9L.normal.src,
-            italic: fontAll.active.NimbusRomNo9L.italic.src,
-            bold: fontAll.active.NimbusRomNo9L.bold.src,
-          },
-          NimbusSans: {
-            normal: fontAll.active.NimbusSans.normal.src,
-            italic: fontAll.active.NimbusSans.italic.src,
-            bold: fontAll.active.NimbusSans.bold.src,
-          },
-        },
-        opt,
-      });
-      resArr.push(res);
+
+    const input = { opt: type === 'opt', src: {} };
+    for (const [key, value] of Object.entries(FontCont[type])) {
+      if (!value || !value.normal) continue;
+      input.src[key] = {
+        normal: value.normal.src,
+      };
+      if (value.italic) input.src[key].italic = value.italic.src;
+      if (value.bold) input.src[key].bold = value.bold.src;
     }
-    await Promise.all(resArr);
 
-    // Theoretically this should be changed to use promises to avoid the race condition when `setBuiltInFontsWorker` is called multiple times quickly and `loadFontsWorker` is still running.
-    if (opt) {
-      fontAll.loadedBuiltInOptWorker = true;
-    } else {
-      fontAll.loadedBuiltInRawWorker = true;
+    for (let i = 0; i < gs.schedulerInner.workers.length; i++) {
+      const worker = gs.schedulerInner.workers[i];
+      const res = worker.loadFontsWorker(input);
+      resArr.push(res);
+
+      // TODO: consider the race condition when `setBuiltInFontsWorkers` is called multiple times quickly and `loadFontsWorker` is still running.
+      if (type === 'opt') {
+        gs.loadedBuiltInOptWorker = true;
+      } else {
+        gs.loadedBuiltInRawWorker = true;
+      }
     }
+    await Promise.all(resArr);
   }
 
   // Set the active font in the workers to match the active font in `fontAll`
   const resArr = [];
-  for (let i = 0; i < scheduler.workers.length; i++) {
-    const worker = scheduler.workers[i];
-    const res = worker.setFontActiveWorker({ opt, sansDefaultName: fontAll.sansDefaultName, serifDefaultName: fontAll.serifDefaultName });
+  for (let i = 0; i < gs.schedulerInner.workers.length; i++) {
+    const worker = gs.schedulerInner.workers[i];
+    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,
+    });
     resArr.push(res);
   }
   await Promise.all(resArr);
@@ -255,15 +242,15 @@ export async function setBuiltInFontsWorker(scheduler, force = false) {
 
 /**
  * WIP: Import fonts embedded in PDFs.
- * This function is not currently used.
+ * This function is out of date and not currently used.
  * @param {*} scheduler
  */
 export async function setUploadFontsWorker(scheduler) {
-  if (!fontAll.active) return;
+  if (!FontCont.active) return;
 
   /** @type {Object<string, fontSrcBuiltIn|fontSrcUpload>} */
   const fontsUpload = {};
-  for (const [key, value] of Object.entries(fontAll.active)) {
+  for (const [key, value] of Object.entries(FontCont.active)) {
     if (!['Carlito', 'Century', 'Garamond', 'Palatino', 'NimbusRomNo9L', 'NimbusSans'].includes(key)) {
       fontsUpload[key] = {
         normal: value?.normal?.src, italic: value?.italic?.src, bold: value?.bold?.src,
@@ -286,10 +273,18 @@ export async function setUploadFontsWorker(scheduler) {
 
   // Set the active font in the workers to match the active font in `fontAll`
   const resArr = [];
-  const opt = fontAll.active.Carlito.normal.opt || fontAll.active.NimbusRomNo9L.normal.opt;
+  const opt = FontCont.active.Carlito.normal.opt || FontCont.active.NimbusRomNo9L.normal.opt;
   for (let i = 0; i < scheduler.workers.length; i++) {
     const worker = scheduler.workers[i];
-    const res = worker.setFontActiveWorker({ opt, sansDefaultName: fontAll.sansDefaultName, serifDefaultName: fontAll.serifDefaultName });
+    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,
+    });
     resArr.push(res);
   }
   await Promise.all(resArr);
@@ -307,15 +302,15 @@ export function setDefaultFontAuto(fontMetricsObj) {
 
   // Change default font to whatever named font appears more
   if ((fontMetricsObj.SerifDefault?.obs || 0) > (fontMetricsObj.SansDefault?.obs || 0)) {
-    fontAll.defaultFontName = 'SerifDefault';
+    FontCont.defaultFontName = 'SerifDefault';
   } else {
-    fontAll.defaultFontName = 'SansDefault';
+    FontCont.defaultFontName = 'SansDefault';
   }
 
   if (gs.schedulerInner) {
     for (let i = 0; i < gs.schedulerInner.workers.length; i++) {
       const worker = gs.schedulerInner.workers[i];
-      worker.setDefaultFontNameWorker({ defaultFontName: fontAll.defaultFontName });
+      worker.updateFontContWorker({ defaultFontName: FontCont.defaultFontName });
     }
   }
 }
@@ -342,14 +337,8 @@ export async function optimizeFontContainerFamily(fontFamily, fontMetricsObj) {
 
   // 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]) {
-    const opentypeFontArr = await Promise.all([loadOpentype(fontFamily.normal.src, null), loadOpentype(fontFamily.italic.src, null), loadOpentype(fontFamily.bold.src, null)]);
-    const normalOptFont = new FontContainerFont(fontFamily.normal.family, fontFamily.normal.style, fontFamily.normal.src, true, opentypeFontArr[0]);
-    const italicOptFont = new FontContainerFont(fontFamily.italic.family, fontFamily.italic.style, fontFamily.italic.src, true, opentypeFontArr[1]);
-    const boldOptFont = new FontContainerFont(fontFamily.bold.family, fontFamily.bold.style, fontFamily.bold.src, true, opentypeFontArr[2]);
-    return {
-      normal: await normalOptFont, italic: await italicOptFont, bold: await boldOptFont,
-    };
+  if (!fontMetricsObj[fontMetricsType] || !fontMetricsObj[fontMetricsType][fontFamily.normal.style] || fontMetricsObj[fontMetricsType][fontFamily.normal.style].obs < 200) {
+    return null;
   }
 
   const metricsNormal = fontMetricsObj[fontMetricsType][fontFamily.normal.style];
@@ -360,29 +349,25 @@ export async function optimizeFontContainerFamily(fontFamily, fontMetricsObj) {
     });
 
   const metricsItalic = fontMetricsObj[fontMetricsType][fontFamily.italic.style];
-  /** @type {FontContainerFont|Promise<FontContainerFont>} */
-  let italicOptFont;
-  if (metricsItalic) {
+  /** @type {?FontContainerFont|Promise<FontContainerFont>} */
+  let italicOptFont = null;
+  if (metricsItalic && metricsItalic.obs >= 200) {
     italicOptFont = gs.scheduler.optimizeFont({ fontData: fontFamily.italic.src, fontMetricsObj: 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);
       });
-  } else {
-    const font = await loadOpentype(fontFamily.italic.src, null);
-    italicOptFont = new FontContainerFont(fontFamily.italic.family, fontFamily.italic.style, fontFamily.italic.src, true, font);
   }
 
   // Bold fonts are not optimized, as we currently have no accurate way to determine if characters are bold within OCR, so do not have bold metrics.
-  const boldOptFont = loadOpentype(fontFamily.bold.src, null).then((opentypeFont) => new FontContainerFont(fontFamily.bold.family, fontFamily.bold.style, fontFamily.bold.src, true, opentypeFont));
-
   return {
-    normal: await normalOptFont, italic: await italicOptFont, bold: await boldOptFont,
+    normal: await normalOptFont, italic: await italicOptFont, bold: null,
   };
 }
 
 /**
  * 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
  */
@@ -396,6 +381,8 @@ export async function optimizeFontContainerAll(fontPrivate, fontMetricsObj) {
 
   const results = await Promise.all([carlitoPromise, centuryPromise, garamondPromise, palatinoPromise, nimbusRomNo9LPromise, nimbusSansPromise]);
 
+  if (results.every((x) => x === null)) return null;
+
   return {
     Carlito: results[0],
     Century: results[1],

package/js/fontEval.js

@@ -1,20 +1,21 @@
-import { DebugData, fontMetricsObj, pageMetricsArr } from './containers/dataContainer.js';
-import { fontAll } from './containers/fontContainer.js';
+import { fontMetricsObj, pageMetricsArr } from './containers/dataContainer.js';
+import { FontCont } from './containers/fontContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
 import {
-  enableFontOpt,
   loadBuiltInFontsRaw,
   optimizeFontContainerAll, setDefaultFontAuto,
+  updateFontContWorkerMain,
 } from './fontContainerMain.js';
 import { gs } from './generalWorkerMain.js';
 
 /**
- *
- * @param {FontContainerFamily} font
+ * Evaluate how well a font matches the provided array of pages.
+ * @param {string} font - Name of font family.
  * @param {Array<OcrPage>} pageArr
+ * @param {boolean} opt - Whether to use optimized fonts.
  * @param {number} n - Number of words to compare
  */
-export async function evalPageFonts(font, pageArr, n = 500) {
+export async function evalPagesFont(font, pageArr, opt, n = 500) {
   if (!gs.scheduler) throw new Error('GeneralScheduler must be defined before this function can run.');
 
   let metricTotal = 0;
@@ -25,25 +26,27 @@ export async function evalPageFonts(font, pageArr, n = 500) {
 
     const imageI = await ImageCache.getBinary(i);
 
-    // The Node.js canvas package does not currently support worke threads
+    // The Node.js canvas package does not currently support worker threads
     // https://github.com/Automattic/node-canvas/issues/1394
     let res;
     if (!(typeof process === 'undefined')) {
       const { evalPageFont } = await import('./worker/compareOCRModule.js');
 
       res = await evalPageFont({
-        font: font.normal.family,
+        font,
         page: pageArr[i],
         binaryImage: imageI,
         pageMetricsObj: pageMetricsArr[i],
+        opt,
       });
       // Browser case
     } else {
       res = await gs.scheduler.evalPageFont({
-        font: font.normal.family,
+        font,
         page: pageArr[i],
         binaryImage: imageI,
         pageMetricsObj: pageMetricsArr[i],
+        opt,
       });
     }
 
@@ -56,28 +59,31 @@ export async function evalPageFonts(font, pageArr, n = 500) {
 
 /**
 * @param {Array<OcrPage>} pageArr
+* @param {boolean} opt - Whether to use optimized fonts.
 */
-export async function evaluateFonts(pageArr) {
-  const fontActive = fontAll.getContainer('active');
-
-  const debug = false;
+export async function evaluateFonts(pageArr, opt) {
+  const evalCarlito = !!(opt ? FontCont.opt?.Carlito : FontCont.raw?.Carlito);
+  const evalNimbusSans = !!(opt ? FontCont.opt?.NimbusSans : FontCont.raw?.NimbusSans);
+  const evalCentury = !!(opt ? FontCont.opt?.Century : FontCont.raw?.Century);
+  const evalPalatino = !!(opt ? FontCont.opt?.Palatino : FontCont.raw?.Palatino);
+  const evalGaramond = !!(opt ? FontCont.opt?.Garamond : FontCont.raw?.Garamond);
+  const evalNimbusRomNo9L = !!(opt ? FontCont.opt?.NimbusRomNo9L : FontCont.raw?.NimbusRomNo9L);
 
   // The browser version runs in parallel using workers, however the Node.js version runs sequentially,
   // as the canvas package does not support workers, and trying to run in parallel causes problems.
   // The logic is the same in both versions.
-  let sansMetrics;
-  let serifMetrics;
+  let fontMetricsTmp;
   if (typeof process === 'undefined') {
     const fontMetricsPromises = {
-      carlito: evalPageFonts(fontActive.Carlito, pageArr),
-      nimbusSans: evalPageFonts(fontActive.NimbusSans, pageArr),
-      century: evalPageFonts(fontActive.Century, pageArr),
-      palatino: evalPageFonts(fontActive.Palatino, pageArr),
-      garamond: evalPageFonts(fontActive.Garamond, pageArr),
-      nimbusRomNo9L: evalPageFonts(fontActive.NimbusRomNo9L, pageArr),
+      carlito: evalCarlito ? evalPagesFont('Carlito', pageArr, opt) : null,
+      nimbusSans: evalNimbusSans ? evalPagesFont('NimbusSans', pageArr, opt) : null,
+      century: evalCentury ? evalPagesFont('Century', pageArr, opt) : null,
+      palatino: evalPalatino ? evalPagesFont('Palatino', pageArr, opt) : null,
+      garamond: evalGaramond ? evalPagesFont('Garamond', pageArr, opt) : null,
+      nimbusRomNo9L: evalNimbusRomNo9L ? evalPagesFont('NimbusRomNo9L', pageArr, opt) : null,
     };
 
-    const fontMetrics = {
+    fontMetricsTmp = {
       carlito: await fontMetricsPromises.carlito,
       nimbusSans: await fontMetricsPromises.nimbusSans,
       century: await fontMetricsPromises.century,
@@ -85,46 +91,39 @@ export async function evaluateFonts(pageArr) {
       garamond: await fontMetricsPromises.garamond,
       nimbusRomNo9L: await fontMetricsPromises.nimbusRomNo9L,
     };
-
-    sansMetrics = {
-      Carlito: fontMetrics.carlito.metricTotal / fontMetrics.carlito.wordsTotal,
-      NimbusSans: fontMetrics.nimbusSans.metricTotal / fontMetrics.nimbusSans.wordsTotal,
-    };
-
-    serifMetrics = {
-      Century: fontMetrics.century.metricTotal / fontMetrics.century.wordsTotal,
-      Palatino: fontMetrics.palatino.metricTotal / fontMetrics.palatino.wordsTotal,
-      Garamond: fontMetrics.garamond.metricTotal / fontMetrics.garamond.wordsTotal,
-      NimbusRomNo9L: fontMetrics.nimbusRomNo9L.metricTotal / fontMetrics.nimbusRomNo9L.wordsTotal,
-    };
   } else {
-    const fontMetrics = {
-      Carlito: await evalPageFonts(fontActive.Carlito, pageArr),
-      NimbusSans: await evalPageFonts(fontActive.NimbusSans, pageArr),
-      Century: await evalPageFonts(fontActive.Century, pageArr),
-      Palatino: await evalPageFonts(fontActive.Palatino, pageArr),
-      Garamond: await evalPageFonts(fontActive.Garamond, pageArr),
-      NimbusRomNo9L: await evalPageFonts(fontActive.NimbusRomNo9L, pageArr),
+    fontMetricsTmp = {
+      carlito: evalCarlito ? await evalPagesFont('Carlito', pageArr, opt) : null,
+      nimbusSans: evalNimbusSans ? await evalPagesFont('NimbusSans', pageArr, opt) : null,
+      century: evalCentury ? await evalPagesFont('Century', pageArr, opt) : null,
+      palatino: evalPalatino ? await evalPagesFont('Palatino', pageArr, opt) : null,
+      garamond: evalGaramond ? await evalPagesFont('Garamond', pageArr, opt) : null,
+      nimbusRomNo9L: evalNimbusRomNo9L ? await evalPagesFont('NimbusRomNo9L', pageArr, opt) : null,
     };
+  }
 
-    sansMetrics = {
-      Carlito: fontMetrics.Carlito.metricTotal / fontMetrics.Carlito.wordsTotal,
-      NimbusSans: fontMetrics.NimbusSans.metricTotal / fontMetrics.NimbusSans.wordsTotal,
-    };
+  const fontMetrics = {
+    Carlito: fontMetricsTmp.carlito ? fontMetricsTmp.carlito.metricTotal / fontMetricsTmp.carlito.wordsTotal : null,
+    NimbusSans: fontMetricsTmp.nimbusSans ? fontMetricsTmp.nimbusSans.metricTotal / fontMetricsTmp.nimbusSans.wordsTotal : null,
+    Century: fontMetricsTmp.century ? fontMetricsTmp.century.metricTotal / fontMetricsTmp.century.wordsTotal : null,
+    Palatino: fontMetricsTmp.palatino ? fontMetricsTmp.palatino.metricTotal / fontMetricsTmp.palatino.wordsTotal : null,
+    Garamond: fontMetricsTmp.garamond ? fontMetricsTmp.garamond.metricTotal / fontMetricsTmp.garamond.wordsTotal : null,
+    NimbusRomNo9L: fontMetricsTmp.nimbusRomNo9L ? fontMetricsTmp.nimbusRomNo9L.metricTotal / fontMetricsTmp.nimbusRomNo9L.wordsTotal : null,
+  };
 
-    serifMetrics = {
-      Century: fontMetrics.Century.metricTotal / fontMetrics.Century.wordsTotal,
-      Palatino: fontMetrics.Palatino.metricTotal / fontMetrics.Palatino.wordsTotal,
-      Garamond: fontMetrics.Garamond.metricTotal / fontMetrics.Garamond.wordsTotal,
-      NimbusRomNo9L: fontMetrics.NimbusRomNo9L.metricTotal / fontMetrics.NimbusRomNo9L.wordsTotal,
-    };
-  }
+  return fontMetrics;
+}
 
+/**
+ *
+ * @param {Awaited<ReturnType<evaluateFonts>>} fontMetrics
+ */
+const calcBestFonts = (fontMetrics) => {
   let minKeySans = 'NimbusSans';
   let minValueSans = Number.MAX_VALUE;
 
-  for (const [key, value] of Object.entries(sansMetrics)) {
-    if (debug) console.log(`${key} metric: ${String(value)}`);
+  for (const [key, value] of Object.entries(fontMetrics)) {
+    if (!['Carlito', 'NimbusSans'].includes(key)) continue;
     if (value < minValueSans) {
       minValueSans = value;
       minKeySans = key;
@@ -134,8 +133,8 @@ export async function evaluateFonts(pageArr) {
   let minKeySerif = 'NimbusRomNo9L';
   let minValueSerif = Number.MAX_VALUE;
 
-  for (const [key, value] of Object.entries(serifMetrics)) {
-    if (debug) console.log(`${key} metric: ${String(value)}`);
+  for (const [key, value] of Object.entries(fontMetrics)) {
+    if (!['Century', 'Palatino', 'Garamond', 'NimbusRomNo9L'].includes(key)) continue;
     if (value < minValueSerif) {
       minValueSerif = value;
       minKeySerif = key;
@@ -143,12 +142,10 @@ export async function evaluateFonts(pageArr) {
   }
 
   return {
-    sansMetrics,
-    serifMetrics,
     minKeySans,
     minKeySerif,
   };
-}
+};
 
 /**
  * Runs font optimization and validation. Sets `fontAll` defaults to best fonts,
@@ -164,24 +161,19 @@ export async function evaluateFonts(pageArr) {
 export async function runFontOptimization(ocrArr) {
   await loadBuiltInFontsRaw();
 
-  const fontRaw = fontAll.getContainer('raw');
-
   const calculateOpt = fontMetricsObj && Object.keys(fontMetricsObj).length > 0;
 
   let enableOptSerif = false;
   let enableOptSans = false;
 
+  let optimizeFontContainerAllPromise;
   if (calculateOpt) {
     setDefaultFontAuto(fontMetricsObj);
-    fontAll.optInitial = await optimizeFontContainerAll(fontRaw, fontMetricsObj);
-
-    // If no image data exists, then `opt` is set to `optInitial`.
-    // This behavior exists so that data can be loaded from previous sessions without changing the appearance of the document.
-    // Arguably, in cases where a user uploads raw OCR data and no images, using the raw font is more prudent than an unvalidated optimized font.
-    // If this ever comes up in actual usage and is a problem, then the behavior can be changed for that specific case.
-    if (!ImageCache.inputModes.image && !ImageCache.inputModes.pdf) {
-      fontAll.opt = { ...fontAll.optInitial };
-    }
+
+    optimizeFontContainerAllPromise = optimizeFontContainerAll(FontCont.raw, fontMetricsObj)
+      .then((res) => {
+        FontCont.opt = res;
+      });
   }
 
   // If image data exists, select the correct font by comparing to the image.
@@ -189,70 +181,50 @@ export async function runFontOptimization(ocrArr) {
     // Evaluate default fonts using up to 5 pages.
     const pageNum = Math.min(ImageCache.pageCount, 5);
 
-    // Set raw font in workers
-    await enableFontOpt(false);
-
     // This step needs to happen here as all fonts must be registered before initializing the canvas.
     if (!(typeof process === 'undefined')) {
+      await optimizeFontContainerAllPromise;
       const { initCanvasNode } = await import('./worker/compareOCRModule.js');
       await initCanvasNode();
     }
 
-    const evalRaw = await evaluateFonts(ocrArr.slice(0, pageNum));
-
-    DebugData.evalRaw = evalRaw;
+    FontCont.rawMetrics = await evaluateFonts(ocrArr.slice(0, pageNum), false);
+    const bestMetricsRaw = calcBestFonts(FontCont.rawMetrics);
 
-    if (calculateOpt && Object.keys(fontAll.optInitial).length > 0) {
-      // Enable optimized fonts
-      await enableFontOpt(true, true, true);
+    await optimizeFontContainerAllPromise;
+    if (FontCont.opt && Object.keys(FontCont.opt).length > 0) {
+      await updateFontContWorkerMain();
 
-      const evalOpt = await evaluateFonts(ocrArr.slice(0, pageNum));
+      FontCont.optMetrics = await evaluateFonts(ocrArr.slice(0, pageNum), true);
 
-      DebugData.evalOpt = evalOpt;
+      const bestMetricsOpt = calcBestFonts(FontCont.optMetrics);
 
       // The default font for both the optimized and unoptimized versions are set to the same font.
       // This ensures that switching on/off "font optimization" does not change the font, which would be confusing.
-      if (evalOpt.sansMetrics[evalOpt.minKeySans] < evalRaw.sansMetrics[evalRaw.minKeySans]) {
-        fontAll.sansDefaultName = evalOpt.minKeySans;
+      if (FontCont.optMetrics[bestMetricsOpt.minKeySans] < FontCont.rawMetrics[bestMetricsRaw.minKeySans]) {
         enableOptSans = true;
+        FontCont.sansDefaultName = bestMetricsOpt.minKeySans;
       } else {
-        fontAll.sansDefaultName = evalRaw.minKeySans;
+        FontCont.sansDefaultName = bestMetricsRaw.minKeySans;
       }
 
       // Repeat for serif fonts
-      if (evalOpt.serifMetrics[evalOpt.minKeySerif] < evalRaw.serifMetrics[evalRaw.minKeySerif]) {
-        fontAll.serifDefaultName = evalOpt.minKeySerif;
+      if (FontCont.optMetrics[bestMetricsOpt.minKeySerif] < FontCont.rawMetrics[bestMetricsRaw.minKeySerif]) {
         enableOptSerif = true;
+        FontCont.serifDefaultName = bestMetricsOpt.minKeySerif;
       } else {
-        fontAll.serifDefaultName = evalRaw.minKeySerif;
-      }
-
-      // Create final optimized font object.
-      // The final optimized font is set to either the initial optimized font or the raw font depending on what fits better.
-      // Make shallow copy to allow for changing individual fonts without copying the entire object.
-      fontAll.opt = { ...fontAll.optInitial };
-
-      if (!enableOptSans) {
-        fontAll.opt.Carlito = fontRaw.Carlito;
-        fontAll.opt.NimbusSans = fontRaw.NimbusSans;
-      }
-
-      if (!enableOptSerif) {
-        fontAll.opt.Century = fontRaw.Century;
-        fontAll.opt.Garamond = fontRaw.Garamond;
-        fontAll.opt.NimbusRomNo9L = fontRaw.NimbusRomNo9L;
-        fontAll.opt.Palatino = fontRaw.Palatino;
+        FontCont.serifDefaultName = bestMetricsRaw.minKeySerif;
       }
     } else {
-      fontAll.sansDefaultName = evalRaw.minKeySans;
-      fontAll.serifDefaultName = evalRaw.minKeySerif;
+      FontCont.sansDefaultName = bestMetricsRaw.minKeySans;
+      FontCont.serifDefaultName = bestMetricsRaw.minKeySerif;
     }
-  }
 
-  // Set final fonts in workers
-  await enableFontOpt(true, false, true);
+    FontCont.enableOpt = enableOptSerif || enableOptSans;
 
-  const enableOpt = enableOptSerif || enableOptSans;
+    // Send updated state to all workers.
+    await updateFontContWorkerMain();
+  }
 
-  return enableOpt;
+  return FontCont.enableOpt;
 }