pdfjs-dist 2.6.347 → 2.7.570

package/lib/core/evaluator.js

@@ -24,7 +24,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PartialEvaluator = void 0;
+exports.PartialEvaluator = exports.EvaluatorPreprocessor = void 0;
 
 var _util = require("../shared/util.js");
 
@@ -226,12 +226,16 @@ class PartialEvaluator {
     return newEvaluator;
   }
 
-  hasBlendModes(resources) {
+  hasBlendModes(resources, nonBlendModesSet) {
     if (!(resources instanceof _primitives.Dict)) {
       return false;
     }
 
-    const processed = new _primitives.RefSet();
+    if (resources.objId && nonBlendModesSet.has(resources.objId)) {
+      return false;
+    }
+
+    const processed = new _primitives.RefSet(nonBlendModesSet);
 
     if (resources.objId) {
       processed.put(resources.objId);
@@ -343,6 +347,9 @@ class PartialEvaluator {
       }
     }
 
+    processed.forEach(ref => {
+      nonBlendModesSet.put(ref);
+    });
     return false;
   }
 
@@ -680,7 +687,7 @@ class PartialEvaluator {
     return transferMaps;
   }
 
-  handleTilingType(fn, args, resources, pattern, patternDict, operatorList, task) {
+  handleTilingType(fn, color, resources, pattern, patternDict, operatorList, task, cacheKey, localTilingPatternCache) {
     const tilingOpList = new _operator_list.OperatorList();
 
     const patternResources = _primitives.Dict.merge({
@@ -694,14 +701,18 @@ class PartialEvaluator {
       resources: patternResources,
       operatorList: tilingOpList
     }).then(function () {
-      return (0, _pattern.getTilingPatternIR)({
-        fnArray: tilingOpList.fnArray,
-        argsArray: tilingOpList.argsArray
-      }, patternDict, args);
-    }).then(function (tilingPatternIR) {
+      const operatorListIR = tilingOpList.getIR();
+      const tilingPatternIR = (0, _pattern.getTilingPatternIR)(operatorListIR, patternDict, color);
       operatorList.addDependencies(tilingOpList.dependencies);
       operatorList.addOp(fn, tilingPatternIR);
-    }, reason => {
+
+      if (cacheKey) {
+        localTilingPatternCache.set(cacheKey, patternDict.objId, {
+          operatorListIR,
+          dict: patternDict
+        });
+      }
+    }).catch(reason => {
       if (reason instanceof _util.AbortException) {
         return;
       }
@@ -718,17 +729,15 @@ class PartialEvaluator {
     });
   }
 
-  handleSetFont(resources, fontArgs, fontRef, operatorList, task, state) {
-    var fontName,
-        fontSize = 0;
+  handleSetFont(resources, fontArgs, fontRef, operatorList, task, state, fallbackFontDict = null) {
+    var fontName;
 
     if (fontArgs) {
       fontArgs = fontArgs.slice();
       fontName = fontArgs[0].name;
-      fontSize = fontArgs[1];
     }
 
-    return this.loadFont(fontName, fontRef, resources).then(translated => {
+    return this.loadFont(fontName, fontRef, resources, fallbackFontDict).then(translated => {
       if (!translated.font.isType3Font) {
         return translated;
       }
@@ -749,8 +758,6 @@ class PartialEvaluator {
       });
     }).then(translated => {
       state.font = translated.font;
-      state.fontSize = fontSize;
-      state.fontName = fontName;
       translated.send(this.handler);
       return translated.loadedName;
     });
@@ -895,14 +902,14 @@ class PartialEvaluator {
     });
   }
 
-  loadFont(fontName, font, resources) {
-    const errorFont = () => {
-      return Promise.resolve(new TranslatedFont({
+  loadFont(fontName, font, resources, fallbackFontDict = null) {
+    const errorFont = async () => {
+      return new TranslatedFont({
         loadedName: "g_font_error",
         font: new _fonts.ErrorFont(`Font "${fontName}" is not available.`),
         dict: font,
         extraProperties: this.options.fontExtraProperties
-      }));
+      });
     };
 
     var fontRef,
@@ -934,7 +941,12 @@ class PartialEvaluator {
         featureId: _util.UNSUPPORTED_FEATURES.errorFontMissing
       });
       (0, _util.warn)(`${partialMsg} -- attempting to fallback to a default font.`);
-      fontRef = PartialEvaluator.fallbackFontDict;
+
+      if (fallbackFontDict) {
+        fontRef = fallbackFontDict;
+      } else {
+        fontRef = PartialEvaluator.fallbackFontDict;
+      }
     }
 
     if (this.fontCache.has(fontRef)) {
@@ -947,12 +959,20 @@ class PartialEvaluator {
       return errorFont();
     }
 
-    if (font.translated) {
-      return font.translated;
+    if (font.cacheKey && this.fontCache.has(font.cacheKey)) {
+      return this.fontCache.get(font.cacheKey);
     }
 
     var fontCapability = (0, _util.createPromiseCapability)();
-    var preEvaluatedFont = this.preEvaluateFont(font);
+    let preEvaluatedFont;
+
+    try {
+      preEvaluatedFont = this.preEvaluateFont(font);
+    } catch (reason) {
+      (0, _util.warn)(`loadFont - ignoring preEvaluateFont errors: "${reason}".`);
+      return errorFont();
+    }
+
     const {
       descriptor,
       hash
@@ -998,21 +1018,13 @@ class PartialEvaluator {
         fontID = this.idFactory.createFontId();
       }
 
-      this.fontCache.put(`id_${fontID}`, fontCapability.promise);
+      font.cacheKey = `cacheKey_${fontID}`;
+      this.fontCache.put(font.cacheKey, fontCapability.promise);
     }
 
     (0, _util.assert)(fontID && fontID.startsWith("f"), 'The "fontID" must be (correctly) defined.');
     font.loadedName = `${this.idFactory.getDocId()}_${fontID}`;
-    font.translated = fontCapability.promise;
-    var translatedPromise;
-
-    try {
-      translatedPromise = this.translateFont(preEvaluatedFont);
-    } catch (e) {
-      translatedPromise = Promise.reject(e);
-    }
-
-    translatedPromise.then(translatedFont => {
+    this.translateFont(preEvaluatedFont).then(translatedFont => {
       if (translatedFont.fontType !== undefined) {
         var xrefFontStats = xref.stats.fontTypes;
         xrefFontStats[translatedFont.fontType] = true;
@@ -1100,26 +1112,45 @@ class PartialEvaluator {
     });
   }
 
-  async handleColorN(operatorList, fn, args, cs, patterns, resources, task, localColorSpaceCache) {
-    var patternName = args[args.length - 1];
-    var pattern;
+  handleColorN(operatorList, fn, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache) {
+    const patternName = args.pop();
 
-    if ((0, _primitives.isName)(patternName) && (pattern = patterns.get(patternName.name))) {
-      var dict = (0, _primitives.isStream)(pattern) ? pattern.dict : pattern;
-      var typeNum = dict.get("PatternType");
+    if (patternName instanceof _primitives.Name) {
+      const name = patternName.name;
+      const localTilingPattern = localTilingPatternCache.getByName(name);
 
-      if (typeNum === PatternType.TILING) {
-        var color = cs.base ? cs.base.getRgb(args, 0) : null;
-        return this.handleTilingType(fn, color, resources, pattern, dict, operatorList, task);
-      } else if (typeNum === PatternType.SHADING) {
-        var shading = dict.get("Shading");
-        var matrix = dict.getArray("Matrix");
-        pattern = _pattern.Pattern.parseShading(shading, matrix, this.xref, resources, this.handler, this._pdfFunctionFactory, localColorSpaceCache);
-        operatorList.addOp(fn, pattern.getIR());
-        return undefined;
+      if (localTilingPattern) {
+        try {
+          const color = cs.base ? cs.base.getRgb(args, 0) : null;
+          const tilingPatternIR = (0, _pattern.getTilingPatternIR)(localTilingPattern.operatorListIR, localTilingPattern.dict, color);
+          operatorList.addOp(fn, tilingPatternIR);
+          return undefined;
+        } catch (ex) {
+          if (ex instanceof _core_utils.MissingDataException) {
+            throw ex;
+          }
+        }
       }
 
-      throw new _util.FormatError(`Unknown PatternType: ${typeNum}`);
+      let pattern = patterns.get(name);
+
+      if (pattern) {
+        var dict = (0, _primitives.isStream)(pattern) ? pattern.dict : pattern;
+        var typeNum = dict.get("PatternType");
+
+        if (typeNum === PatternType.TILING) {
+          const color = cs.base ? cs.base.getRgb(args, 0) : null;
+          return this.handleTilingType(fn, color, resources, pattern, dict, operatorList, task, name, localTilingPatternCache);
+        } else if (typeNum === PatternType.SHADING) {
+          var shading = dict.get("Shading");
+          var matrix = dict.getArray("Matrix");
+          pattern = _pattern.Pattern.parseShading(shading, matrix, this.xref, resources, this.handler, this._pdfFunctionFactory, localColorSpaceCache);
+          operatorList.addOp(fn, pattern.getIR());
+          return undefined;
+        }
+
+        throw new _util.FormatError(`Unknown PatternType: ${typeNum}`);
+      }
     }
 
     throw new _util.FormatError(`Unknown PatternName: ${patternName}`);
@@ -1186,7 +1217,8 @@ class PartialEvaluator {
     task,
     resources,
     operatorList,
-    initialState = null
+    initialState = null,
+    fallbackFontDict = null
   }) {
     resources = resources || _primitives.Dict.empty;
     initialState = initialState || new EvalState();
@@ -1201,6 +1233,7 @@ class PartialEvaluator {
     const localImageCache = new _image_utils.LocalImageCache();
     const localColorSpaceCache = new _image_utils.LocalColorSpaceCache();
     const localGStateCache = new _image_utils.LocalGStateCache();
+    const localTilingPatternCache = new _image_utils.LocalTilingPatternCache();
 
     var xobjs = resources.get("XObject") || _primitives.Dict.empty;
 
@@ -1341,7 +1374,7 @@ class PartialEvaluator {
 
           case _util.OPS.setFont:
             var fontSize = args[1];
-            next(self.handleSetFont(resources, args, null, operatorList, task, stateManager.state).then(function (loadedName) {
+            next(self.handleSetFont(resources, args, null, operatorList, task, stateManager.state, fallbackFontDict).then(function (loadedName) {
               operatorList.addDependency(loadedName);
               operatorList.addOp(_util.OPS.setFont, [loadedName, fontSize]);
             }));
@@ -1533,7 +1566,7 @@ class PartialEvaluator {
             cs = stateManager.state.fillColorSpace;
 
             if (cs.name === "Pattern") {
-              next(self.handleColorN(operatorList, _util.OPS.setFillColorN, args, cs, patterns, resources, task, localColorSpaceCache));
+              next(self.handleColorN(operatorList, _util.OPS.setFillColorN, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache));
               return;
             }
 
@@ -1545,7 +1578,7 @@ class PartialEvaluator {
             cs = stateManager.state.strokeColorSpace;
 
             if (cs.name === "Pattern") {
-              next(self.handleColorN(operatorList, _util.OPS.setStrokeColorN, args, cs, patterns, resources, task, localColorSpaceCache));
+              next(self.handleColorN(operatorList, _util.OPS.setStrokeColorN, args, cs, patterns, resources, task, localColorSpaceCache, localTilingPatternCache));
               return;
             }
 
@@ -2875,6 +2908,11 @@ class PartialEvaluator {
       }
 
       dict = Array.isArray(df) ? this.xref.fetchIfRef(df[0]) : df;
+
+      if (!(dict instanceof _primitives.Dict)) {
+        throw new _util.FormatError("Descendant font is not a dictionary.");
+      }
+
       type = dict.get("Subtype");
 
       if (!(0, _primitives.isName)(type)) {
@@ -2950,7 +2988,7 @@ class PartialEvaluator {
     };
   }
 
-  translateFont(preEvaluatedFont) {
+  async translateFont(preEvaluatedFont) {
     var baseDict = preEvaluatedFont.baseDict;
     var dict = preEvaluatedFont.dict;
     var composite = preEvaluatedFont.composite;
@@ -3022,7 +3060,7 @@ class PartialEvaluator {
       var baseFontStr = baseFont && baseFont.name;
 
       if (fontNameStr !== baseFontStr) {
-        (0, _util.info)(`The FontDescriptor\'s FontName is "${fontNameStr}" but ` + `should be the same as the Font\'s BaseFont "${baseFontStr}".`);
+        (0, _util.info)(`The FontDescriptor's FontName is "${fontNameStr}" but ` + `should be the same as the Font's BaseFont "${baseFontStr}".`);
 
         if (fontNameStr && baseFontStr && baseFontStr.startsWith(fontNameStr)) {
           fontName = baseFont;
@@ -3075,30 +3113,24 @@ class PartialEvaluator {
       italicAngle: descriptor.get("ItalicAngle"),
       isType3Font: false
     };
-    var cMapPromise;
 
     if (composite) {
-      var cidEncoding = baseDict.get("Encoding");
+      const cidEncoding = baseDict.get("Encoding");
 
       if ((0, _primitives.isName)(cidEncoding)) {
         properties.cidEncoding = cidEncoding.name;
       }
 
-      cMapPromise = _cmap.CMapFactory.create({
+      const cMap = await _cmap.CMapFactory.create({
         encoding: cidEncoding,
         fetchBuiltInCMap: this._fetchBuiltInCMapBound,
         useCMap: null
-      }).then(function (cMap) {
-        properties.cMap = cMap;
-        properties.vertical = properties.cMap.vertical;
       });
-    } else {
-      cMapPromise = Promise.resolve(undefined);
+      properties.cMap = cMap;
+      properties.vertical = properties.cMap.vertical;
     }
 
-    return cMapPromise.then(() => {
-      return this.extractDataStructures(dict, baseDict, properties);
-    }).then(newProperties => {
+    return this.extractDataStructures(dict, baseDict, properties).then(newProperties => {
       this.extractWidths(dict, descriptor, newProperties);
 
       if (type === "Type3") {
@@ -3197,7 +3229,7 @@ class TranslatedFont {
     var charProcOperatorList = Object.create(null);
 
     for (const key of charProcs.getKeys()) {
-      loadCharProcsPromise = loadCharProcsPromise.then(function () {
+      loadCharProcsPromise = loadCharProcsPromise.then(() => {
         var glyphStream = charProcs.get(key);
         var operatorList = new _operator_list.OperatorList();
         return type3Evaluator.getOperatorList({
@@ -3205,7 +3237,11 @@ class TranslatedFont {
           task,
           resources: fontResources,
           operatorList
-        }).then(function () {
+        }).then(() => {
+          if (operatorList.fnArray[0] === _util.OPS.setCharWidthAndBounds) {
+            this._removeType3ColorOperators(operatorList);
+          }
+
           charProcOperatorList[key] = operatorList.getIR();
 
           for (const dependency of operatorList.dependencies) {
@@ -3225,10 +3261,66 @@ class TranslatedFont {
     return this.type3Loaded;
   }
 
+  _removeType3ColorOperators(operatorList) {
+    let i = 1,
+        ii = operatorList.length;
+
+    while (i < ii) {
+      switch (operatorList.fnArray[i]) {
+        case _util.OPS.setStrokeColorSpace:
+        case _util.OPS.setFillColorSpace:
+        case _util.OPS.setStrokeColor:
+        case _util.OPS.setStrokeColorN:
+        case _util.OPS.setFillColor:
+        case _util.OPS.setFillColorN:
+        case _util.OPS.setStrokeGray:
+        case _util.OPS.setFillGray:
+        case _util.OPS.setStrokeRGBColor:
+        case _util.OPS.setFillRGBColor:
+        case _util.OPS.setStrokeCMYKColor:
+        case _util.OPS.setFillCMYKColor:
+        case _util.OPS.shadingFill:
+        case _util.OPS.setRenderingIntent:
+          operatorList.fnArray.splice(i, 1);
+          operatorList.argsArray.splice(i, 1);
+          ii--;
+          continue;
+
+        case _util.OPS.setGState:
+          const [gStateObj] = operatorList.argsArray[i];
+          let j = 0,
+              jj = gStateObj.length;
+
+          while (j < jj) {
+            const [gStateKey] = gStateObj[j];
+
+            switch (gStateKey) {
+              case "TR":
+              case "TR2":
+              case "HT":
+              case "BG":
+              case "BG2":
+              case "UCR":
+              case "UCR2":
+                gStateObj.splice(j, 1);
+                jj--;
+                continue;
+            }
+
+            j++;
+          }
+
+          break;
+      }
+
+      i++;
+    }
+  }
+
 }
 
 class StateManager {
-  constructor(initialState) {
+  constructor(initialState = new EvalState()) {
     this.state = initialState;
     this.stateStack = [];
   }
@@ -3761,7 +3853,7 @@ class EvaluatorPreprocessor {
     return (0, _util.shadow)(this, "MAX_INVALID_PATH_OPS", 20);
   }
 
-  constructor(stream, xref, stateManager) {
+  constructor(stream, xref, stateManager = new StateManager()) {
     this.parser = new _parser.Parser({
       lexer: new _parser.Lexer(stream, EvaluatorPreprocessor.opMap),
       xref
@@ -3872,4 +3964,6 @@ class EvaluatorPreprocessor {
     }
   }
 
-}
+}
+
+exports.EvaluatorPreprocessor = EvaluatorPreprocessor;

package/lib/core/fonts.js

@@ -25,7 +25,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getFontType = getFontType;
-exports.IdentityToUnicodeMap = exports.ToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = exports.SEAC_ANALYSIS_ENABLED = void 0;
+exports.ToUnicodeMap = exports.SEAC_ANALYSIS_ENABLED = exports.IdentityToUnicodeMap = exports.FontFlags = exports.Font = exports.ErrorFont = void 0;
 
 var _util = require("../shared/util.js");
 
@@ -435,6 +435,7 @@ var Font = function FontClosure() {
     this.defaultWidth = properties.defaultWidth;
     this.composite = properties.composite;
     this.cMap = properties.cMap;
+    this.capHeight = properties.capHeight / PDF_GLYPH_SPACE_UNITS;
     this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS;
     this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS;
     this.fontMatrix = properties.fontMatrix;
@@ -466,7 +467,7 @@ var Font = function FontClosure() {
         (0, _util.warn)('Font file is empty in "' + name + '" (' + this.loadedName + ")");
       }
 
-      this.fallbackToSystemFont();
+      this.fallbackToSystemFont(properties);
       return;
     }
 
@@ -509,7 +510,7 @@ var Font = function FontClosure() {
       }
     } catch (e) {
       (0, _util.warn)(e);
-      this.fallbackToSystemFont();
+      this.fallbackToSystemFont(properties);
       return;
     }
 
@@ -1020,7 +1021,7 @@ var Font = function FontClosure() {
       return data;
     },
 
-    fallbackToSystemFont: function Font_fallbackToSystemFont() {
+    fallbackToSystemFont(properties) {
       this.missingFile = true;
       var name = this.name;
       var type = this.type;
@@ -1028,15 +1029,18 @@ var Font = function FontClosure() {
       let fontName = name.replace(/[,_]/g, "-").replace(/\s/g, "");
       var stdFontMap = (0, _standard_fonts.getStdFontMap)(),
           nonStdFontMap = (0, _standard_fonts.getNonStdFontMap)();
-      var isStandardFont = !!stdFontMap[fontName] || !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]);
+      const isStandardFont = !!stdFontMap[fontName];
+      const isMappedToStandardFont = !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]);
       fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;
       this.bold = fontName.search(/bold/gi) !== -1;
       this.italic = fontName.search(/oblique/gi) !== -1 || fontName.search(/italic/gi) !== -1;
       this.black = name.search(/Black/g) !== -1;
-      this.remeasure = Object.keys(this.widths).length > 0;
+      const isNarrow = name.search(/Narrow/g) !== -1;
+      this.remeasure = (!isStandardFont || isNarrow) && Object.keys(this.widths).length > 0;
 
-      if (isStandardFont && type === "CIDFontType2" && this.cidEncoding.startsWith("Identity-")) {
-        const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)();
+      if ((isStandardFont || isMappedToStandardFont) && type === "CIDFontType2" && this.cidEncoding.startsWith("Identity-")) {
+        const GlyphMapForStandardFonts = (0, _standard_fonts.getGlyphMapForStandardFonts)(),
+              cidToGidMap = properties.cidToGidMap;
         const map = [];
 
         for (const charCode in GlyphMapForStandardFonts) {
@@ -1057,6 +1061,16 @@ var Font = function FontClosure() {
           }
         }
 
+        if (cidToGidMap) {
+          for (const charCode in map) {
+            const cid = map[charCode];
+
+            if (cidToGidMap[cid] !== undefined) {
+              map[+charCode] = cidToGidMap[cid];
+            }
+          }
+        }
+
         var isIdentityUnicode = this.toUnicode instanceof IdentityToUnicodeMap;
 
         if (!isIdentityUnicode) {
@@ -1109,6 +1123,7 @@ var Font = function FontClosure() {
       this.loadedName = fontName.split("-")[0];
       this.fontType = getFontType(type, subtype);
     },
+
     checkAndRepair: function Font_checkAndRepair(name, font, properties) {
       const VALID_TABLES = ["OS/2", "cmap", "head", "hhea", "hmtx", "maxp", "name", "post", "loca", "glyf", "fpgm", "prep", "cvt ", "CFF "];
 
@@ -2641,7 +2656,7 @@ var Font = function FontClosure() {
       return (0, _util.shadow)(this, "spaceWidth", width);
     },
 
-    charToGlyph: function Font_charToGlyph(charcode, isSpace) {
+    _charToGlyph(charcode, isSpace = false) {
       var fontCharCode, width, operatorListId;
       var widthCode = charcode;
 
@@ -2706,6 +2721,7 @@ var Font = function FontClosure() {
 
       return glyph;
     },
+
     charsToGlyphs: function Font_charsToGlyphs(chars) {
       var charsCache = this.charsCache;
       var glyphs, glyph, charcode;
@@ -2736,13 +2752,13 @@ var Font = function FontClosure() {
           var length = c.length;
           i += length;
           var isSpace = length === 1 && chars.charCodeAt(i - 1) === 0x20;
-          glyph = this.charToGlyph(charcode, isSpace);
+          glyph = this._charToGlyph(charcode, isSpace);
           glyphs.push(glyph);
         }
       } else {
         for (i = 0, ii = chars.length; i < ii; ++i) {
           charcode = chars.charCodeAt(i);
-          glyph = this.charToGlyph(charcode, charcode === 0x20);
+          glyph = this._charToGlyph(charcode, charcode === 0x20);
           glyphs.push(glyph);
         }
       }
@@ -2750,8 +2766,75 @@ var Font = function FontClosure() {
       return charsCache[charsCacheKey] = glyphs;
     },
 
+    getCharPositions(chars) {
+      const positions = [];
+
+      if (this.cMap) {
+        const c = Object.create(null);
+        let i = 0;
+
+        while (i < chars.length) {
+          this.cMap.readCharCode(chars, i, c);
+          const length = c.length;
+          positions.push([i, i + length]);
+          i += length;
+        }
+      } else {
+        for (let i = 0, ii = chars.length; i < ii; ++i) {
+          positions.push([i, i + 1]);
+        }
+      }
+
+      return positions;
+    },
+
     get glyphCacheValues() {
       return Object.values(this.glyphCache);
+    },
+
+    encodeString(str) {
+      const buffers = [];
+      const currentBuf = [];
+
+      const hasCurrentBufErrors = () => buffers.length % 2 === 1;
+
+      for (let i = 0, ii = str.length; i < ii; i++) {
+        const unicode = str.codePointAt(i);
+
+        if (unicode > 0xd7ff && (unicode < 0xe000 || unicode > 0xfffd)) {
+          i++;
+        }
+
+        if (this.toUnicode) {
+          const char = String.fromCodePoint(unicode);
+          const charCode = this.toUnicode.charCodeOf(char);
+
+          if (charCode !== -1) {
+            if (hasCurrentBufErrors()) {
+              buffers.push(currentBuf.join(""));
+              currentBuf.length = 0;
+            }
+
+            const charCodeLength = this.cMap ? this.cMap.getCharCodeLength(charCode) : 1;
+
+            for (let j = charCodeLength - 1; j >= 0; j--) {
+              currentBuf.push(String.fromCharCode(charCode >> 8 * j & 0xff));
+            }
+
+            continue;
+          }
+        }
+
+        if (!hasCurrentBufErrors()) {
+          buffers.push(currentBuf.join(""));
+          currentBuf.length = 0;
+        }
+
+        currentBuf.push(String.fromCodePoint(unicode));
+      }
+
+      buffers.push(currentBuf.join(""));
+      return buffers;
     }
 
   };
@@ -2771,6 +2854,9 @@ var ErrorFont = function ErrorFontClosure() {
     charsToGlyphs: function ErrorFont_charsToGlyphs() {
       return [];
     },
+    encodeString: function ErrorFont_encodeString(chars) {
+      return [chars];
+    },
 
     exportData(extraProperties = false) {
       return {