Improve word-space detection in getTextContent

The gap between two glyphs was turned into a space using a hardcoded
`trackingSpaceMin` of `0.102 * fontSize`. Depending on the font this was
either too large or too small, producing fake spaces inside words
("Robe rt") or a space between every letter of letter-spaced text
("R E A S O N S").

The threshold is now derived from the font's space width (or the glyph's
advance width for Type3 fonts, where the font size is meaningless) and
raised for uniformly letter-spaced runs. A space wrongly inserted before
the first glyph of such a run is retracted once the next gap confirms it,
and the adaptive state is reset on spacing or text-matrix changes so it
can't leak across sections.

It fixes #18768 and #16752.

Author: calixteman

src/core/evaluator.js

@@ -2418,6 +2418,12 @@ class PartialEvaluator {
       spaceInFlowMin: 0,
       spaceInFlowMax: 0,
       trackingSpaceMin: Infinity,
+      useCharWidthThreshold: false,
+      wideSpaceMax: Infinity,
+      minAdvance: Infinity,
+      pendingSpaceIndex: -1,
+      pendingSpaceAdvance: 0,
+      pendingSpaceExtraCharId: -1,
       negativeSpaceMax: -Infinity,
       notASpace: -Infinity,
       transform: null,
@@ -2483,21 +2489,37 @@ class PartialEvaluator {
     // even if one is present in the text stream.
     const NOT_A_SPACE_FACTOR = 0.03;
 
+    // A reported space wider than fontSize * MAX_SPACE_WIDTH_FACTOR is treated
+    // as unreliable metrics, so trackingSpaceMin isn't derived from it.
+    const MAX_SPACE_WIDTH_FACTOR = 1 / 3;
+
     // A negative white < fontSize * NEGATIVE_SPACE_FACTOR induces
     // a break (a new chunk of text is created).
     // It doesn't change anything when the text is copied but
     // it improves potential mismatch between text layer and canvas.
     const NEGATIVE_SPACE_FACTOR = -0.2;
 
-    // A white with a width in [fontSize * MIN_FACTOR; fontSize * MAX_FACTOR]
-    // is a space which will be inserted in the current flow of words.
+    // A white with a width in [trackingSpaceMin; fontSize * MAX_FACTOR] is a
+    // space which will be inserted in the current flow of words.
     // If the width is outside of this range then the flow is broken
     // (which means a new span in the text layer).
     // It's useful to adjust the best as possible the span in the layer
     // to what is displayed in the canvas.
-    const SPACE_IN_FLOW_MIN_FACTOR = 0.102;
     const SPACE_IN_FLOW_MAX_FACTOR = 0.6;
 
+    // When every gap within a run is wider than the space threshold (e.g.
+    // letter-spaced text), the threshold is raised to this multiple of the
+    // smallest gap, capped at fontSize * WIDE_SPACE_MAX_FACTOR, so the gaps
+    // between letters of a single word aren't turned into spaces.
+    const WIDE_SPACE_MULT = 1.3;
+    const WIDE_SPACE_MAX_FACTOR = 0.4;
+
+    // For fonts without usable space metrics (Type3), the space threshold is
+    // derived from the current glyph's own advance width instead of the font
+    // size, since the latter is unreliable when the font matrix does the
+    // scaling.
+    const CHAR_WIDTH_SPACE_FACTOR = 0.25;
+
     // If a char is too high/too low compared to the previous we just create
     // a new chunk.
     // If the advance isn't in the +/-VERTICAL_SHIFT_RATIO * height range then
@@ -2516,6 +2538,7 @@ class PartialEvaluator {
     const preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
 
     let textState, currentTextState;
+    let lastFakeSpaceExtraCharId = -1;
 
     function pushWhitespace({
       width = 0,
@@ -2610,10 +2633,21 @@ class PartialEvaluator {
       textContentItem.textAdvanceScale = scaleCtmX * scaleLineX;
 
       const { fontSize } = textState;
-      textContentItem.trackingSpaceMin = fontSize * TRACKING_SPACE_FACTOR;
+
+      let trackingFactor = TRACKING_SPACE_FACTOR;
+      if (!font.isType3Font) {
+        const spaceEm = font.spaceWidth / 1000;
+        if (spaceEm > 0 && spaceEm <= MAX_SPACE_WIDTH_FACTOR) {
+          trackingFactor = Math.max(0.5 * spaceEm, TRACKING_SPACE_FACTOR);
+        }
+      }
+      textContentItem.trackingSpaceMin = fontSize * trackingFactor;
+      textContentItem.useCharWidthThreshold = font.isType3Font;
+      textContentItem.spaceInFlowMin = fontSize * trackingFactor;
+      textContentItem.wideSpaceMax = fontSize * WIDE_SPACE_MAX_FACTOR;
+      resetAdaptiveSpacing();
       textContentItem.notASpace = fontSize * NOT_A_SPACE_FACTOR;
       textContentItem.negativeSpaceMax = fontSize * NEGATIVE_SPACE_FACTOR;
-      textContentItem.spaceInFlowMin = fontSize * SPACE_IN_FLOW_MIN_FACTOR;
       textContentItem.spaceInFlowMax = fontSize * SPACE_IN_FLOW_MAX_FACTOR;
       textContentItem.hasEOL = false;
 
@@ -2690,6 +2724,81 @@ class PartialEvaluator {
       ];
     }
 
+    function getTrackingSpaceMin(glyphWidth) {
+      if (textContentItem.useCharWidthThreshold && glyphWidth) {
+        return (
+          Math.abs(glyphWidth * textState.textHScale) * CHAR_WIDTH_SPACE_FACTOR
+        );
+      }
+      return textContentItem.trackingSpaceMin;
+    }
+
+    function getSpaceThreshold(trackingSpaceMin) {
+      const { minAdvance, wideSpaceMax } = textContentItem;
+      if (
+        minAdvance > trackingSpaceMin &&
+        minAdvance < WIDE_SPACE_MULT * trackingSpaceMin
+      ) {
+        return Math.min(WIDE_SPACE_MULT * minAdvance, wideSpaceMax);
+      }
+      return trackingSpaceMin;
+    }
+
+    function resetAdaptiveSpacing() {
+      textContentItem.minAdvance = Infinity;
+      textContentItem.pendingSpaceIndex = -1;
+      textContentItem.pendingSpaceAdvance = 0;
+      textContentItem.pendingSpaceExtraCharId = -1;
+    }
+
+    function recordPendingSpace(advance, textOrientation) {
+      if (textContentItem.minAdvance < Infinity) {
+        return;
+      }
+      textContentItem.pendingSpaceIndex = textContentItem.str.length - 1;
+      textContentItem.pendingSpaceAdvance = textOrientation * advance;
+      textContentItem.pendingSpaceExtraCharId = lastFakeSpaceExtraCharId;
+    }
+
+    function resolvePendingSpace(
+      advance,
+      textOrientation,
+      trackingSpaceMin,
+      spaceThreshold
+    ) {
+      if (textContentItem.pendingSpaceIndex < 0) {
+        return;
+      }
+      const { pendingSpaceAdvance } = textContentItem;
+      const forwardAdvance = textOrientation * advance;
+      const baseline = Math.min(pendingSpaceAdvance, forwardAdvance);
+      if (
+        baseline > trackingSpaceMin / WIDE_SPACE_MULT &&
+        forwardAdvance <= spaceThreshold &&
+        pendingSpaceAdvance <= spaceThreshold
+      ) {
+        textContentItem.str.splice(textContentItem.pendingSpaceIndex, 1);
+        if (textContentItem.pendingSpaceExtraCharId >= 0) {
+          intersector?.removeExtraChar(textContentItem.pendingSpaceExtraCharId);
+        }
+      }
+      textContentItem.pendingSpaceIndex = -1;
+      textContentItem.pendingSpaceExtraCharId = -1;
+    }
+
+    function recordMinAdvance(advance, textOrientation, trackingSpaceMin) {
+      if (textContentItem.useCharWidthThreshold) {
+        return;
+      }
+      const forwardAdvance = textOrientation * advance;
+      if (
+        forwardAdvance > trackingSpaceMin &&
+        forwardAdvance < textContentItem.minAdvance
+      ) {
+        textContentItem.minAdvance = forwardAdvance;
+      }
+    }
+
     function compareWithLastPosition(glyphWidth) {
       const currentTransform = getCurrentTextTransform();
       let posX = currentTransform[4];
@@ -2722,6 +2831,7 @@ class PartialEvaluator {
       let lastPosY = textContentItem.prevTransform[5];
 
       if (lastPosX === posX && lastPosY === posY) {
+        textContentItem.minAdvance = Infinity;
         return true;
       }
 
@@ -2808,7 +2918,15 @@ class PartialEvaluator {
           resetLastChars();
         }
 
-        if (advanceY <= textOrientation * textContentItem.trackingSpaceMin) {
+        const trackingSpaceMin = getTrackingSpaceMin(glyphWidth);
+        const spaceThreshold = getSpaceThreshold(trackingSpaceMin);
+        resolvePendingSpace(
+          advanceY,
+          textOrientation,
+          trackingSpaceMin,
+          spaceThreshold
+        );
+        if (advanceY <= textOrientation * spaceThreshold) {
           if (shouldAddWhitepsace()) {
             // The space is very thin, hence it deserves to have its own span in
             // order to avoid too much shift between the canvas and the text
@@ -2831,9 +2949,12 @@ class PartialEvaluator {
             pushWhitespace({ height: Math.abs(advanceY) });
           } else {
             textContentItem.height += advanceY;
+            recordPendingSpace(advanceY, textOrientation);
           }
         }
 
+        recordMinAdvance(advanceY, textOrientation, trackingSpaceMin);
+
         if (Math.abs(advanceX) > textContentItem.width * VERTICAL_SHIFT_RATIO) {
           flushTextContentItem();
         }
@@ -2888,7 +3009,15 @@ class PartialEvaluator {
         resetLastChars();
       }
 
-      if (advanceX <= textOrientation * textContentItem.trackingSpaceMin) {
+      const trackingSpaceMin = getTrackingSpaceMin(glyphWidth);
+      const spaceThreshold = getSpaceThreshold(trackingSpaceMin);
+      resolvePendingSpace(
+        advanceX,
+        textOrientation,
+        trackingSpaceMin,
+        spaceThreshold
+      );
+      if (advanceX <= textOrientation * spaceThreshold) {
         if (shouldAddWhitepsace()) {
           // The space is very thin, hence it deserves to have its own span in
           // order to avoid too much shift between the canvas and the text
@@ -2907,9 +3036,12 @@ class PartialEvaluator {
           pushWhitespace({ width: Math.abs(advanceX) });
         } else {
           textContentItem.width += advanceX;
+          recordPendingSpace(advanceX, textOrientation);
         }
       }
 
+      recordMinAdvance(advanceX, textOrientation, trackingSpaceMin);
+
       if (Math.abs(advanceY) > textContentItem.height * VERTICAL_SHIFT_RATIO) {
         flushTextContentItem();
       }
@@ -3092,14 +3224,15 @@ class PartialEvaluator {
     }
 
     function addFakeSpaces(width, transf, textOrientation) {
+      lastFakeSpaceExtraCharId = -1;
       if (
         textOrientation * textContentItem.spaceInFlowMin <= width &&
         width <= textOrientation * textContentItem.spaceInFlowMax
       ) {
         if (textContentItem.initialized) {
           resetLastChars();
           textContentItem.str.push(" ");
-          intersector?.addExtraChar(" ");
+          lastFakeSpaceExtraCharId = intersector?.addExtraChar(" ") ?? -1;
         }
         return false;
       }
@@ -3140,6 +3273,7 @@ class PartialEvaluator {
 
       textContent.items.push(runBidiTransform(textContentItem));
       textContentItem.initialized = false;
+      resetAdaptiveSpacing();
       textContentItem.str.length = 0;
     }
 
@@ -3216,7 +3350,10 @@ class PartialEvaluator {
             textState.textRise = args[0];
             break;
           case OPS.setHScale:
-            textState.textHScale = args[0] / 100;
+            if (textState.textHScale !== args[0] / 100) {
+              textState.textHScale = args[0] / 100;
+              resetAdaptiveSpacing();
+            }
             break;
           case OPS.setLeading:
             textState.leading = args[0];
@@ -3251,12 +3388,19 @@ class PartialEvaluator {
               args[5]
             );
             updateAdvanceScale();
+            resetAdaptiveSpacing();
             break;
           case OPS.setCharSpacing:
-            textState.charSpacing = args[0];
+            if (textState.charSpacing !== args[0]) {
+              textState.charSpacing = args[0];
+              resetAdaptiveSpacing();
+            }
             break;
           case OPS.setWordSpacing:
-            textState.wordSpacing = args[0];
+            if (textState.wordSpacing !== args[0]) {
+              textState.wordSpacing = args[0];
+              resetAdaptiveSpacing();
+            }
             break;
           case OPS.beginText:
             textState.textMatrix = IDENTITY_MATRIX.slice();
@@ -3328,8 +3472,14 @@ class PartialEvaluator {
               self.ensureStateFont(stateManager.state);
               continue;
             }
-            textState.wordSpacing = args[0];
-            textState.charSpacing = args[1];
+            if (
+              textState.wordSpacing !== args[0] ||
+              textState.charSpacing !== args[1]
+            ) {
+              textState.wordSpacing = args[0];
+              textState.charSpacing = args[1];
+              resetAdaptiveSpacing();
+            }
             textState.carriageReturn();
             buildTextContentItem({
               chars: args[2],

src/core/fonts.js

@@ -3462,10 +3462,7 @@ class Font {
     return builder.toArray();
   }
 
-  /**
-   * @private
-   */
-  get _spaceWidth() {
+  get spaceWidth() {
     // trying to estimate space character width
     const possibleSpaceReplacements = ["space", "minus", "one", "i", "I"];
     let width;
@@ -3500,7 +3497,7 @@ class Font {
         break; // the non-zero width found
       }
     }
-    return shadow(this, "_spaceWidth", width || this.defaultWidth);
+    return shadow(this, "spaceWidth", width || this.defaultWidth);
   }
 
   /**
@@ -3552,7 +3549,7 @@ class Font {
         if (glyphName === "") {
           // Ensure that other relevant glyph properties are also updated
           // (fixes issue18059.pdf).
-          width ||= this._spaceWidth;
+          width ||= this.spaceWidth;
           unicode = String.fromCharCode(fontCharCode);
         }
       }