scribe.js-ocr 0.7.3 → 0.7.4

package/js/containers/app.js

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

package/js/containers/fontContainer.js

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

package/js/export/writeHocr.js

@@ -75,38 +75,40 @@ export function writeHocr(ocrData, minValue, maxValue) {
         hocrOut += `bbox ${Math.round(wordObj.bbox.left)} ${Math.round(wordObj.bbox.top)} ${Math.round(wordObj.bbox.right)} ${Math.round(wordObj.bbox.bottom)}`;
         hocrOut += `;x_wconf ${wordObj.conf}`;
 
-        if (wordObj.font && wordObj.font !== 'Default') {
-          hocrOut += `;x_font ${wordObj.font}`;
+        if (wordObj.style.font && wordObj.style.font !== 'Default') {
+          hocrOut += `;x_font ${wordObj.style.font}`;
         }
 
-        if (wordObj.size) {
-          hocrOut += `;x_fsize ${wordObj.size}`;
+        if (wordObj.style.size) {
+          hocrOut += `;x_fsize ${wordObj.style.size}`;
         }
 
         hocrOut += "'";
 
         // Tesseract HOCR specifies default language for a paragraph in the "ocr_par" element,
         // however as ScribeOCR does not currently have a paragarph object, every word must have its language specified.
-        hocrOut += ` lang='${wordObj.lang}'`;
+        if (wordObj.lang) hocrOut += ` lang='${wordObj.lang}'`;
 
         // TODO: Why are we representing font family and style using the `style` HTML element here?
         // This is not how Tesseract does things, and our own parsing script does not appear to be written to re-import it properly.
         // Add "style" attribute (if applicable)
-        if (['italic', 'bold'].includes(wordObj.style) || wordObj.smallCaps || (wordObj.font && wordObj.font !== 'Default')) {
+        if (wordObj.style.bold || wordObj.style.italic || wordObj.style.smallCaps || (wordObj.style.font && wordObj.style.font !== 'Default')) {
           hocrOut += ' style=\'';
 
-          if (wordObj.style === 'italic') {
+          if (wordObj.style.italic) {
             hocrOut += 'font-style:italic;';
-          } else if (wordObj.style === 'bold') {
+          }
+
+          if (wordObj.style.bold) {
             hocrOut += 'font-weight:bold;';
           }
 
-          if (wordObj.smallCaps) {
+          if (wordObj.style.smallCaps) {
             hocrOut += 'font-variant:small-caps;';
           }
 
-          if (wordObj.font && wordObj.font !== 'Default') {
-            hocrOut += `font-family:${wordObj.font}`;
+          if (wordObj.style.font && wordObj.style.font !== 'Default') {
+            hocrOut += `font-family:${wordObj.style.font}`;
           }
 
           hocrOut += '\'>';
@@ -115,9 +117,9 @@ export function writeHocr(ocrData, minValue, maxValue) {
         }
 
         // Add word text, along with any formatting that uses nested elements rather than attributes
-        if (wordObj.sup) {
+        if (wordObj.style.sup) {
           hocrOut += `<sup>${ocr.escapeXml(wordObj.text)}</sup>`;
-        } else if (wordObj.dropcap) {
+        } else if (wordObj.style.dropcap) {
           hocrOut += `<span class='ocr_dropcap'>${ocr.escapeXml(wordObj.text)}</span>`;
         } else {
           hocrOut += ocr.escapeXml(wordObj.text);

package/js/export/writeHtml.js

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

package/js/export/writePdf.js

@@ -10,6 +10,7 @@ import { createEmbeddedFontType0, createEmbeddedFontType1 } from './writePdfFont
 import { opt } from '../containers/app.js';
 import { pageMetricsArr } from '../containers/dataContainer.js';
 import ocr from '../objects/ocrObjects.js';
+import { getStyleLookup } from '../utils/miscUtils.js';
 
 /**
  * @param {number} x
@@ -97,6 +98,7 @@ export async function writePdf(hocrArr, minpage = 0, maxpage = -1, textMode = 'e
       normal: useOpt && FontCont.opt?.[familyKeyI]?.normal ? FontCont.opt[familyKeyI].normal : FontCont.raw[familyKeyI].normal,
       italic: useOpt && FontCont.opt?.[familyKeyI]?.italic ? FontCont.opt[familyKeyI].italic : FontCont.raw[familyKeyI].italic,
       bold: useOpt && FontCont.opt?.[familyKeyI]?.bold ? FontCont.opt[familyKeyI].bold : FontCont.raw[familyKeyI].bold,
+      boldItalic: useOpt && FontCont.opt?.[familyKeyI]?.boldItalic ? FontCont.opt[familyKeyI].boldItalic : FontCont.raw[familyKeyI].boldItalic,
     };
     await addFamilyObj(familyKeyI, familyObjI);
   }
@@ -301,6 +303,8 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
 
   const pdfFontsUsed = new Set();
 
+  const underlines = /** @type {Array<{left: number, right: number, top: number, height: number, fontSize: number, bold: boolean}>} */ ([]);
+
   // Start 1st object: Text Content
   let textContentObjStr = '';
 
@@ -349,7 +353,7 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
     let wordFontOpentype = (wordJ.lang === 'chi_sim' ? fontChiSim : wordFont.opentype);
 
     if (!wordFontOpentype) {
-      const fontNameMessage = wordJ.lang === 'chi_sim' ? 'chi_sim' : `${wordFont.family} (${wordJ.style})`;
+      const fontNameMessage = wordJ.lang === 'chi_sim' ? 'chi_sim' : `${wordFont.family} (${getStyleLookup(wordJ.style)})`;
       console.log(`Skipping word due to missing font (${fontNameMessage})`);
       continue;
     }
@@ -359,7 +363,7 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
     let wordFontSize = word0Metrics.fontSize;
 
     // Set font and font size
-    const pdfFontCurrent = wordJ.lang === 'chi_sim' ? pdfFonts.NotoSansSC.normal : pdfFonts[wordFont.family][wordJ.style];
+    const pdfFontCurrent = wordJ.lang === 'chi_sim' ? pdfFonts.NotoSansSC.normal : pdfFonts[wordFont.family][getStyleLookup(wordJ.style)];
     pdfFontNameCurrent = pdfFontCurrent.name;
     pdfFontTypeCurrent = pdfFontCurrent.type;
     pdfFontsUsed.add(pdfFontCurrent);
@@ -372,7 +376,7 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
     const word0LeftBearing = wordJ.visualCoords ? word0Metrics.leftSideBearing : 0;
 
     let tz = 100;
-    if (wordJ.dropcap) {
+    if (wordJ.style.dropcap) {
       const wordWidthActual = wordJ.bbox.right - wordJ.bbox.left;
       tz = (wordWidthActual / word0Metrics.visualWidth) * 100;
     }
@@ -406,6 +410,8 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
     let spacingAdj = 0;
     let kernSpacing = false;
     let wordLast = wordJ;
+    let underlineLeft = /** @type {?number} */ null;
+    let underlineRight = /** @type {?number} */ null;
     let wordFontOpentypeLast = wordFontOpentype;
     let fontSizeLast = wordFontSize;
     let tsCurrent = 0;
@@ -426,7 +432,7 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
       wordFontOpentype = wordJ.lang === 'chi_sim' ? fontChiSim : wordFont.opentype;
 
       if (!wordFontOpentype) {
-        const fontNameMessage = wordJ.lang === 'chi_sim' ? 'chi_sim' : `${wordFont.family} (${wordJ.style})`;
+        const fontNameMessage = wordJ.lang === 'chi_sim' ? 'chi_sim' : `${wordFont.family} (${getStyleLookup(wordJ.style)})`;
         console.log(`Skipping word due to missing font (${fontNameMessage})`);
         continue;
       }
@@ -446,11 +452,11 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
         fillColor = wordJ.matchTruth ? '0 1 0.5 rg' : '1 0 0 rg';
       }
 
-      const angleAdjWord = wordJ.sup ? ocr.calcWordAngleAdj(wordJ) : { x: 0, y: 0 };
+      const angleAdjWord = wordJ.style.sup ? ocr.calcWordAngleAdj(wordJ) : { x: 0, y: 0 };
       const angleAdjWordX = (rotateBackground && Math.abs(angle ?? 0) > 0.05) ? angleAdjWord.x : 0;
 
       let ts = 0;
-      if (wordJ.sup || wordJ.dropcap) {
+      if (wordJ.style.sup || wordJ.style.dropcap) {
         ts = (lineObj.bbox.bottom + lineObj.baseline[1] + angleAdjLine.y) - (wordJ.bbox.bottom + angleAdjLine.y + angleAdjWord.y);
         if (!wordJ.visualCoords) {
           const fontDesc = wordFont.opentype.descender / wordFont.opentype.unitsPerEm * wordMetrics.fontSize;
@@ -462,12 +468,12 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
 
       // TODO: This probably fails for Chinese, rethink.
       tz = 100;
-      if (wordJ.dropcap) {
+      if (wordJ.style.dropcap) {
         const wordWidthActual = wordJ.bbox.right - wordJ.bbox.left;
         tz = (wordWidthActual / wordMetrics.visualWidth) * 100;
       }
 
-      const pdfFont = wordJ.lang === 'chi_sim' ? pdfFonts.NotoSansSC.normal : pdfFonts[wordFont.family][wordJ.style];
+      const pdfFont = wordJ.lang === 'chi_sim' ? pdfFonts.NotoSansSC.normal : pdfFonts[wordFont.family][getStyleLookup(wordJ.style)];
       const pdfFontName = pdfFont.name;
       const pdfFontType = pdfFont.type;
       pdfFontsUsed.add(pdfFont);
@@ -480,7 +486,8 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
         // The space between words determined by:
         // (1) The right bearing of the last word, (2) the left bearing of the current word, (3) the width of the space character between words,
         // (4) the current character spacing value (applied twice--both before and after the space character).
-        const spaceWidthGlyph = wordFontOpentypeLast.charToGlyph(' ').advanceWidth * (fontSizeLast / wordFontOpentypeLast.unitsPerEm);
+        const spaceAdvance = wordFontOpentypeLast.charToGlyph(' ').advanceWidth || wordFontOpentypeLast.unitsPerEm / 2;
+        const spaceWidthGlyph = spaceAdvance * (fontSizeLast / wordFontOpentypeLast.unitsPerEm);
 
         const wordSpaceExpectedPx = (spaceWidthGlyph + charSpacingLast * 2 + wordRightBearingLast) + wordLeftBearing;
 
@@ -503,10 +510,11 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
       // However, this assumption does not hold for single-character words, as there is no space between character to adjust.
       // Therefore, we calculate the difference between the rendered and actual word and apply an adjustment to the width of the next space.
       // (This does not apply to drop caps as those have horizontal scaling applied to exactly match the image.)
-      if (charArr.length === 1 && !wordJ.dropcap) {
+      if (charArr.length === 1 && !wordJ.style.dropcap) {
         const wordLastGlyph = wordFontOpentype.charToGlyph(charArr.at(-1));
         const wordLastGlyphMetrics = wordLastGlyph.getMetrics();
-        const lastCharWidth = (wordLast.visualCoords ? (wordLastGlyphMetrics.xMax - wordLastGlyphMetrics.xMin) : wordLastGlyph.advanceWidth) * (wordFontSize / wordFontOpentype.unitsPerEm);
+        const lastCharAdvance = wordLast.visualCoords ? (wordLastGlyphMetrics.xMax - wordLastGlyphMetrics.xMin) : wordLastGlyph.advanceWidth || wordFontOpentype.unitsPerEm / 2;
+        const lastCharWidth = lastCharAdvance * (wordFontSize / wordFontOpentype.unitsPerEm);
         spacingAdj = wordWidthAdj - lastCharWidth - angleAdjWordX;
       } else {
         spacingAdj = 0 - angleAdjWordX;
@@ -514,7 +522,7 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
 
       textContentObjStr += ' ] TJ\n';
 
-      const fontSize = wordJ.smallCaps && wordJ.text[0] && wordJ.text[0] !== wordJ.text[0].toUpperCase() ? wordFontSize * wordFont.smallCapsMult : wordFontSize;
+      const fontSize = wordJ.style.smallCaps && wordJ.text[0] && wordJ.text[0] !== wordJ.text[0].toUpperCase() ? wordFontSize * wordFont.smallCapsMult : wordFontSize;
       if (pdfFontName !== pdfFontNameCurrent || fontSize !== fontSizeLast) {
         textContentObjStr += `${pdfFontName} ${String(fontSize)} Tf\n`;
         pdfFontNameCurrent = pdfFontName;
@@ -541,8 +549,8 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
       // Non-ASCII and special characters are encoded/escaped using winEncodingLookup
       for (let k = 0; k < charArr.length; k++) {
         const letterSrc = charArr[k];
-        const letter = wordJ.smallCaps ? charArr[k].toUpperCase() : charArr[k];
-        const fontSizeLetter = wordJ.smallCaps && letterSrc !== letter ? wordFontSize * wordFont.smallCapsMult : wordFontSize;
+        const letter = wordJ.style.smallCaps ? charArr[k].toUpperCase() : charArr[k];
+        const fontSizeLetter = wordJ.style.smallCaps && letterSrc !== letter ? wordFontSize * wordFont.smallCapsMult : wordFontSize;
 
         const letterEnc = pdfFontTypeCurrent === 0 ? wordFontOpentype.charToGlyphIndex(letter)?.toString(16).padStart(4, '0') : winEncodingLookup[letter];
         if (letterEnc) {
@@ -611,6 +619,28 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
         }
       }
 
+      if (wordJ.style.underline && underlineLeft === null) {
+        underlineLeft = wordJ.bbox.left;
+      }
+
+      if (wordJ.style.underline) {
+        underlineRight = wordJ.bbox.right;
+      }
+
+      if (underlineLeft !== null && (!wordJ.style.underline || j === words.length - 1)) {
+        underlines.push({
+          left: underlineLeft,
+          right: underlineRight,
+          top: lineTopAdj,
+          height: lineObj.bbox.bottom - lineObj.bbox.top,
+          fontSize: wordFontSize,
+          bold: wordJ.style.bold,
+        });
+
+        underlineLeft = null;
+        underlineRight = null;
+      }
+
       wordLast = wordJ;
       wordRightBearingLast = wordLast.visualCoords ? wordMetrics.rightSideBearing : 0;
       wordFontOpentypeLast = wordFontOpentype;
@@ -622,5 +652,13 @@ async function ocrPageToPDFStream(pageObj, outputDims, pdfFonts, textMode, angle
 
   textContentObjStr += 'ET';
 
+  // Add underlines
+  underlines.forEach((underline) => {
+    const underlineThickness = underline.bold ? Math.ceil(underline.fontSize / 12) : Math.ceil(underline.fontSize / 24);
+    const underlineOffset = Math.ceil(underline.fontSize / 12) + underlineThickness;
+
+    textContentObjStr += `\n${String(underline.left)} ${String(outputDims.height - underline.top - underlineOffset)} ${String(underline.right - underline.left)} ${underlineThickness} re\nf\n`;
+  });
+
   return { textContentObjStr, pdfFontsUsed };
 }

package/js/export/writePdfFonts.js

@@ -108,12 +108,12 @@ const generateFontFlags = (serif, italic, smallcap, symbolic) => { /* eslint-dis
  *
  * @param {opentype.Font} font - Opentype.js font object
  * @param {number} objIndex - Index for font descriptor PDF object
- * @param {('normal'|'italic'|'bold')} style - Style of the font
+ * @param {boolean} italic
  * @param {?number} embeddedObjIndex - Index for embedded font file PDF object.
  *  If not provided, the font will not be embedded in the PDF.
  * @returns {string} The font descriptor object string.
  */
-function createFontDescriptor(font, objIndex, style = 'normal', embeddedObjIndex = null) {
+function createFontDescriptor(font, objIndex, italic, embeddedObjIndex = null) {
   let objOut = `${String(objIndex)} 0 obj\n<</Type/FontDescriptor`;
 
   const namesTable = font.names.windows || font.names;
@@ -155,7 +155,7 @@ function createFontDescriptor(font, objIndex, style = 'normal', embeddedObjIndex
 
   // Symbolic is always set to false, even if the font contains glyphs outside the Adobe standard Latin character set.
   // This is because symbolic fonts are only used when embedded, and this does not appear to matter for embedded fonts.
-  objOut += `/Flags ${String(generateFontFlags(serif, style === 'italic', false, false))}`;
+  objOut += `/Flags ${String(generateFontFlags(serif, italic, false, false))}`;
 
   if (embeddedObjIndex === null || embeddedObjIndex === undefined) {
     objOut += '>>\nendobj\n\n';
@@ -175,12 +175,12 @@ function createFontDescriptor(font, objIndex, style = 'normal', embeddedObjIndex
  *
  * @param {opentype.Font} font - Opentype.js font object
  * @param {number} firstObjIndex - Index for the first PDF object
- * @param {('normal'|'italic'|'bold')} style - Style of the font
+ * @param {boolean} [italic=false] - Whether the font is italic.
  * @param {boolean} [isStandardFont=false] - Whether the font is a standard font.
  *  Standard fonts are not embedded in the PDF.
  * @returns {Array<string>}
  */
-export function createEmbeddedFontType1(font, firstObjIndex, style = 'normal', isStandardFont = false) {
+export function createEmbeddedFontType1(font, firstObjIndex, italic = false, isStandardFont = false) {
   // Start 1st object: Font Dictionary
   let fontDictObjStr = `${String(firstObjIndex)} 0 obj\n<</Type/Font/Subtype/Type1`;
 
@@ -193,7 +193,8 @@ export function createEmbeddedFontType1(font, firstObjIndex, style = 'normal', i
 
   fontDictObjStr += '/Widths[';
   for (let i = 0; i < win1252Chars.length; i++) {
-    const advanceNorm = Math.round(font.charToGlyph(win1252Chars[i]).advanceWidth * (1000 / font.unitsPerEm));
+    const advance = font.charToGlyph(win1252Chars[i]).advanceWidth || font.unitsPerEm;
+    const advanceNorm = Math.round(advance * (1000 / font.unitsPerEm));
     fontDictObjStr += `${String(advanceNorm)} `;
   }
   fontDictObjStr += ']/FirstChar 32/LastChar 255';
@@ -201,7 +202,7 @@ export function createEmbeddedFontType1(font, firstObjIndex, style = 'normal', i
   fontDictObjStr += `/FontDescriptor ${String(firstObjIndex + 1)} 0 R>>\nendobj\n\n`;
 
   // Start 2nd object: Font Descriptor
-  const fontDescObjStr = createFontDescriptor(font, firstObjIndex + 1, style, isStandardFont ? null : firstObjIndex + 2);
+  const fontDescObjStr = createFontDescriptor(font, firstObjIndex + 1, italic, isStandardFont ? null : firstObjIndex + 2);
 
   // objOut += `${String(firstObjIndex + 1)} 0 obj\n<</Type/FontDescriptor`;
 
@@ -249,13 +250,14 @@ export function createEmbeddedFontType1(font, firstObjIndex, style = 'normal', i
  *
  * @param {opentype.Font} font - Opentype.js font object
  * @param {number} firstObjIndex - Index for the first PDF object
+ * @param {boolean} [italic=false] - Whether the font is italic.
  *
  * This function does not produce "toUnicode" or "Widths" objects,
  * so any PDF it creates directly will lack usable copy/paste.
  * However, both of these objects will be created from the embedded file
  * when the result is run through mupdf.
  */
-export function createEmbeddedFontType0(font, firstObjIndex, style = 'normal') {
+export function createEmbeddedFontType0(font, firstObjIndex, italic = false) {
   // Start 1st object: Font Dictionary
   let fontDictObjStr = `${String(firstObjIndex)} 0 obj\n<</Type/Font/Subtype/Type0`;
 
@@ -282,7 +284,7 @@ export function createEmbeddedFontType0(font, firstObjIndex, style = 'normal') {
   toUnicodeStr += '\nendstream\nendobj\n\n';
 
   // Start 3rd object: FontDescriptor
-  const fontDescObjStr = createFontDescriptor(font, firstObjIndex + 1, style, firstObjIndex + 3);
+  const fontDescObjStr = createFontDescriptor(font, firstObjIndex + 1, italic, firstObjIndex + 3);
 
   // objOut += `${String(firstObjIndex + 2)} 0 obj\n`;
 

package/js/export/writeTabular.js

@@ -86,9 +86,9 @@ function createCellsSingle(ocrTableWords, extraCols = [], startRow = 0, xlsxMode
 
         if (xlsxMode) {
           let fontStyle;
-          if (wordObj.style === 'italic') {
+          if (wordObj.style.italic) {
             fontStyle = '<i/>';
-          } else if (wordObj.smallCaps) {
+          } else if (wordObj.style.smallCaps) {
             fontStyle = '<smallCaps/>';
           } else {
             fontStyle = '';