scribe.js-ocr 0.7.1 → 0.7.2

package/js/containers/app.js

@@ -29,6 +29,8 @@ export class opt {
 
   static reflow = true;
 
+  static removeMargins = false;
+
   static pageBreaks = true;
 
   /** @type {("invis"|"ebook"|"eval"|"proof")} */

package/js/containers/fontContainer.js

@@ -264,7 +264,7 @@ export class FontCont {
 
   static defaultFontName = 'SerifDefault';
 
-  static serifDefaultName = 'NimbusRomNo9L';
+  static serifDefaultName = 'NimbusRoman';
 
   static sansDefaultName = 'NimbusSans';
 
@@ -388,8 +388,12 @@ 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 (/Times/i.test(family)) {
-        family = 'NimbusRomNo9L';
+      if (/NimbusRom/i.test(family)) {
+        family = 'NimbusRoman';
+      } else if (/Times/i.test(family)) {
+        family = 'NimbusRoman';
+      } else if (/NimbusSan/i.test(family)) {
+        family = 'NimbusSans';
       } else if (/Helvetica/i.test(family)) {
         family = 'NimbusSans';
       } else if (/Arial/i.test(family)) {
@@ -406,6 +410,8 @@ export class FontCont {
         family = 'Carlito';
       } else if (/Courier/i.test(family) && FontCont.enableCleanToNimbusMono) {
         family = 'NimbusMono';
+      } else if (/NimbusMono/i.test(family) && FontCont.enableCleanToNimbusMono) {
+        family = 'NimbusMono';
       }
     }
 
@@ -451,7 +457,7 @@ export class FontCont {
     FontCont.enableCleanToNimbusMono = false;
 
     FontCont.defaultFontName = 'SerifDefault';
-    FontCont.serifDefaultName = 'NimbusRomNo9L';
+    FontCont.serifDefaultName = 'NimbusRoman';
     FontCont.sansDefaultName = 'NimbusSans';
   };
 

package/js/export/export.js

@@ -8,11 +8,12 @@ import { saveAs } from '../utils/miscUtils.js';
 import { writePdf } from './writePdf.js';
 import { writeHocr } from './writeHocr.js';
 import { writeText } from './writeText.js';
+import { writeHtml } from './writeHtml.js';
 
 /**
  * Export active OCR data to specified format.
  * @public
- * @param {'pdf'|'hocr'|'docx'|'xlsx'|'txt'|'text'} [format='txt']
+ * @param {'pdf'|'hocr'|'docx'|'html'|'xlsx'|'txt'|'text'} [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,6 +184,8 @@ export async function exportData(format = 'txt', minPage = 0, maxPage = -1) {
     }
   } else if (format === 'hocr') {
     content = writeHocr(ocrAll.active, minPage, maxPage);
+  } else if (format === 'html') {
+    content = writeHtml(ocrAll.active, 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.

package/js/export/writeHtml.js

@@ -0,0 +1,223 @@
+import { FontCont } from '../containers/fontContainer.js';
+import { opt } from '../containers/app.js';
+import { calcWordMetrics } from '../utils/fontUtils.js';
+import { assignParagraphs } from '../utils/reflowPars.js';
+import { pageMetricsArr } from '../containers/dataContainer.js';
+import ocr from '../objects/ocrObjects.js';
+
+/**
+ *
+ * @param {string} text
+ * @param {number} fontSizeHTMLSmallCaps
+ */
+const makeSmallCapsDivs = (text, fontSizeHTMLSmallCaps) => {
+  const textDivs0 = text.match(/([a-z]+)|([^a-z]+)/g);
+  if (!textDivs0) return '';
+  const textDivs = textDivs0.map((x) => {
+    const lower = /[a-z]/.test(x);
+    const styleStr = lower ? `style="font-size:${fontSizeHTMLSmallCaps}px"` : '';
+    return `<span class="input-sub" ${styleStr}>${x}</span>`;
+  });
+  return textDivs.join('');
+};
+
+/**
+ * Convert an array of ocrPage objects to HTML.
+ *
+ * @param {Array<OcrPage>} ocrCurrent -
+ * @param {number} minpage - The first page to include in the document.
+ * @param {number} maxpage - The last page to include in the document.
+ * @param {boolean} reflowText - Remove line breaks within what appears to be the same paragraph.
+ * @param {boolean} removeMargins - Remove the margins from the text.
+ * @param {?Array<string>} wordIds - An array of word IDs to include in the document.
+ *    If omitted, all words are included.
+ */
+export function writeHtml(ocrCurrent, minpage = 0, maxpage = -1, reflowText = false, removeMargins = false, wordIds = null) {
+  if (!(typeof process === 'undefined')) {
+    throw new Error('HTML exports are not supported in Node.js');
+  }
+
+  const canvas = new OffscreenCanvas(1, 1);
+  const ctx = /** @type {OffscreenCanvasRenderingContext2D} */ (canvas.getContext('2d'));
+
+  const fontsUsed = new Set();
+
+  const pad = 5;
+
+  let bodyStr = '<body>';
+
+  if (maxpage === -1) maxpage = ocrCurrent.length - 1;
+
+  let newLine = false;
+
+  let top = 0;
+
+  for (let g = minpage; g <= maxpage; g++) {
+    if (!ocrCurrent[g] || ocrCurrent[g].lines.length === 0) continue;
+
+    const pageObj = ocrCurrent[g];
+
+    let minLeft = 0;
+    let minTop = 0;
+    let maxBottom = 0;
+    if (removeMargins) {
+      const wordArr = ocr.getPageWords(pageObj);
+      for (let h = 0; h < wordArr.length; h++) {
+        const wordObj = wordArr[h];
+        if (wordIds && !wordIds.includes(wordObj.id)) continue;
+        if (minLeft === 0 || wordObj.bbox.left < minLeft) minLeft = wordObj.bbox.left;
+        if (minTop === 0 || wordObj.bbox.top < minTop) minTop = wordObj.bbox.top;
+        if (wordObj.bbox.bottom > maxBottom) maxBottom = wordObj.bbox.bottom;
+      }
+    }
+
+    bodyStr += `<div class="scribe-page" id="page${g}" style="position:absolute;top:${top}px;">`;
+    if (removeMargins) {
+      top += Math.min((maxBottom - minTop) + 200, pageMetricsArr[g].dims.height + 10);
+    } else {
+      top += pageMetricsArr[g].dims.height + 10;
+    }
+
+    if (reflowText) {
+      const angle = pageMetricsArr[g].angle || 0;
+      assignParagraphs(pageObj, angle);
+    }
+
+    let parCurrent = pageObj.lines[0].par;
+
+    for (let h = 0; h < pageObj.lines.length; h++) {
+      const lineObj = pageObj.lines[h];
+
+      if (reflowText) {
+        if (g > 0 && h === 0 || lineObj.par !== parCurrent) newLine = true;
+        parCurrent = lineObj.par;
+      } else {
+        newLine = true;
+      }
+
+      for (let i = 0; i < lineObj.words.length; i++) {
+        const wordObj = lineObj.words[i];
+        if (!wordObj) continue;
+
+        if (wordIds && !wordIds.includes(wordObj.id)) continue;
+
+        if (newLine) {
+          bodyStr += '\n';
+        } else if (h > 0 || g > 0 || i > 0) {
+          bodyStr += ' ';
+        }
+
+        newLine = false;
+
+        const scale = 1;
+        const angle = 0;
+
+        const fontI = FontCont.getWordFont(wordObj);
+        fontsUsed.add(fontI);
+
+        const {
+          charSpacing, leftSideBearing, rightSideBearing, fontSize, charArr, advanceArr, kerningArr, font,
+        } = calcWordMetrics(wordObj);
+
+        const wordStr = charArr.join('');
+
+        const charSpacingHTML = charSpacing * scale;
+
+        let x1 = wordObj.bbox.left - minLeft;
+        const y1 = wordObj.line.bbox.bottom + wordObj.line.baseline[1] - minTop;
+
+        if (wordObj.visualCoords) x1 -= leftSideBearing * scale;
+
+        const fontSizeHTML = fontSize * scale;
+
+        ctx.font = `${fontI.fontFaceStyle} ${fontI.fontFaceWeight} ${fontSizeHTML}px ${fontI.fontFaceName}`;
+
+        const metrics = ctx.measureText(wordStr);
+
+        const fontSizeHTMLSmallCaps = fontSize * scale * fontI.smallCapsMult;
+
+        // Align with baseline
+        const topHTML = Math.round((y1 - metrics.fontBoundingBoxAscent + fontSizeHTML * 0.6) * 1000) / 1000;
+
+        let styleStr = '';
+
+        const topPadOffset = 5 * Math.sin(angle * (Math.PI / 180));
+        const leftPadOffset = 5 * Math.cos(angle * (Math.PI / 180));
+
+        styleStr += `left:${x1 - leftPadOffset}px;`;
+        styleStr += `top:${topHTML - topPadOffset}px;`;
+        styleStr += `font-size:${fontSizeHTML}px;`;
+        styleStr += `font-family:${fontI.fontFaceName};`;
+
+        if (Math.abs(angle ?? 0) > 0.05) {
+          styleStr += `transform-origin:left ${y1 - topHTML}px;`;
+          styleStr += `transform:rotate(${angle}deg);`;
+        }
+
+        // We cannot make the text uppercase in the input field, as this would result in the text being saved as uppercase.
+        // Additionally, while there is a small-caps CSS property, it does not allow for customizing the size of the small caps.
+        // 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) {
+          styleStr += 'text-transform:uppercase;';
+          innerHTML = makeSmallCapsDivs(wordStr, fontSizeHTMLSmallCaps);
+        } else {
+          innerHTML = wordStr;
+        }
+
+        styleStr += `letter-spacing:${charSpacingHTML}px;`;
+
+        styleStr += `font-weight:${fontI.fontFaceWeight};`;
+        styleStr += `font-style:${fontI.fontFaceStyle};`;
+
+        // Line height must match the height of the font bounding box for the font metrics to be accurate.
+        styleStr += `line-height:${metrics.fontBoundingBoxAscent + metrics.fontBoundingBoxDescent}px;`;
+
+        bodyStr += `<span class="scribe-word" id="${wordObj.id}" style="${styleStr}">${innerHTML}</span>`;
+      }
+    }
+
+    bodyStr += '</div>';
+
+    opt.progressHandler({ n: g, type: 'export', info: { } });
+  }
+
+  let styleStr = '<style>.scribe-word {';
+
+  styleStr += 'position:absolute;';
+  styleStr += `padding-left:${pad}px;`;
+  styleStr += `padding-right:${pad}px;`;
+  styleStr += 'z-index:1;';
+  styleStr += 'white-space:nowrap;';
+  if (opt.kerning) {
+    styleStr += 'font-kerning:normal;';
+  } else {
+    styleStr += 'font-kerning:none;';
+  }
+
+  styleStr += '}';
+
+  for (const fontI of fontsUsed) {
+    const cdnPath = 'https://cdn.jsdelivr.net/npm/scribe.js-ocr@0.7.1/fonts/all/';
+    let styleTitleCase = fontI.style.charAt(0).toUpperCase() + fontI.style.slice(1).toLowerCase();
+    if (styleTitleCase === 'Normal') styleTitleCase = 'Regular';
+    const fontName = `${fontI.family}-${styleTitleCase}.woff`;
+    const fontPath = cdnPath + fontName;
+
+    styleStr += `@font-face {
+    font-family: '${fontI.fontFaceName}';
+    font-style: ${fontI.fontFaceStyle};
+    font-weight: ${fontI.fontFaceWeight};
+    src: url('${fontPath}');
+}\n`;
+  }
+
+  styleStr += '</style>';
+
+  bodyStr += '</body>';
+
+  const htmlStr = `<html><head>${styleStr}</head>${bodyStr}</html>`;
+
+  return htmlStr;
+}

package/js/fontContainerMain.js

@@ -33,9 +33,9 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
   let /** @type {Promise<ArrayBuffer>} */palatinoNormal;
   let /** @type {Promise<ArrayBuffer>} */palatinoItalic;
   let /** @type {Promise<ArrayBuffer>} */palatinoBold;
-  let /** @type {Promise<ArrayBuffer>} */nimbusRomNo9LNormal;
-  let /** @type {Promise<ArrayBuffer>} */nimbusRomNo9LItalic;
-  let /** @type {Promise<ArrayBuffer>} */nimbusRomNo9LBold;
+  let /** @type {Promise<ArrayBuffer>} */nimbusRomanNormal;
+  let /** @type {Promise<ArrayBuffer>} */nimbusRomanItalic;
+  let /** @type {Promise<ArrayBuffer>} */nimbusRomanBold;
   let /** @type {Promise<ArrayBuffer>} */nimbusSansNormal;
   let /** @type {Promise<ArrayBuffer>} */nimbusSansItalic;
   let /** @type {Promise<ArrayBuffer>} */nimbusSansBold;
@@ -56,9 +56,9 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
       palatinoNormal = fetch(new URL('../fonts/latin/Palatino-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
       palatinoItalic = fetch(new URL('../fonts/latin/Palatino-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       palatinoBold = fetch(new URL('../fonts/latin/Palatino-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LNormal = fetch(new URL('../fonts/latin/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LItalic = fetch(new URL('../fonts/latin/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LBold = fetch(new URL('../fonts/latin/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanNormal = fetch(new URL('../fonts/latin/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanItalic = fetch(new URL('../fonts/latin/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanBold = fetch(new URL('../fonts/latin/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansNormal = fetch(new URL('../fonts/latin/NimbusSans-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansItalic = fetch(new URL('../fonts/latin/NimbusSans-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansBold = fetch(new URL('../fonts/latin/NimbusSans-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
@@ -78,9 +78,9 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
       palatinoNormal = fetch(new URL('../fonts/all/Palatino-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
       palatinoItalic = fetch(new URL('../fonts/all/Palatino-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       palatinoBold = fetch(new URL('../fonts/all/Palatino-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LNormal = fetch(new URL('../fonts/all/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LItalic = fetch(new URL('../fonts/all/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
-      nimbusRomNo9LBold = fetch(new URL('../fonts/all/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanNormal = fetch(new URL('../fonts/all/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanItalic = fetch(new URL('../fonts/all/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
+      nimbusRomanBold = fetch(new URL('../fonts/all/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansNormal = fetch(new URL('../fonts/all/NimbusSans-Regular.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansItalic = fetch(new URL('../fonts/all/NimbusSans-Italic.woff', import.meta.url)).then((res) => res.arrayBuffer());
       nimbusSansBold = fetch(new URL('../fonts/all/NimbusSans-Bold.woff', import.meta.url)).then((res) => res.arrayBuffer());
@@ -102,9 +102,9 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
     palatinoNormal = readFile(new URL('../fonts/all/Palatino-Regular.woff', import.meta.url)).then((res) => res.buffer);
     palatinoItalic = readFile(new URL('../fonts/all/Palatino-Italic.woff', import.meta.url)).then((res) => res.buffer);
     palatinoBold = readFile(new URL('../fonts/all/Palatino-Bold.woff', import.meta.url)).then((res) => res.buffer);
-    nimbusRomNo9LNormal = readFile(new URL('../fonts/all/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.buffer);
-    nimbusRomNo9LItalic = readFile(new URL('../fonts/all/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.buffer);
-    nimbusRomNo9LBold = readFile(new URL('../fonts/all/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.buffer);
+    nimbusRomanNormal = readFile(new URL('../fonts/all/NimbusRoman-Regular.woff', import.meta.url)).then((res) => res.buffer);
+    nimbusRomanItalic = readFile(new URL('../fonts/all/NimbusRoman-Italic.woff', import.meta.url)).then((res) => res.buffer);
+    nimbusRomanBold = readFile(new URL('../fonts/all/NimbusRoman-Bold.woff', import.meta.url)).then((res) => res.buffer);
     nimbusSansNormal = readFile(new URL('../fonts/all/NimbusSans-Regular.woff', import.meta.url)).then((res) => res.buffer);
     nimbusSansItalic = readFile(new URL('../fonts/all/NimbusSans-Italic.woff', import.meta.url)).then((res) => res.buffer);
     nimbusSansBold = readFile(new URL('../fonts/all/NimbusSans-Bold.woff', import.meta.url)).then((res) => res.buffer);
@@ -118,7 +118,7 @@ export async function loadBuiltInFontsRaw(glyphSet = 'latin') {
     Century: { normal: await centuryNormal, italic: await centuryItalic, bold: await centuryBold },
     Garamond: { normal: await garamondNormal, italic: await garamondItalic, bold: await garamondBold },
     Palatino: { normal: await palatinoNormal, italic: await palatinoItalic, bold: await palatinoBold },
-    NimbusRomNo9L: { normal: await nimbusRomNo9LNormal, italic: await nimbusRomNo9LItalic, bold: await nimbusRomNo9LBold },
+    NimbusRoman: { normal: await nimbusRomanNormal, italic: await nimbusRomanItalic, bold: await nimbusRomanBold },
     NimbusSans: { normal: await nimbusSansNormal, italic: await nimbusSansItalic, bold: await nimbusSansBold },
     NimbusMono: { normal: await nimbusMonoNormal, italic: await nimbusMonoItalic, bold: await nimbusMonoBold },
   };
@@ -265,7 +265,7 @@ export async function setUploadFontsWorker(scheduler) {
   /** @type {Object<string, fontSrcBuiltIn|fontSrcUpload>} */
   const fontsUpload = {};
   for (const [key, value] of Object.entries(FontCont.active)) {
-    if (!['Carlito', 'Century', 'Garamond', 'Palatino', 'NimbusRomNo9L', 'NimbusSans', 'NimbusMono'].includes(key)) {
+    if (!['Carlito', 'Century', 'Garamond', 'Palatino', 'NimbusRoman', 'NimbusSans', 'NimbusMono'].includes(key)) {
       fontsUpload[key] = {
         normal: value?.normal?.src, italic: value?.italic?.src, bold: value?.bold?.src,
       };
@@ -287,7 +287,7 @@ export async function setUploadFontsWorker(scheduler) {
 
   // Set the active font in the workers to match the active font in `fontAll`
   const resArr = [];
-  const opt = FontCont.active.Carlito.normal.opt || FontCont.active.NimbusRomNo9L.normal.opt;
+  const opt = FontCont.active.Carlito.normal.opt || FontCont.active.NimbusRoman.normal.opt;
   for (let i = 0; i < scheduler.workers.length; i++) {
     const worker = scheduler.workers[i];
     const res = worker.updateFontContWorker({
@@ -388,11 +388,11 @@ export async function optimizeFontContainerAll(fontPrivate, fontMetricsObj) {
   const centuryPromise = optimizeFontContainerFamily(fontPrivate.Century, fontMetricsObj);
   const garamondPromise = optimizeFontContainerFamily(fontPrivate.Garamond, fontMetricsObj);
   const palatinoPromise = optimizeFontContainerFamily(fontPrivate.Palatino, fontMetricsObj);
-  const nimbusRomNo9LPromise = optimizeFontContainerFamily(fontPrivate.NimbusRomNo9L, 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, nimbusRomNo9LPromise, nimbusSansPromise, nimbusMonoPromise]);
+  const results = await Promise.all([carlitoPromise, centuryPromise, garamondPromise, palatinoPromise, nimbusRomanPromise, nimbusSansPromise, nimbusMonoPromise]);
 
   if (results.every((x) => x === null)) return null;
 
@@ -401,7 +401,7 @@ export async function optimizeFontContainerAll(fontPrivate, fontMetricsObj) {
     Century: results[1],
     Garamond: results[2],
     Palatino: results[3],
-    NimbusRomNo9L: results[4],
+    NimbusRoman: results[4],
     NimbusSans: results[5],
     NimbusMono: results[6],
   };

package/js/fontEval.js

@@ -49,7 +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 evalNimbusRomNo9L = !!(opt ? FontCont.opt?.NimbusRomNo9L : FontCont.raw?.NimbusRomNo9L);
+  const evalNimbusRoman = !!(opt ? FontCont.opt?.NimbusRoman : FontCont.raw?.NimbusRoman);
   const evalNimbusMono = !!(opt ? FontCont.opt?.NimbusMono : FontCont.raw?.NimbusMono);
 
   const fontMetricsPromises = {
@@ -58,7 +58,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,
-    nimbusRomNo9L: evalNimbusRomNo9L ? evalPagesFont('NimbusRomNo9L', pageArr, opt) : null,
+    nimbusRoman: evalNimbusRoman ? evalPagesFont('NimbusRoman', pageArr, opt) : null,
     nimbusMono: evalNimbusMono ? evalPagesFont('NimbusMono', pageArr, opt) : null,
   };
 
@@ -68,7 +68,7 @@ export async function evaluateFonts(pageArr, opt) {
     century: await fontMetricsPromises.century,
     palatino: await fontMetricsPromises.palatino,
     garamond: await fontMetricsPromises.garamond,
-    nimbusRomNo9L: await fontMetricsPromises.nimbusRomNo9L,
+    nimbusRoman: await fontMetricsPromises.nimbusRoman,
     nimbusMono: await fontMetricsPromises.nimbusMono,
   };
 
@@ -78,7 +78,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,
-    NimbusRomNo9L: fontMetricsTmp.nimbusRomNo9L ? fontMetricsTmp.nimbusRomNo9L.metricTotal / fontMetricsTmp.nimbusRomNo9L.wordsTotal : null,
+    NimbusRoman: fontMetricsTmp.nimbusRoman ? fontMetricsTmp.nimbusRoman.metricTotal / fontMetricsTmp.nimbusRoman.wordsTotal : null,
     NimbusMono: fontMetricsTmp.nimbusMono ? fontMetricsTmp.nimbusMono.metricTotal / fontMetricsTmp.nimbusMono.wordsTotal : null,
   };
 
@@ -101,11 +101,11 @@ const calcBestFonts = (fontMetrics) => {
     }
   }
 
-  let minKeySerif = 'NimbusRomNo9L';
+  let minKeySerif = 'NimbusRoman';
   let minValueSerif = Number.MAX_VALUE;
 
   for (const [key, value] of Object.entries(fontMetrics)) {
-    if (!['Century', 'Palatino', 'Garamond', 'NimbusRomNo9L', 'NimbusMono'].includes(key)) continue;
+    if (!['Century', 'Palatino', 'Garamond', 'NimbusRoman', 'NimbusMono'].includes(key)) continue;
     if (value && value < minValueSerif) {
       minValueSerif = value;
       minKeySerif = key;

package/js/global.d.ts

@@ -32,7 +32,7 @@ declare global {
         Century: FontContainerFamilyBuiltIn;
         Garamond: FontContainerFamilyBuiltIn;
         Palatino: FontContainerFamilyBuiltIn;
-        NimbusRomNo9L: FontContainerFamilyBuiltIn;
+        NimbusRoman: FontContainerFamilyBuiltIn;
         NimbusSans: FontContainerFamilyBuiltIn;
         NimbusMono: FontContainerFamilyBuiltIn;
         [key: string]: FontContainerFamily;

package/js/import/importOCR.js

@@ -133,7 +133,9 @@ export async function importOCRFiles(ocrFilesAll) {
     const sansFontStr = getMeta('sans-font');
     if (sansFontStr) sansFont = sansFontStr;
 
-    const serifFontStr = getMeta('serif-font');
+    let serifFontStr = getMeta('serif-font');
+    // Older versions of Scribe used 'NimbusRomNo9L' instead of 'NimbusRoman'.
+    if (serifFontStr && serifFontStr === 'NimbusRomNo9L') serifFontStr = 'NimbusRoman';
     if (serifFontStr) serifFont = serifFontStr;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scribe.js-ocr",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "High-quality OCR and text extraction for images and PDFs.",
   "main": "scribe.js",
   "directories": {