scribe.js-ocr 0.7.4 → 0.9.0

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.
@@ -49,6 +49,10 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
   let /** @type {Promise<ArrayBuffer>} */nimbusMonoItalic;
   let /** @type {Promise<ArrayBuffer>} */nimbusMonoBold;
   let /** @type {Promise<ArrayBuffer>} */nimbusMonoBoldItalic;
+  let /** @type {Promise<ArrayBuffer>} */gothicNormal;
+  let /** @type {Promise<ArrayBuffer>} */gothicItalic;
+  let /** @type {Promise<ArrayBuffer>} */gothicBold;
+  let /** @type {Promise<ArrayBuffer>} */gothicBoldItalic;
   if (typeof process === 'undefined') {
     if (glyphSet === 'latin') {
       carlitoNormal = fetch(new URL('../fonts/latin/Carlito-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
@@ -79,6 +83,10 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
       nimbusMonoItalic = fetch(new URL('../fonts/latin/NimbusMono-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusMonoBold = fetch(new URL('../fonts/latin/NimbusMono-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusMonoBoldItalic = fetch(new URL('../fonts/latin/NimbusMono-BoldItalic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicNormal = fetch(new URL('../fonts/latin/URWGothicBook-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicItalic = fetch(new URL('../fonts/latin/URWGothicBook-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicBold = fetch(new URL('../fonts/latin/URWGothicBook-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicBoldItalic = fetch(new URL('../fonts/latin/URWGothicBook-BoldItalic.woff', import.meta.url)).then((res) => res.arrayBuffer());
     } else {
       carlitoNormal = fetch(new URL('../fonts/all/Carlito-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
       carlitoItalic = fetch(new URL('../fonts/all/Carlito-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
@@ -108,9 +116,13 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
       nimbusMonoItalic = fetch(new URL('../fonts/all/NimbusMono-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusMonoBold = fetch(new URL('../fonts/all/NimbusMono-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusMonoBoldItalic = fetch(new URL('../fonts/all/NimbusMono-BoldItalic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicNormal = fetch(new URL('../fonts/all/URWGothicBook-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicItalic = fetch(new URL('../fonts/all/URWGothicBook-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicBold = fetch(new URL('../fonts/all/URWGothicBook-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      gothicBoldItalic = fetch(new URL('../fonts/all/URWGothicBook-BoldItalic.woff', import.meta.url)).then((res) => res.arrayBuffer());
     }
   } else {
-    const { readFile } = await import('fs/promises');
+    const { readFile } = await import('node:fs/promises');
     carlitoNormal = readFile(new URL('../fonts/all/Carlito-Regular.woff', import.meta.url)).then((res) => res.buffer);
     carlitoItalic = readFile(new URL('../fonts/all/Carlito-Italic.woff', import.meta.url)).then((res) => res.buffer);
     carlitoBold = readFile(new URL('../fonts/all/Carlito-Bold.woff', import.meta.url)).then((res) => res.buffer);
@@ -139,6 +151,10 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
     nimbusMonoItalic = readFile(new URL('../fonts/all/NimbusMono-Italic.woff', import.meta.url)).then((res) => res.buffer);
     nimbusMonoBold = readFile(new URL('../fonts/all/NimbusMono-Bold.woff', import.meta.url)).then((res) => res.buffer);
     nimbusMonoBoldItalic = readFile(new URL('../fonts/all/NimbusMono-BoldItalic.woff', import.meta.url)).then((res) => res.buffer);
+    gothicNormal = readFile(new URL('../fonts/all/URWGothicBook-Regular.woff', import.meta.url)).then((res) => res.buffer);
+    gothicItalic = readFile(new URL('../fonts/all/URWGothicBook-Italic.woff', import.meta.url)).then((res) => res.buffer);
+    gothicBold = readFile(new URL('../fonts/all/URWGothicBook-Bold.woff', import.meta.url)).then((res) => res.buffer);
+    gothicBoldItalic = readFile(new URL('../fonts/all/URWGothicBook-BoldItalic.woff', import.meta.url)).then((res) => res.buffer);
   }
 
   const srcObj = {
@@ -151,6 +167,9 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
     Garamond: {
       normal: await garamondNormal, italic: await garamondItalic, bold: await garamondBold, boldItalic: await garamondBoldItalic,
     },
+    Gothic: {
+      normal: await gothicNormal, italic: await gothicItalic, bold: await gothicBold, boldItalic: await gothicBoldItalic,
+    },
     Palatino: {
       normal: await palatinoNormal, italic: await palatinoItalic, bold: await palatinoBold, boldItalic: await palatinoBoldItalic,
     },
@@ -193,7 +212,7 @@ export async function loadChiSimFont() {
   if (typeof process === 'undefined') {
     chiSimSrc = fetch(new URL('../fonts/NotoSansSC-Regular.ttf', import.meta.url)).then((res) => res.arrayBuffer());
   } else {
-    const { readFile } = await import('fs/promises');
+    const { readFile } = await import('node:fs/promises');
     chiSimSrc = readFile(new URL('../fonts/NotoSansSC-Regular.ttf', import.meta.url)).then((res) => res.buffer);
   }
 
@@ -204,6 +223,35 @@ export async function loadChiSimFont() {
   return chiReady;
 }
 
+let dingbatsReadyRes;
+let dingbatsReady;
+
+/**
+ * Loads dingbats font. Returns early if already loaded.
+ */
+export async function loadDingbatsFont() {
+  console.log('Loading Dingbats font');
+  if (dingbatsReady) return dingbatsReady;
+
+  dingbatsReady = new Promise((resolve, reject) => {
+    dingbatsReadyRes = resolve;
+  });
+
+  let /** @type {Promise<ArrayBuffer>} */ dingbatsSrc;
+  if (typeof process === 'undefined') {
+    dingbatsSrc = fetch(new URL('../fonts/Dingbats.woff', import.meta.url)).then((res) => res.arrayBuffer());
+  } else {
+    const { readFile } = await import('node:fs/promises');
+    dingbatsSrc = readFile(new URL('../fonts/Dingbats.woff', import.meta.url)).then((res) => res.buffer);
+  }
+
+  FontCont.supp.dingbats = await loadFont('Dingbats', 'normal', 'sans', await dingbatsSrc, false);
+
+  dingbatsReadyRes();
+
+  return dingbatsReady;
+}
+
 /**
  * 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.
@@ -213,15 +261,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 +334,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 +384,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 +399,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 +423,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,18 +472,20 @@ 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);
-
-  const results = await Promise.all([carlitoPromise, centuryPromise, garamondPromise, palatinoPromise, nimbusRomanPromise, nimbusSansPromise, nimbusMonoPromise]);
+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 gothicPromise = optimizeFontContainerFamily(fontPrivate.Gothic, 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, gothicPromise,
+    palatinoPromise, nimbusRomanPromise, nimbusSansPromise, nimbusMonoPromise]);
 
   if (results.every((x) => x === null)) return null;
 
@@ -443,9 +493,10 @@ export async function optimizeFontContainerAll(fontPrivate, fontMetricsObj) {
     Carlito: results[0],
     Century: results[1],
     Garamond: results[2],
-    Palatino: results[3],
-    NimbusRoman: results[4],
-    NimbusSans: results[5],
-    NimbusMono: results[6],
+    Gothic: results[3],
+    Palatino: results[4],
+    NimbusRoman: results[5],
+    NimbusSans: results[6],
+    NimbusMono: results[7],
   };
 }

package/js/fontEval.js

@@ -1,4 +1,4 @@
-import { fontMetricsObj, pageMetricsArr } from './containers/dataContainer.js';
+import { pageMetricsAll } from './containers/dataContainer.js';
 import { FontCont } from './containers/fontContainer.js';
 import { ImageCache } from './containers/imageContainer.js';
 import {
@@ -28,7 +28,7 @@ export async function evalPagesFont(font, pageArr, opt, n = 500) {
       font,
       page: pageArr[i],
       binaryImage: imageI,
-      pageMetricsObj: pageMetricsArr[i],
+      pageMetricsObj: pageMetricsAll[i],
       opt,
     });
 
@@ -49,6 +49,7 @@ export async function evaluateFonts(pageArr, opt) {
   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 evalGothic = !!(opt ? FontCont.opt?.Gothic : FontCont.raw?.Gothic);
   const evalNimbusRoman = !!(opt ? FontCont.opt?.NimbusRoman : FontCont.raw?.NimbusRoman);
   const evalNimbusMono = !!(opt ? FontCont.opt?.NimbusMono : FontCont.raw?.NimbusMono);
 
@@ -58,6 +59,7 @@ export async function evaluateFonts(pageArr, opt) {
     century: evalCentury ? evalPagesFont('Century', pageArr, opt) : null,
     palatino: evalPalatino ? evalPagesFont('Palatino', pageArr, opt) : null,
     garamond: evalGaramond ? evalPagesFont('Garamond', pageArr, opt) : null,
+    gothic: evalGothic ? evalPagesFont('Gothic', pageArr, opt) : null,
     nimbusRoman: evalNimbusRoman ? evalPagesFont('NimbusRoman', pageArr, opt) : null,
     nimbusMono: evalNimbusMono ? evalPagesFont('NimbusMono', pageArr, opt) : null,
   };
@@ -68,6 +70,7 @@ export async function evaluateFonts(pageArr, opt) {
     century: await fontMetricsPromises.century,
     palatino: await fontMetricsPromises.palatino,
     garamond: await fontMetricsPromises.garamond,
+    gothic: await fontMetricsPromises.gothic,
     nimbusRoman: await fontMetricsPromises.nimbusRoman,
     nimbusMono: await fontMetricsPromises.nimbusMono,
   };
@@ -78,6 +81,7 @@ export async function evaluateFonts(pageArr, opt) {
     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,
+    Gothic: fontMetricsTmp.gothic ? fontMetricsTmp.gothic.metricTotal / fontMetricsTmp.gothic.wordsTotal : null,
     NimbusRoman: fontMetricsTmp.nimbusRoman ? fontMetricsTmp.nimbusRoman.metricTotal / fontMetricsTmp.nimbusRoman.wordsTotal : null,
     NimbusMono: fontMetricsTmp.nimbusMono ? fontMetricsTmp.nimbusMono.metricTotal / fontMetricsTmp.nimbusMono.wordsTotal : null,
   };
@@ -94,7 +98,7 @@ const calcBestFonts = (fontMetrics) => {
   let minValueSans = Number.MAX_VALUE;
 
   for (const [key, value] of Object.entries(fontMetrics)) {
-    if (!['Carlito', 'NimbusSans'].includes(key)) continue;
+    if (!['Carlito', 'Gothic', 'NimbusSans'].includes(key)) continue;
     if (value && value < minValueSans) {
       minValueSans = value;
       minKeySans = key;
@@ -132,16 +136,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 +171,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;
 }