PDF.js 源码解读: fonts

// 字体字典 /FontFile2 /FontFile3 + 内容流中的字符码
//   → PartialEvaluator.extractDataStructures / extractWidths   （属性准备）
//   → new Font(name, file, properties, options)                （本篇）
//       → getFontFileType → checkAndRepair / convert
//       → toUnicode / toFontChar / widths / fontMatrix
//   → Font._charToGlyph / charsToGlyphs                        （字符码 → Glyph）
//   → Font.renderer（FontRendererFactory）                     （字形轮廓）
//   → exportData → TranslatedFont.send → FontFaceObject        （主线程装载）
//   → canvas.js 的文本绘制与 text_layer 的文本选择

  constructor(name, file, properties, evaluatorOptions) {
    this.name = name;
    this.psName = null;
    this.mimetype = null;
    this.disableFontFace = evaluatorOptions.disableFontFace;
    this.fontExtraProperties = evaluatorOptions.fontExtraProperties;
 
    this.loadedName = properties.loadedName;
    this.isType3Font = properties.isType3Font;
    this.missingFile = false;
    this.cssFontInfo = properties.cssFontInfo;

let isSerifFont = !!(properties.flags & FontFlags.Serif);
// Fallback to checking the font name, in order to improve text-selection,
// since the /Flags-entry is often wrong (fixes issue13845.pdf).
if (!isSerifFont && !properties.isSimulatedFlags) {
  const stdFontMap = getStdFontMap(),
    nonStdFontMap = getNonStdFontMap(),
    serifFonts = getSerifFonts();
  for (const namePart of name.split('+')) {
    let fontName = normalizeFontName(namePart);
    fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;
    fontName = fontName.split('-', 1)[0];
    if (serifFonts[fontName]) {
      isSerifFont = true;
      break;
    }
  }
}
this.isSerifFont = isSerifFont;
 
this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);
this.isMonospace = !!(properties.flags & FontFlags.FixedPitch);

const matches = name.match(/^InvalidPDFjsFont_(.*)_\d+$/);
this.isInvalidPDFjsFont = !!matches;
if (this.isInvalidPDFjsFont) {
  this.fallbackName = matches[1];
} else if (this.isMonospace) {
  this.fallbackName = 'monospace';
} else if (this.isSerifFont) {
  this.fallbackName = 'serif';
} else {
  this.fallbackName = 'sans-serif';
}
 
if (this.systemFontInfo?.guessFallback) {
  // Once the fallback name is guessed, we don't want to guess it again.
  this.systemFontInfo.guessFallback = false;
  this.systemFontInfo.css += `,${this.fallbackName}`;
}

this.differences = properties.differences;
this.widths = properties.widths;
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.lineHeight = this.ascent - this.descent;
this.fontMatrix = properties.fontMatrix;
this.bbox = properties.bbox;
this.defaultEncoding = properties.defaultEncoding;
 
this.toUnicode = properties.toUnicode;
this.toFontChar = [];

if (properties.type === 'Type3') {
  for (let charCode = 0; charCode < 256; charCode++) {
    this.toFontChar[charCode] = this.differences[charCode] || properties.defaultEncoding[charCode];
  }
  return;
}

if (this.isType3Font) {
  // Font char code in this case is actually a glyph name.
  operatorListId = fontCharCode;
}

if (!file || file.isEmpty) {
  if (file) {
    // Some bad PDF generators will include empty font files,
    // attempting to recover by assuming that no file exists.
    warn('Font file is empty in "' + name + '" (' + this.loadedName + ')');
  }
  this.fallbackToSystemFont(properties);
  return;
}
 
// Parse the font file to determine the correct type/subtype, rather than
// relying on the (often incorrect) data in the font dictionary; (see e.g.
//  issue6782.pdf, issue7598.pdf, and issue9949.pdf).
[type, subtype] = getFontFileType(file, properties);

function getFontFileType(file, { type, subtype, composite }) {
  let fileType, fileSubtype;
 
  if (isTrueTypeFile(file) || isTrueTypeCollectionFile(file)) {
    fileType = composite ? 'CIDFontType2' : 'TrueType';
  } else if (isOpenTypeFile(file)) {
    fileType = composite ? 'CIDFontType2' : 'OpenType';
  } else if (isType1File(file)) {
    if (composite) {
      fileType = 'CIDFontType0';
    } else {
      fileType = type === 'MMType1' ? 'MMType1' : 'Type1';
    }
  } else if (isCFFFile(file)) {
    if (composite) {
      fileType = 'CIDFontType0';
      fileSubtype = 'CIDFontType0C';
    } else {
      fileType = type === 'MMType1' ? 'MMType1' : 'Type1';
      fileSubtype = 'Type1C';
    }
  } else {
    warn('getFontFileType: Unable to detect correct font file Type/Subtype.');
    fileType = type;
    fileSubtype = subtype;
  }
 
  return [fileType, fileSubtype];
}

let data;
try {
  switch (type) {
    case 'MMType1':
      info('MMType1 font (' + name + '), falling back to Type1.');
    /* falls through */
    case 'Type1':
    case 'CIDFontType0':
      this.mimetype = 'font/opentype';
 
      const cff =
        subtype === 'Type1C' || subtype === 'CIDFontType0C'
          ? new CFFFont(file, properties)
          : new Type1Font(name, file, properties);
 
      adjustWidths(properties);
 
      // Wrap the CFF data inside an OTF font file
      data = this.convert(name, cff, properties);
      break;
 
    case 'OpenType':
    case 'TrueType':
    case 'CIDFontType2':
      this.mimetype = 'font/opentype';
 
      // Repair the TrueType file. It is can be damaged in the point of
      // view of the sanitizer
      data = this.checkAndRepair(name, file, properties);
 
      adjustWidths(properties);
 
      if (this.isOpenType) {
        type = 'OpenType';
      }
      break;
 
    default:
      throw new FormatError(`Font ${type} is not supported`);
  }
} catch (e) {
  warn(e);
  this.fallbackToSystemFont(properties);
  return;
}

function adjustWidths(properties) {
  if (!properties.fontMatrix) {
    return;
  }
  if (properties.fontMatrix[0] === FONT_IDENTITY_MATRIX[0]) {
    return;
  }
  // adjusting width to fontMatrix scale
  const scale = 0.001 / properties.fontMatrix[0];
  const glyphsWidths = properties.widths;
  for (const glyph in glyphsWidths) {
    glyphsWidths[glyph] *= scale;
  }
  properties.defaultWidth *= scale;
}

amendFallbackToUnicode(properties);
this.data = data;
 
// Transfer some properties again that could change during font conversion
this.type = type;
this.subtype = subtype;
this.fontMatrix = properties.fontMatrix;
this.widths = properties.widths;
this.defaultWidth = properties.defaultWidth;
this.toUnicode = properties.toUnicode;
this.seacMap = properties.seacMap;

function amendFallbackToUnicode(properties) {
  if (!properties.fallbackToUnicode) {
    return;
  }
  if (properties.toUnicode instanceof IdentityToUnicodeMap) {
    return;
  }
  const toUnicode = [];
  for (const charCode in properties.fallbackToUnicode) {
    if (properties.toUnicode.has(charCode)) {
      continue; // The font dictionary has a `ToUnicode` entry.
    }
    toUnicode[charCode] = properties.fallbackToUnicode[charCode];
  }
  if (toUnicode.length > 0) {
    properties.toUnicode.amend(toUnicode);
  }
}

class Glyph {
  constructor(
    originalCharCode,
    fontChar,
    unicode,
    accent,
    width,
    vmetric,
    operatorListId,
    isSpace,
    isInFont,
  ) {
    this.originalCharCode = originalCharCode;
    this.fontChar = fontChar;
    this.unicode = unicode;
    this.accent = accent;
    this.width = width;
    this.vmetric = vmetric;
    this.operatorListId = operatorListId;
    this.isSpace = isSpace;
    this.isInFont = isInFont;
  }
 
  /**
   * This property, which is only used by `PartialEvaluator.getTextContent`,
   * is purposely made non-serializable.
   * @type {Object}
   */
  get category() {
    return shadow(
      this,
      'category',
      getCharUnicodeCategory(this.unicode),
      /* nonSerializable = */ true,
    );
  }
}

  _charToGlyph(charcode, isSpace = false) {
    let glyph = this.#glyphCache.get(charcode);
    // All `Glyph`-properties, except `isSpace` in multi-byte strings,
    // depend indirectly on the `charcode`.
    if (glyph?.isSpace === isSpace) {
      return glyph;
    }
    let fontCharCode, width, operatorListId;

let widthCode = charcode;
if (this.cMap?.contains(charcode)) {
  widthCode = this.cMap.lookup(charcode);
 
  if (typeof widthCode === 'string') {
    widthCode = convertCidString(charcode, widthCode);
  }
}
width = this.widths[widthCode];
if (typeof width !== 'number') {
  width = this.defaultWidth;
}
const vmetric = this.vmetrics?.[widthCode] || this.defaultVMetrics;

function convertCidString(charCode, cid, shouldThrow = false) {
  switch (cid.length) {
    case 1:
      return cid.charCodeAt(0);
    case 2:
      return (cid.charCodeAt(0) << 8) | cid.charCodeAt(1);
  }
  const msg = `Unsupported CID string (charCode ${charCode}): "${cid}".`;
  if (shouldThrow) {
    throw new FormatError(msg);
  }
  warn(msg);
  return cid;
}

let unicode = this.toUnicode.get(charcode) || charcode;
if (typeof unicode === 'number') {
  unicode = String.fromCharCode(unicode);
}
 
let isInFont = this.toFontChar[charcode] !== undefined;
// First try the toFontChar map, if it's not there then try falling
// back to the char code.
fontCharCode = this.toFontChar[charcode] || charcode;

if (this.missingFile) {
  const glyphName = this.differences[charcode] || this.defaultEncoding[charcode];
  if ((glyphName === '.notdef' || glyphName === '') && this.type === 'Type1') {
    // .notdef glyphs should be invisible in non-embedded Type1 fonts, so
    // replace them with spaces.
    fontCharCode = 0x20;
 
    if (glyphName === '') {
      // Ensure that other relevant glyph properties are also updated
      // (fixes issue18059.pdf).
      width ||= this._spaceWidth;
      unicode = String.fromCharCode(fontCharCode);
    }
  }
  fontCharCode = mapSpecialUnicodeValues(fontCharCode);
}

let accent = null;
if (this.seacMap?.[charcode]) {
  isInFont = true;
  const seac = this.seacMap[charcode];
  fontCharCode = seac.baseFontCharCode;
  accent = {
    fontChar: String.fromCodePoint(seac.accentFontCharCode),
    offset: seac.accentOffset,
  };
}

    let fontChar = "";
    if (typeof fontCharCode === "number") {
      if (fontCharCode <= 0x10ffff) {
        fontChar = String.fromCodePoint(fontCharCode);
      } else {
        warn(`charToGlyph - invalid fontCharCode: ${fontCharCode}`);
      }
    }
 
    if (this.missingFile && this.vertical && fontChar.length === 1) {
      const vertical = getVerticalPresentationForm()[fontChar.charCodeAt(0)];
      if (vertical) {
        fontChar = unicode = String.fromCharCode(vertical);
      }
    }
 
    glyph = new Glyph(
      charcode,
      fontChar,
      unicode,
      accent,
      width,
      vmetric,
      operatorListId,
      isSpace,
      isInFont
    );
    this.#glyphCache.set(charcode, glyph);
    return glyph;
  }

  charsToGlyphs(chars) {
    // If we translated this string before, just grab it from the cache.
    let glyphs = this.#charsCache.get(chars);
    if (glyphs) {
      return glyphs;
    }
    glyphs = [];
 
    if (this.cMap) {
      // Composite fonts have multi-byte strings, convert the string from
      // single-byte to multi-byte.
      const c = Object.create(null),
        ii = chars.length;
      let i = 0;
      while (i < ii) {
        this.cMap.readCharCode(chars, i, c);
        const { charcode, length } = c;
        i += length;
        // Space is char with code 0x20 and length 1 in multiple-byte codes.
        const glyph = this._charToGlyph(
          charcode,
          length === 1 && chars.charCodeAt(i - 1) === 0x20
        );
        glyphs.push(glyph);
      }
    } else {
      for (let i = 0, ii = chars.length; i < ii; ++i) {
        const charcode = chars.charCodeAt(i);
        const glyph = this._charToGlyph(charcode, charcode === 0x20);
        glyphs.push(glyph);
      }
    }
 
    // Enter the translated string into the cache.
    this.#charsCache.set(chars, glyphs);
    return glyphs;
  }

class Font {
  #charsCache = new Map();
 
  #glyphCache = new Map();

  get glyphCacheValues() {
    return this.#glyphCache.values();
  }

PartialEvaluator.buildFontPaths(
  this.font,
  /* glyphs = */ this.font.glyphCacheValues,
  handler,
  evaluatorOptions,
);

  getCharPositions(chars) {
    // This function doesn't use a cache because
    // it's called only when saving or printing.
    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;
  }

class ToUnicodeMap {
  constructor(cmap = []) {
    // The elements of this._map can be integers or strings, depending on how
    // `cmap` was created.
    this._map = cmap;
  }
 
  get length() {
    return this._map.length;
  }
 
  forEach(callback) {
    for (const charCode in this._map) {
      callback(charCode, this._map[charCode].codePointAt(0));
    }
  }
 
  has(i) {
    return this._map[i] !== undefined;
  }
 
  get(i) {
    return this._map[i];
  }

class IdentityToUnicodeMap {
  constructor(firstChar, lastChar) {
    this.firstChar = firstChar;
    this.lastChar = lastChar;
  }
 
  get length() {
    return this.lastChar + 1 - this.firstChar;
  }
 
  forEach(callback) {
    for (let i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
      callback(i, i);
    }
  }
 
  has(i) {
    return this.firstChar <= i && i <= this.lastChar;
  }

function buildToFontChar(encoding, glyphsUnicodeMap, differences) {
  const toFontChar = [];
  let unicode;
  for (let i = 0, ii = encoding.length; i < ii; i++) {
    unicode = getUnicodeForGlyph(encoding[i], glyphsUnicodeMap);
    if (unicode !== -1) {
      toFontChar[i] = unicode;
    }
  }
  for (const charCode in differences) {
    unicode = getUnicodeForGlyph(differences[charCode], glyphsUnicodeMap);
    if (unicode !== -1) {
      toFontChar[+charCode] = unicode;
    }
  }
  return toFontChar;
}

function adjustMapping(charCodeToGlyphId, hasGlyph, newGlyphZeroId, toUnicode) {
  const newMap = Object.create(null);
  const toUnicodeExtraMap = new Map();
  const toFontChar = [];
  const usedGlyphIds = new Set();
  let privateUseAreaIndex = 0;
  const privateUseOffetStart = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
  let nextAvailableFontCharCode = privateUseOffetStart;
  let privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
  const isInPrivateArea = code =>
    (PRIVATE_USE_AREAS[0][0] <= code && code <= PRIVATE_USE_AREAS[0][1]) ||
    (PRIVATE_USE_AREAS[1][0] <= code && code <= PRIVATE_USE_AREAS[1][1]);
  let LIGATURE_TO_UNICODE = null;

  for (const originalCharCode in charCodeToGlyphId) {
    let glyphId = charCodeToGlyphId[originalCharCode];
    // For missing glyphs don't create the mappings so the glyph isn't
    // drawn.
    if (!hasGlyph(glyphId)) {
      continue;
    }
    if (nextAvailableFontCharCode > privateUseOffetEnd) {
      privateUseAreaIndex++;
      if (privateUseAreaIndex >= PRIVATE_USE_AREAS.length) {
        warn("Ran out of space in font private use area.");
        break;
      }
      nextAvailableFontCharCode = PRIVATE_USE_AREAS[privateUseAreaIndex][0];
      privateUseOffetEnd = PRIVATE_USE_AREAS[privateUseAreaIndex][1];
    }
    const fontCharCode = nextAvailableFontCharCode++;
    if (glyphId === 0) {
      glyphId = newGlyphZeroId;
    }

    let unicode = toUnicode.get(originalCharCode);
    if (typeof unicode === "string") {
      if (unicode.length === 1) {
        unicode = unicode.codePointAt(0);
      } else {
        if (!LIGATURE_TO_UNICODE) {
          LIGATURE_TO_UNICODE = new Map();
          // The code range [0xfb00, 0xfb4f] contains some ligature characters
          // but not all.
          for (let i = 0xfb00; i <= 0xfb4f; i++) {
            const normalized = String.fromCharCode(i).normalize("NFKD");
            if (normalized.length > 1) {
              LIGATURE_TO_UNICODE.set(normalized, i);
            }
          }
        }
        unicode = LIGATURE_TO_UNICODE.get(unicode) || unicode.codePointAt(0);
      }
    }
    if (unicode && !isInPrivateArea(unicode) && !usedGlyphIds.has(glyphId)) {
      toUnicodeExtraMap.set(unicode, glyphId);
      usedGlyphIds.add(glyphId);
    }
 
    newMap[fontCharCode] = glyphId;
    toFontChar[originalCharCode] = fontCharCode;
  }

return {
  toFontChar,
  charCodeToGlyphId: newMap,
  toUnicodeExtraMap,
  nextAvailableFontCharCode,
};

    // Try to infer if the fallback encoding should really be `WinAnsiEncoding`.
    if (properties.defaultEncoding === WinAnsiEncoding) {
      return;
    }
    for (const r of nameRecords) {
      if (!isWinNameRecord(r)) {
        return; // Not Windows, hence `WinAnsiEncoding` wouldn't make sense.
      }
    }
    const encoding = WinAnsiEncoding;
 
    const toUnicode = [],
      glyphsUnicodeMap = getGlyphsUnicode();
    for (const charCode in encoding) {
      const glyphName = encoding[charCode];
      if (glyphName === "") {
        continue;
      }
      const unicode = glyphsUnicodeMap[glyphName];
      if (unicode === undefined) {
        continue;
      }
      toUnicode[charCode] = String.fromCharCode(unicode);
    }
    if (toUnicode.length > 0) {
      properties.toUnicode.amend(toUnicode);
    }
  }

function adjustType1ToUnicode(properties, builtInEncoding) {
  if (properties.isInternalFont) {
    return;
  }
  if (properties.hasIncludedToUnicodeMap) {
    return; // The font dictionary has a `ToUnicode` entry.
  }
  if (builtInEncoding === properties.defaultEncoding) {
    return; // No point in trying to adjust `toUnicode` if the encodings match.
  }
  if (properties.toUnicode instanceof IdentityToUnicodeMap) {
    return;
  }
  const toUnicode = [],
    glyphsUnicodeMap = getGlyphsUnicode();
  for (const charCode in builtInEncoding) {
    if (properties.hasEncoding) {
      if (
        properties.baseEncodingName ||
        properties.differences[charCode] !== undefined
      ) {
        continue; // The font dictionary has an `Encoding`/`Differences` entry.
      }
    }

// The following steps modify the original font data, making copy
font = new Stream(new Uint8Array(font.getBytes()));

    function readTableEntry(file) {
      const tag = file.getString(4);
 
      const checksum = file.getInt32() >>> 0;
      const offset = file.getInt32() >>> 0;
      const length = file.getInt32() >>> 0;
 
      // Read the table associated data
      const previousPosition = file.pos;
      file.pos = file.start || 0;
      file.skip(offset);
      const data = file.getBytes(length);
      file.pos = previousPosition;
 
      if (tag === "head") {
        // clearing checksum adjustment
        data[8] = data[9] = data[10] = data[11] = 0;
        data[17] |= 0x20; // Set font optimized for cleartype flag.
      }
      // The "CFF " table may be replaced completely, hence its data shouldn't
      // need to be read and/or modified piecewise through a `DataView`.
      const view =
        tag === "CFF "
          ? null
          : new DataView(data.buffer, data.byteOffset, data.byteLength);

function readTables(file, numTables) {
  const tables = Object.create(null);
  tables['OS/2'] = null;
  tables.cmap = null;
  tables.head = null;
  tables.hhea = null;
  tables.hmtx = null;
  tables.maxp = null;
  tables.name = null;
  tables.post = null;
 
  for (let i = 0; i < numTables; i++) {
    const table = readTableEntry(file);
    if (!VALID_TABLES.includes(table.tag)) {
      continue; // skipping table if it's not a required or optional table
    }
    if (table.length === 0) {
      continue; // skipping empty tables
    }
    tables[table.tag] = table;
  }
  return tables;
}

let header, tables;
if (isTrueTypeCollectionFile(font)) {
  const ttcData = readTrueTypeCollectionData(font, this.name);
  header = ttcData.header;
  tables = ttcData.tables;
} else {
  header = readOpenTypeHeader(font);
  tables = readTables(font, header.numTables);
}
 
const isTrueType = !tables['CFF '];

// OpenType font (skip composite fonts with non-default glyph mapping).
if (
  (header.version === 'OTTO' &&
    (!properties.composite || (properties.fontFileN === 'FontFile3' && parsedCff?.isCIDFont))) ||
  !tables.head ||
  !tables.hhea ||
  !tables.maxp ||
  !tables.post
) {
  // No major tables: throwing everything at `CFFFont`.
  return this.convert(name, new CFFFont(new Stream(tables['CFF '].data), properties), properties);
}

if (!tables.loca) {
  throw new FormatError('Required "loca" table is not found');
}
if (!tables.glyf) {
  warn('Required "glyf" table is not found -- trying to recover.');
  // Note: We use `sanitizeGlyphLocations` to add dummy glyf data below.
  tables.glyf = {
    tag: 'glyf',
    data: new Uint8Array(0),
  };
}

font.pos = (font.start || 0) + tables.maxp.offset;
let version = font.getInt32();
const numGlyphs = numGlyphsFromCFF ?? font.getUint16();
if (version === 0x00005000 && tables.maxp.length !== 6) {
  tables.maxp.data = tables.maxp.data.subarray(0, 6);
  tables.maxp.length = 6;
}
 
if (version !== 0x00010000 && version !== 0x00005000) {
  if (tables.maxp.length === 6) {
    version = 0x0005000;
  } else if (tables.maxp.length >= 32) {
    version = 0x00010000;
  } else {
    throw new FormatError(`"maxp" table has a wrong version number`);
  }
  writeUint32(tables.maxp.data, 0, version);
}

if (tables.loca) {
  const locaLength = isGlyphLocationsLong ? (numGlyphs + 1) * 4 : (numGlyphs + 1) * 2;
  if (tables.loca.length !== locaLength) {
    warn("Incorrect 'loca' table length -- attempting to fix it.");
    // The length of the loca table is wrong (see #13425), so we check if we
    // have enough space to fix it.
    const sortedTables = Object.values(tables)
      .filter(Boolean)
      .sort((a, b) => a.offset - b.offset);
    const locaIndex = sortedTables.indexOf(tables.loca);
    const nextTable = sortedTables[locaIndex + 1] || null;
    if (nextTable && tables.loca.offset + locaLength < nextTable.offset) {
      const previousPos = font.pos;
      font.pos = font.start || 0;
      font.skip(tables.loca.offset);
      tables.loca.data = font.getBytes(locaLength);
      tables.loca.length = locaLength;
      font.pos = previousPos;
    }
  }
}

const numGlyphsPlusOne = numGlyphs + 1;
if (locaLength === numGlyphsPlusOne << 1) {
  // 0x0000 indicates the loca table consists of short offsets
  data[50] = 0;
  data[51] = 0;
} else if (locaLength === numGlyphsPlusOne << 2) {
  // 0x0001 indicates the loca table consists of long offsets
  data[50] = 0;
  data[51] = 1;
} else {
  throw new FormatError('Could not fix indexToLocFormat: ' + indexToLocFormat);
}

const glyf = source.subarray(sourceStart, sourceEnd);
 
// Sanitize the glyph bounding box.
const xMin = signedInt16(glyf[2], glyf[3]);
const yMin = signedInt16(glyf[4], glyf[5]);
const xMax = signedInt16(glyf[6], glyf[7]);
const yMax = signedInt16(glyf[8], glyf[9]);
 
if (xMin > xMax) {
  writeSignedInt16(glyf, 2, xMax);
  writeSignedInt16(glyf, 6, xMin);
}
if (yMin > yMax) {
  writeSignedInt16(glyf, 4, yMax);
  writeSignedInt16(glyf, 8, yMin);
}
 
const contoursCount = signedInt16(glyf[0], glyf[1]);
if (contoursCount < 0) {
  if (contoursCount < -1) {
    // OTS doesn't like contour count to be less than -1.
    // The glyph data offsets are very likely wrong and
    // having something lower than -1, very likely, implies
    // to have some garbage data.
    return glyphProfile;
  }
  // complex glyph, writing as is
  dest.set(glyf, destStart);
  glyphProfile.length = glyf.length;
  return glyphProfile;
}

// validating flags
let coordinatesLength = 0;
for (i = 0; i < flagsCount; i++) {
  const flag = glyf[j++];
  if (flag & 0xc0) {
    // reserved flags must be zero, cleaning up
    glyf[j - 1] = flag & 0x3f;
  }
  let xLength = 2;
  if (flag & 2) {
    xLength = 1;
  } else if (flag & 16) {
    xLength = 0;
  }
  let yLength = 2;
  if (flag & 4) {
    yLength = 1;
  } else if (flag & 32) {
    yLength = 0;
  }
  const xyLength = xLength + yLength;
  coordinatesLength += xyLength;
  if (flag & 8) {
    const repeat = glyf[j++];
    if (repeat === 0) {
      // The repeat count should be non-zero when the repeat flag is set.
      glyf[j - 1] ^= 8;
    }
    i += repeat;
    coordinatesLength += repeat * xyLength;
  }
}
// glyph without coordinates will be rejected
if (coordinatesLength === 0) {
  return glyphProfile;
}

if (!hintsValid && instructionsLength > 0) {
  dest.set(glyf.subarray(0, instructionsStart), destStart);
  dest.set([0, 0], destStart + instructionsStart);
  dest.set(glyf.subarray(instructionsEnd, glyphDataLength), destStart + instructionsStart + 2);
  glyphDataLength -= instructionsLength;
  if (glyf.length - glyphDataLength > 3) {
    glyphDataLength = (glyphDataLength + 3) & ~3;
  }
  glyphProfile.length = glyphDataLength;
  return glyphProfile;
}

const locaEntries = [];
// There are numGlyphs + 1 loca table entries.
for (i = 0, j = 0; i < numGlyphs + 1; i++, j += itemSize) {
  let offset = itemDecode(locaData, j);
  if (offset > oldGlyfDataLength) {
    offset = oldGlyfDataLength;
  }
  locaEntries.push({
    index: i,
    offset,
    endOffset: 0,
  });
}
locaEntries.sort((a, b) => a.offset - b.offset);
// Now the offsets are sorted, calculate the end offset of each glyph.
// The last loca entry's endOffset is not calculated since it's the end
// of the data and will be stored on the previous entry's endOffset.
for (i = 0; i < numGlyphs; i++) {
  locaEntries[i].endOffset = locaEntries[i + 1].offset;
}
// Re-sort so glyphs aren't out of order.
locaEntries.sort((a, b) => a.index - b.index);

// Calculate the endOffset of the "first" glyph correctly when there are
// *multiple* empty ones at the start of the data (fixes issue14618.pdf).
for (i = 0; i < numGlyphs; i++) {
  const { offset, endOffset } = locaEntries[i];
  if (offset !== 0 || endOffset !== 0) {
    break;
  }
  const nextOffset = locaEntries[i + 1].offset;
  if (nextOffset === 0) {
    continue;
  }
  locaEntries[i].endOffset = nextOffset;
  break;
}

const droppedGlyphs = pruneCompositeGlyphCycles(oldGlyfData, locaEntries, numGlyphs);

const missingGlyphs = Object.create(null);
let writeOffset = 0;
itemEncode(locaData, 0, writeOffset);
for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {
  const glyphProfile = droppedGlyphs.has(i)
    ? { length: 0, sizeOfInstructions: 0 }
    : sanitizeGlyph(
        oldGlyfData,
        locaEntries[i].offset,
        locaEntries[i].endOffset,
        newGlyfData,
        writeOffset,
        hintsValid,
      );
  const newLength = glyphProfile.length;
  if (newLength === 0) {
    missingGlyphs[i] = true;
  }
  if (glyphProfile.sizeOfInstructions > maxSizeOfInstructions) {
    maxSizeOfInstructions = glyphProfile.sizeOfInstructions;
  }
  writeOffset += newLength;
  itemEncode(locaData, j, writeOffset);
}

if (writeOffset === 0) {
  // glyf table cannot be empty -- redoing the glyf and loca tables
  // to have single glyph with one point
  const simpleGlyph = new Uint8Array([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0]);
  for (i = 0, j = itemSize; i < numGlyphsOut; i++, j += itemSize) {
    itemEncode(locaData, j, simpleGlyph.length);
  }
  glyf.data = simpleGlyph;
}

      } else if (dupFirstEntry) {
        // Browsers will not display a glyph at position 0. Typically glyph 0
        // is notdef, but a number of fonts put a valid glyph there so it must
        // be duplicated and appended.
        const firstEntryLength = itemDecode(locaData, itemSize);
        if (newGlyfData.length > firstEntryLength + writeOffset) {
          glyf.data = newGlyfData.subarray(0, firstEntryLength + writeOffset);
        } else {
          glyf.data = new Uint8Array(firstEntryLength + writeOffset);
          glyf.data.set(newGlyfData.subarray(0, writeOffset));
        }
        glyf.data.set(newGlyfData.subarray(0, firstEntryLength), writeOffset);
        itemEncode(
          loca.data,
          locaData.length - itemSize,
          writeOffset + firstEntryLength
        );
      }

const numOfSidebearings = numGlyphs - numOfMetrics;
const numMissing = numOfSidebearings - ((metrics.length - numOfMetrics * 4) >> 1);
 
if (numMissing > 0) {
  // For each missing glyph, we set both the width and lsb to 0 (zero).
  // Since we need to add two properties for each glyph, this explains
  // the use of |numMissing * 2| when initializing the typed array.
  const entries = new Uint8Array(metrics.length + numMissing * 2);
  entries.set(metrics.data);
  if (dupFirstEntry) {
    // Set the sidebearing value of the duplicated glyph.
    entries[metrics.length] = metrics.data[2];
    entries[metrics.length + 1] = metrics.data[3];
  }
  metrics.data = entries;
}

if (numOfMetrics > numGlyphs) {
  info(
    `The numOfMetrics (${numOfMetrics}) should not be ` +
      `greater than the numGlyphs (${numGlyphs}).`,
  );
  // Reduce numOfMetrics if it is greater than numGlyphs
  numOfMetrics = numGlyphs;
  header.data[34] = (numOfMetrics & 0xff00) >> 8;
  header.data[35] = numOfMetrics & 0x00ff;
}

function sanitizeTTPrograms(fpgm, prep, cvt, maxFunctionDefs) {
  const ttContext = {
    functionsDefined: [],
    functionsUsed: [],
    functionsStackDeltas: [],
    tooComplexToFollowFunctions: false,
    hintsValid: true,
  };
  if (fpgm) {
    sanitizeTTProgram(fpgm, ttContext);
  }
  if (prep) {
    sanitizeTTProgram(prep, ttContext);
  }
  if (fpgm) {
    checkInvalidFunctions(ttContext, maxFunctionDefs);
  }
  if (cvt && cvt.length & 1) {
    const cvtData = new Uint8Array(cvt.length + 1);
    cvtData.set(cvt.data);
    cvt.data = cvtData;
  }
  return ttContext.hintsValid;
}

// Adjusting stack not exactly, but just enough to get function id
if (!inFDEF && !inELSE) {
  let stackDelta = 0;
  if (op <= 0x8e) {
    stackDelta = TTOpsStackDeltas[op];
  } else if (op >= 0xc0 && op <= 0xdf) {
    stackDelta = -1;
  } else if (op >= 0xe0) {
    stackDelta = -2;
  }
  if (op >= 0x71 && op <= 0x75) {
    n = stack.pop();
    if (!isNaN(n)) {
      stackDelta = -n * 2;
    }
  }
  while (stackDelta < 0 && stack.length > 0) {
    stack.pop();
    stackDelta++;
  }
  while (stackDelta > 0) {
    stack.push(NaN); // pushing any number into stack
    stackDelta--;
  }
}

// Extract some more font properties from the OpenType head and
// hhea tables; yMin and descent value are always negative.
const metricsOverride = {
  unitsPerEm: int16(tables.head.data[18], tables.head.data[19]),
  yMax: signedInt16(tables.head.data[42], tables.head.data[43]),
  yMin: signedInt16(tables.head.data[38], tables.head.data[39]),
  ascent: signedInt16(tables.hhea.data[4], tables.hhea.data[5]),
  descent: signedInt16(tables.hhea.data[6], tables.hhea.data[7]),
  lineGap: signedInt16(tables.hhea.data[8], tables.hhea.data[9]),
};
 
// PDF FontDescriptor metrics lie -- using data from actual font.
this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm;
this.descent = metricsOverride.descent / metricsOverride.unitsPerEm;
this.lineGap = metricsOverride.lineGap / metricsOverride.unitsPerEm;

if (this.cssFontInfo?.lineHeight) {
  this.lineHeight = this.cssFontInfo.metrics.lineHeight;
  this.lineGap = this.cssFontInfo.metrics.lineGap;
} else {
  this.lineHeight = this.ascent - this.descent + this.lineGap;
}

if (properties.composite) {
  const cidToGidMap = properties.cidToGidMap || [];
  const isCidToGidMapEmpty = cidToGidMap.length === 0;
 
  properties.cMap.forEach(function (charCode, cid) {
    if (typeof cid === 'string') {
      cid = convertCidString(charCode, cid /* shouldThrow = true */);
    }
    if (cid > 0xffff) {
      throw new FormatError('Max size of CID is 65,535');
    }
    let glyphId = -1;
    if (isCidToGidMapEmpty) {
      glyphId = cid;
    } else if (cidToGidMap[cid] !== undefined) {
      glyphId = cidToGidMap[cid];
    }
 
    if (glyphId >= 0 && glyphId < numGlyphs && hasGlyph(glyphId)) {
      charCodeToGlyphId[charCode] = glyphId;
    }
  });
}

        if (
          platformId === 0 &&
          (encodingId === /* Unicode Default */ 0 ||
            encodingId === /* Unicode 1.1 */ 1 ||
            encodingId === /* Unicode BMP */ 3)
        ) {
          useTable = true;
          // Continue the loop since there still may be a higher priority
          // table.
        } else if (platformId === 1 && encodingId === 0) {
          useTable = true;
          // Continue the loop since there still may be a higher priority
          // table.
        } else if (
          platformId === 3 &&
          encodingId === 1 &&
          (hasEncoding || !potentialTable)
        ) {
          useTable = true;
          if (!isSymbolicFont) {
            canBreak = true;
          }
        } else if (isSymbolicFont && platformId === 3 && encodingId === 0) {
          useTable = true;

for (const mapping of cmapMappings) {
  if (mapping.charCode !== unicodeOrCharCode) {
    continue;
  }
  charCodeToGlyphId[charCode] = mapping.glyphId;
  break;
}

      } else if (cmapPlatformId === 0) {
        // Default Unicode semantics, use the charcodes as is.
        for (const mapping of cmapMappings) {
          charCodeToGlyphId[mapping.charCode] = mapping.glyphId;
        }
        // Always prefer the BaseEncoding/Differences arrays, when they exist
        // (fixes issue13433.pdf).
        forcePostTable = true;
      } else if (cmapPlatformId === 3 && cmapEncodingId === 0) {
        // When a (3, 0) cmap table is present, it is used instead but the
        // spec has special rules for char codes in the range of 0xF000 to
        // 0xF0FF and it says the (3, 0) table should map the values from
        // the (1, 0) table by prepending 0xF0 to the char codes. To reverse
        // this, the upper bits of the char code are cleared, but only for the
        // special range since some PDFs have char codes outside of this range
        // (e.g. 0x2013) which when masked would overwrite other values in the
        // cmap.
        for (const mapping of cmapMappings) {
          let charCode = mapping.charCode;
          if (charCode >= 0xf000 && charCode <= 0xf0ff) {
            charCode &= 0xff;
          }
          charCodeToGlyphId[charCode] = mapping.glyphId;
        }
      } else {

// Last, try to map any missing charcodes using the post table.
if (properties.glyphNames && (baseEncoding.length || this.differences.length)) {
  for (let i = 0; i < 256; ++i) {
    if (!forcePostTable && charCodeToGlyphId[i] !== undefined) {
      continue;
    }
    const glyphName = this.differences[i] || baseEncoding[i];
    if (!glyphName) {
      continue;
    }
    const glyphId = properties.glyphNames.indexOf(glyphName);
    if (glyphId > 0 && hasGlyph(glyphId)) {
      charCodeToGlyphId[i] = glyphId;
    }
  }
}

// When `cssFontInfo` is set, the font is used to render text in the HTML
// view (e.g. with Xfa) so nothing must be moved in the private use area.
if (!properties.cssFontInfo) {
  // Converting glyphs and ids into font's cmap table
  const newMapping = adjustMapping(charCodeToGlyphId, hasGlyph, glyphZeroId, this.toUnicode);
  this.toFontChar = newMapping.toFontChar;
  tables.cmap = {
    tag: 'cmap',
    data: createCmapTable(newMapping.charCodeToGlyphId, newMapping.toUnicodeExtraMap, numGlyphsOut),
  };
 
  if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'], font)) {
    tables['OS/2'] = {
      tag: 'OS/2',
      data: createOS2Table(properties, newMapping.charCodeToGlyphId, metricsOverride),
    };
  }
}

function validateOS2Table(os2, file) {
  file.pos = (file.start || 0) + os2.offset;
  const version = file.getUint16();
  const minLength = [78, 86, 96, 96, 96, 100][version];
  if (minLength === undefined || os2.length < minLength) {
    return false;
  }
  // TODO verify all OS/2 tables fields, but currently we validate only those
  // that give us issues
  file.skip(60); // skipping type, misc sizes, panose, unicode ranges
  const selection = file.getUint16();
  if (version < 4 && selection & 0x0300) {
    return false;
  }
  const firstChar = file.getUint16();
  const lastChar = file.getUint16();
  if (firstChar > lastChar) {
    return false;
  }
  file.skip(6); // skipping sTypoAscender/Descender/LineGap
  const usWinAscent = file.getUint16();
  if (usWinAscent === 0) {
    // makes font unreadable by windows
    return false;
  }
 
  // OS/2 appears to be valid, resetting some fields
  os2.data[8] = os2.data[9] = 0; // IE rejects fonts if fsType != 0
  return true;
}

// Re-creating 'name' table
if (!tables.name) {
  tables.name = {
    tag: 'name',
    data: createNameTable(this.name),
  };
} else {
  // ... using existing 'name' table as prototype
  const [namePrototype, nameRecords] = readNameTable(tables.name);
 
  tables.name.data = createNameTable(name, namePrototype);
  this.psName = namePrototype[0][6] || null;
 
  if (!properties.composite) {
    // For TrueType fonts that do not include `ToUnicode` or `Encoding`
    // data, attempt to use the name-table to improve text selection.
    adjustTrueTypeToUnicode(properties, this.isSymbolicFont, nameRecords);
  }
}

const builder = new OpenTypeFileBuilder(header.version);
for (const tableTag in tables) {
  builder.addTable(tableTag, tables[tableTag].data);
}
return builder.toArray();

// Type 1 fonts have a notdef inserted at the beginning, so glyph 0
// becomes glyph 1. In a CFF font glyph 0 is appended to the end of the
// char strings.
const glyphZeroId = font instanceof CFFFont ? font.numGlyphs - 1 : 1;
const mapping = font.getGlyphMapping(properties);
let newMapping = null;
let newCharCodeToGlyphId = mapping;
let toUnicodeExtraMap = null;

if (!properties.cssFontInfo) {
  newMapping = adjustMapping(mapping, font.hasGlyphId.bind(font), glyphZeroId, this.toUnicode);
  this.toFontChar = newMapping.toFontChar;
  newCharCodeToGlyphId = newMapping.charCodeToGlyphId;
  toUnicodeExtraMap = newMapping.toUnicodeExtraMap;
}
const numGlyphs = font.numGlyphs;

  hasGlyphId(id) {
    if (id < 0 || id >= this.numGlyphs) {
      return false;
    }
    if (id === 0) {
      // notdef is always defined.
      return true;
    }
    const glyph = this.charstrings[id - 1];
    return glyph.charstring.length > 0;
  }

    const seacs = font.seacs;
    if (newMapping && SEAC_ANALYSIS_ENABLED && seacs?.length) {
      const matrix = properties.fontMatrix || FONT_IDENTITY_MATRIX;
      const charset = font.getCharset();
      const seacMap = Object.create(null);
      for (let glyphId in seacs) {
        glyphId |= 0;
        const seac = seacs[glyphId];
        const baseGlyphName = StandardEncoding[seac[2]];
        const accentGlyphName = StandardEncoding[seac[3]];
        const baseGlyphId = charset.indexOf(baseGlyphName);
        const accentGlyphId = charset.indexOf(accentGlyphName);
        if (baseGlyphId < 0 || accentGlyphId < 0) {
          continue;
        }
        const accentOffset = {
          x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4],
          y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5],
        };

        const charCodes = getCharCodes(mapping, glyphId);
        if (!charCodes) {
          // There's no point in mapping it if the char code was never mapped
          // to begin with.
          continue;
        }

(function fontTableHmtx() {
  const charstrings = font.charstrings;
  const cffWidths = font.cff?.widths ?? null;
 
  const hmtx = new DataBuilder({ exactLength: numGlyphs * 4 });
  // Fake .notdef (width=0 and lsb=0) first, skip redundant assignment.
  hmtx.skip(4);
 
  for (let i = 1, ii = numGlyphs; i < ii; i++) {
    let width = 0;
    if (charstrings) {
      width = charstrings[i - 1].width || 0;
    } else if (cffWidths) {
      width = Math.ceil(cffWidths[i] || 0);
    }
    hmtx.setInt16(width);
    hmtx.skip(2); // Use lsb=0, skip redundant assignment.
  }
  return hmtx.data;
})();

const builder = new OpenTypeFileBuilder('\x4F\x54\x54\x4F');
// PostScript Font Program
builder.addTable('CFF ', font.data);
// OS/2 and Windows Specific metrics
builder.addTable('OS/2', createOS2Table(properties, newCharCodeToGlyphId));
// Character to glyphs mapping
builder.addTable('cmap', createCmapTable(newCharCodeToGlyphId, toUnicodeExtraMap, numGlyphs));

hhea.setSafeInt16(properties.capHeight); // caretSlopeRise
hhea.setSafeInt16(Math.tan(properties.italicAngle) * properties.xHeight); // caretSlopeRun

hhea.setInt16(numGlyphs); // Number of HMetrics

if (properties.builtInEncoding) {
  // For Type1 fonts that do not include either `ToUnicode` or `Encoding`
  // data, attempt to use the `builtInEncoding` to improve text selection.
  adjustType1ToUnicode(properties, properties.builtInEncoding);
}

// TODO: Check the charstring widths to determine this.
properties.fixedPitch = false;

const cff =
  subtype === 'Type1C' || subtype === 'CIDFontType0C'
    ? new CFFFont(file, properties)
    : new Type1Font(name, file, properties);

if (parsedCff) {
  try {
    parsedCff.duplicateFirstGlyph();
    tables['CFF '].data = new CFFCompiler(parsedCff).compile();
    numGlyphsFromCFF = parsedCff.charStringCount;
  } catch {
    warn('Failed to compile font ' + properties.loadedName);
  }
}

if (properties.type === 'Type3') {
  for (let charCode = 0; charCode < 256; charCode++) {
    this.toFontChar[charCode] = this.differences[charCode] || properties.defaultEncoding[charCode];
  }
  return;
}

if (this.isType3Font) {
  // Font char code in this case is actually a glyph name.
  operatorListId = fontCharCode;
}

    const charProcs = dict.get("CharProcs");
    const fontResources = dict.get("Resources") || resources;
    const charProcOperatorList = new Map();
 
    const [x0, y0, x1, y1] = font.bbox;
    const fontBBoxSize = Math.hypot(x1 - x0, y1 - y0);
 
    for (const key of charProcs.getKeys()) {

switch (operatorList.fnArray[0]) {
  case OPS.setCharWidthAndBounds:
    this.#removeType3ColorOperators(operatorList, fontBBoxSize);
    break;
  case OPS.setCharWidth:
    if (!fontBBoxSize) {
      this.#guessType3FontBBox(operatorList);
    }
    break;
}

      } catch {
        warn(`Type3 font resource "${key}" is not available.`);
        charProcOperatorList.set(key, new OperatorList().getIR());
      }