@file-viewer/capability-pdf-identity-repair 3.0.2 → 3.1.0

package/dist/index.js

@@ -1,7 +1,481 @@
-import { registerFileViewerPdfIdentityFontRepair } from '@file-viewer/renderer-pdf';
-import { repairMalformedIdentityCjkFonts } from '@file-viewer/renderer-pdf/identity-font-repair';
-export const enableFileViewerPdfIdentityFontRepair = () => {
-    registerFileViewerPdfIdentityFontRepair(repairMalformedIdentityCjkFonts);
+// src/index.ts
+import { registerFileViewerPdfIdentityFontRepair } from "@file-viewer/renderer-pdf";
+
+// ../../renderers/pdf/dist/pdfIdentityFontRepair.js
+import { decodePDFRawStream, PDFArray, PDFDict, PDFDocument, PDFHexString, PDFName, PDFNumber, PDFRawStream, PDFString } from "pdf-lib";
+
+// ../../renderers/pdf/dist/pdfIdentityFontName.js
+var MAX_PDF_IDENTITY_FONT_NAME_CHARACTERS = 1024;
+var PDF_FONT_STYLE_NAMES = /* @__PURE__ */ new Set([
+  "bold",
+  "regular",
+  "italic",
+  "oblique",
+  "medium",
+  "semibold",
+  "demibold",
+  "light",
+  "black",
+  "thin"
+]);
+var isFontNameSeparator = (character) => character === "," || character === "_" || character === "-" || character.trim() === "";
+var hasSubsetPrefix = (value) => {
+  if (value.length < 7 || value[6] !== "+")
+    return false;
+  for (let index = 0; index < 6; index += 1) {
+    const codePoint = value.charCodeAt(index) | 32;
+    if (codePoint < 97 || codePoint > 122)
+      return false;
+  }
+  return true;
+};
+var stripFontStyleSuffix = (value) => {
+  let cursor = 0;
+  while (cursor < value.length) {
+    if (!isFontNameSeparator(value[cursor])) {
+      cursor += 1;
+      continue;
+    }
+    const separatorStart = cursor;
+    while (cursor < value.length && isFontNameSeparator(value[cursor]))
+      cursor += 1;
+    const tokenStart = cursor;
+    while (cursor < value.length && !isFontNameSeparator(value[cursor]))
+      cursor += 1;
+    const token = value.slice(tokenStart, cursor).toLowerCase();
+    const style = token.endsWith("mt") ? token.slice(0, -2) : token;
+    if (PDF_FONT_STYLE_NAMES.has(style))
+      return value.slice(0, separatorStart);
+  }
+  return value;
+};
+var normalizePdfIdentityFontFamily = (value) => {
+  if (!value || value.length > MAX_PDF_IDENTITY_FONT_NAME_CHARACTERS)
+    return "";
+  const withoutSubset = hasSubsetPrefix(value) ? value.slice(7) : value;
+  const withoutStyle = stripFontStyleSuffix(withoutSubset);
+  const normalizedCharacters = [];
+  for (const character of withoutStyle.normalize("NFKC").toLowerCase()) {
+    if (!isFontNameSeparator(character))
+      normalizedCharacters.push(character);
+  }
+  return normalizedCharacters.join("");
+};
+
+// ../../renderers/pdf/dist/pdfIdentityFontRepair.js
+var MAX_REPAIR_SOURCE_BYTES = 64 * 1024 * 1024;
+var MAX_TTF_TABLES = 256;
+var MAX_CMAP_GLYPHS = 65535;
+var MAX_CMAP_CODEPOINT_VISITS = 65536;
+var MAX_DECODED_FONT_BYTES = 64 * 1024 * 1024;
+var CMAP_BFCHAR_CHUNK_SIZE = 100;
+var BASE_FONT = PDFName.of("BaseFont");
+var CID_TO_GID_MAP = PDFName.of("CIDToGIDMap");
+var DESCENDANT_FONTS = PDFName.of("DescendantFonts");
+var ENCODING = PDFName.of("Encoding");
+var FONT = PDFName.of("Font");
+var FONT_DESCRIPTOR = PDFName.of("FontDescriptor");
+var FONT_FAMILY = PDFName.of("FontFamily");
+var FONT_FILE_2 = PDFName.of("FontFile2");
+var LENGTH_1 = PDFName.of("Length1");
+var RESOURCES = PDFName.of("Resources");
+var SUBTYPE = PDFName.of("Subtype");
+var TO_UNICODE = PDFName.of("ToUnicode");
+var X_OBJECT = PDFName.of("XObject");
+var CJK_FONT_FAMILY_ALIASES = {
+  "\u5FAE\u8F6F\u96C5\u9ED1": "microsoftyahei",
+  "\u5B8B\u4F53": "simsun",
+  "\u9ED1\u4F53": "simhei",
+  "\u6977\u4F53": "kaiti",
+  "\u4EFF\u5B8B": "fangsong"
+};
+var CJK_FONT_FAMILY_MARKERS = [
+  "microsoftyahei",
+  "simsun",
+  "nsimsun",
+  "simhei",
+  "kaiti",
+  "fangsong",
+  "pingfang",
+  "songti",
+  "heiti",
+  "hiragino",
+  "notosanscjk",
+  "sourcehansans",
+  "sourcehanserif"
+];
+var readUint16 = (bytes, offset) => {
+  if (offset < 0 || offset + 2 > bytes.length) {
+    throw new Error("Unexpected end of TrueType font data.");
+  }
+  return bytes[offset] << 8 | bytes[offset + 1];
+};
+var readUint32 = (bytes, offset) => {
+  if (offset < 0 || offset + 4 > bytes.length) {
+    throw new Error("Unexpected end of TrueType font data.");
+  }
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+};
+var readTag = (bytes, offset) => {
+  if (offset < 0 || offset + 4 > bytes.length) {
+    return "";
+  }
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+};
+var normalizeFontFamily = (value) => {
+  const normalized = normalizePdfIdentityFontFamily(value);
+  return CJK_FONT_FAMILY_ALIASES[normalized] || normalized;
+};
+var isCjkFontFamily = (family) => {
+  const key = normalizeFontFamily(family);
+  return CJK_FONT_FAMILY_MARKERS.some((marker) => key.includes(marker)) || /[\u3400-\u9fff]/.test(family);
+};
+var readFontName = (font) => {
+  var _a;
+  return ((_a = font.lookupMaybe(BASE_FONT, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText()) || "";
+};
+var readFontFamily = (descriptor) => {
+  var _a;
+  if (!descriptor) {
+    return "";
+  }
+  return ((_a = descriptor.lookupMaybe(FONT_FAMILY, PDFString, PDFHexString)) === null || _a === void 0 ? void 0 : _a.decodeText()) || "";
+};
+var getDescendantFont = (font) => {
+  var _a;
+  return (_a = font.lookupMaybe(DESCENDANT_FONTS, PDFArray)) === null || _a === void 0 ? void 0 : _a.lookupMaybe(0, PDFDict);
+};
+var getEmbeddedTrueTypeFont = (descriptor) => {
+  var _a;
+  if (!descriptor) {
+    return void 0;
+  }
+  const fontFile = descriptor.get(FONT_FILE_2);
+  if (!fontFile) {
+    return void 0;
+  }
+  const resolved = descriptor.context.lookup(fontFile);
+  if (!(resolved instanceof PDFRawStream)) {
+    return void 0;
+  }
+  const declaredLength = (_a = resolved.dict.lookupMaybe(LENGTH_1, PDFNumber)) === null || _a === void 0 ? void 0 : _a.asNumber();
+  if (typeof declaredLength !== "number" || !Number.isSafeInteger(declaredLength) || declaredLength < 1 || declaredLength > MAX_DECODED_FONT_BYTES || resolved.contents.byteLength > MAX_DECODED_FONT_BYTES) {
+    return void 0;
+  }
+  return resolved;
+};
+var createFontRecord = (font) => {
+  var _a;
+  const descendant = getDescendantFont(font);
+  if (!descendant) {
+    return null;
+  }
+  const encoding = (_a = font.lookupMaybe(ENCODING, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText();
+  if (encoding !== "Identity-H" && encoding !== "Identity-V") {
+    return null;
+  }
+  const descriptor = descendant.lookupMaybe(FONT_DESCRIPTOR, PDFDict);
+  const baseFont = readFontName(font);
+  const descriptorFamily = readFontFamily(descriptor);
+  const cidToGidMapObject = descendant.get(CID_TO_GID_MAP);
+  const cidToGidMap = cidToGidMapObject ? descendant.context.lookup(cidToGidMapObject) : void 0;
+  const familyKeys = new Set([baseFont, descriptorFamily].filter(Boolean).map(normalizeFontFamily).filter(Boolean));
+  return {
+    font,
+    descendant,
+    familyKeys,
+    baseFont,
+    identityCidToGidMap: !cidToGidMap || cidToGidMap instanceof PDFName && cidToGidMap.decodeText() === "Identity",
+    embeddedFont: getEmbeddedTrueTypeFont(descriptor)
+  };
+};
+var collectFontRecords = (pdfDocument) => {
+  const records = /* @__PURE__ */ new Map();
+  const visitedResources = /* @__PURE__ */ new Set();
+  const visitedXObjects = /* @__PURE__ */ new Set();
+  const visitResources = (resources) => {
+    var _a;
+    if (!resources || visitedResources.has(resources)) {
+      return;
+    }
+    visitedResources.add(resources);
+    const fonts = resources.lookupMaybe(FONT, PDFDict);
+    for (const fontObject of (fonts === null || fonts === void 0 ? void 0 : fonts.values()) || []) {
+      const font = pdfDocument.context.lookup(fontObject);
+      if (!(font instanceof PDFDict) || records.has(font)) {
+        continue;
+      }
+      const record = createFontRecord(font);
+      if (record) {
+        records.set(font, record);
+      }
+    }
+    const xObjects = resources.lookupMaybe(X_OBJECT, PDFDict);
+    for (const xObjectRef of (xObjects === null || xObjects === void 0 ? void 0 : xObjects.values()) || []) {
+      const xObject = pdfDocument.context.lookup(xObjectRef);
+      if (!(xObject instanceof PDFRawStream) || visitedXObjects.has(xObject)) {
+        continue;
+      }
+      visitedXObjects.add(xObject);
+      if (((_a = xObject.dict.lookupMaybe(SUBTYPE, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText()) !== "Form") {
+        continue;
+      }
+      visitResources(xObject.dict.lookupMaybe(RESOURCES, PDFDict));
+    }
+  };
+  for (const page of pdfDocument.getPages()) {
+    visitResources(page.node.Resources());
+  }
+  return [...records.values()];
+};
+var findCmapTable = (fontBytes) => {
+  if (fontBytes.length < 12) {
+    throw new Error("Invalid TrueType font header.");
+  }
+  const tableCount = readUint16(fontBytes, 4);
+  if (tableCount < 1 || tableCount > MAX_TTF_TABLES) {
+    throw new Error(`Invalid TrueType table count: ${tableCount}.`);
+  }
+  let cmapOffset = -1;
+  for (let index = 0; index < tableCount; index += 1) {
+    const entryOffset = 12 + index * 16;
+    if (entryOffset + 16 > fontBytes.length) {
+      throw new Error("Invalid TrueType table directory.");
+    }
+    if (readTag(fontBytes, entryOffset) === "cmap") {
+      cmapOffset = readUint32(fontBytes, entryOffset + 8);
+      break;
+    }
+  }
+  if (cmapOffset < 0 || cmapOffset + 4 > fontBytes.length) {
+    throw new Error("TrueType font does not contain a readable cmap table.");
+  }
+  const cmapCount = readUint16(fontBytes, cmapOffset + 2);
+  const tables = [];
+  for (let index = 0; index < cmapCount; index += 1) {
+    const recordOffset = cmapOffset + 4 + index * 8;
+    if (recordOffset + 8 > fontBytes.length) {
+      break;
+    }
+    const offset = cmapOffset + readUint32(fontBytes, recordOffset + 4);
+    if (offset + 2 > fontBytes.length) {
+      continue;
+    }
+    const format = readUint16(fontBytes, offset);
+    if (format === 4 || format === 12) {
+      tables.push({
+        offset,
+        format,
+        platformId: readUint16(fontBytes, recordOffset),
+        encodingId: readUint16(fontBytes, recordOffset + 2)
+      });
+    }
+  }
+  const score = (table) => (table.format === 12 ? 100 : 0) + (table.platformId === 3 ? 20 : 0) + (table.platformId === 0 ? 10 : 0) + (table.encodingId === 10 ? 4 : 0) + (table.encodingId === 1 ? 2 : 0);
+  const selected = tables.sort((left, right) => score(right) - score(left))[0];
+  if (!selected) {
+    throw new Error("TrueType font does not contain a supported Unicode cmap.");
+  }
+  return selected;
+};
+var setGlyphMapping = (map, glyphId, codePoint) => {
+  if (glyphId > 0 && glyphId <= MAX_CMAP_GLYPHS && codePoint > 0 && codePoint <= 1114111 && !map.has(glyphId)) {
+    map.set(glyphId, codePoint);
+  }
+};
+var parseFormat12Cmap = (fontBytes, table, glyphToUnicode) => {
+  const tableLength = readUint32(fontBytes, table.offset + 4);
+  const tableEnd = table.offset + tableLength;
+  const groupCount = readUint32(fontBytes, table.offset + 12);
+  if (tableLength < 16 || tableEnd > fontBytes.length || table.offset + 16 + groupCount * 12 > tableEnd) {
+    throw new Error("Invalid TrueType cmap format 12 groups.");
+  }
+  let visitedCodePoints = 0;
+  for (let index = 0; index < groupCount; index += 1) {
+    const offset = table.offset + 16 + index * 12;
+    const startCodePoint = readUint32(fontBytes, offset);
+    const endCodePoint = readUint32(fontBytes, offset + 4);
+    const startGlyphId = readUint32(fontBytes, offset + 8);
+    const length = Math.min(endCodePoint - startCodePoint + 1, MAX_CMAP_GLYPHS - startGlyphId + 1);
+    if (!Number.isSafeInteger(length) || length < 1) {
+      continue;
+    }
+    for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
+      if (visitedCodePoints >= MAX_CMAP_CODEPOINT_VISITS) {
+        return;
+      }
+      visitedCodePoints += 1;
+      setGlyphMapping(glyphToUnicode, startGlyphId + innerIndex, startCodePoint + innerIndex);
+    }
+  }
+};
+var parseFormat4Cmap = (fontBytes, table, glyphToUnicode) => {
+  const tableLength = readUint16(fontBytes, table.offset + 2);
+  const tableEnd = table.offset + tableLength;
+  const segmentCount = readUint16(fontBytes, table.offset + 6) / 2;
+  const endCodesOffset = table.offset + 14;
+  const startCodesOffset = endCodesOffset + segmentCount * 2 + 2;
+  const deltasOffset = startCodesOffset + segmentCount * 2;
+  const rangeOffsetsOffset = deltasOffset + segmentCount * 2;
+  if (!Number.isInteger(segmentCount) || segmentCount < 1 || tableLength < 16 || tableEnd > fontBytes.length || rangeOffsetsOffset + segmentCount * 2 > tableEnd) {
+    throw new Error("Invalid TrueType cmap format 4 segments.");
+  }
+  let visitedCodePoints = 0;
+  for (let index = 0; index < segmentCount; index += 1) {
+    const endCodePoint = readUint16(fontBytes, endCodesOffset + index * 2);
+    const startCodePoint = readUint16(fontBytes, startCodesOffset + index * 2);
+    const delta = readUint16(fontBytes, deltasOffset + index * 2);
+    const rangeOffset = readUint16(fontBytes, rangeOffsetsOffset + index * 2);
+    if (endCodePoint < startCodePoint) {
+      continue;
+    }
+    for (let codePoint = startCodePoint; codePoint <= endCodePoint && codePoint !== 65535; codePoint += 1) {
+      if (visitedCodePoints >= MAX_CMAP_CODEPOINT_VISITS) {
+        return;
+      }
+      visitedCodePoints += 1;
+      let glyphId = 0;
+      if (rangeOffset === 0) {
+        glyphId = codePoint + delta & 65535;
+      } else {
+        const glyphOffset = rangeOffsetsOffset + index * 2 + rangeOffset + (codePoint - startCodePoint) * 2;
+        if (glyphOffset + 2 <= tableEnd) {
+          glyphId = readUint16(fontBytes, glyphOffset);
+          if (glyphId) {
+            glyphId = glyphId + delta & 65535;
+          }
+        }
+      }
+      setGlyphMapping(glyphToUnicode, glyphId, codePoint);
+    }
+  }
+};
+var parseTrueTypeGlyphToUnicode = (fontBytes) => {
+  const selected = findCmapTable(fontBytes);
+  const glyphToUnicode = /* @__PURE__ */ new Map();
+  if (selected.format === 12) {
+    parseFormat12Cmap(fontBytes, selected, glyphToUnicode);
+  } else {
+    parseFormat4Cmap(fontBytes, selected, glyphToUnicode);
+  }
+  return glyphToUnicode;
+};
+var toHex = (value, minLength = 4) => value.toString(16).toUpperCase().padStart(minLength, "0");
+var encodeUnicodeCodePoint = (codePoint) => {
+  if (codePoint <= 65535) {
+    return toHex(codePoint);
+  }
+  const offset = codePoint - 65536;
+  const highSurrogate = 55296 + (offset >> 10);
+  const lowSurrogate = 56320 + (offset & 1023);
+  return `${toHex(highSurrogate)}${toHex(lowSurrogate)}`;
+};
+var createToUnicodeCmap = (glyphToUnicode) => {
+  const entries = [...glyphToUnicode].filter(([glyphId, codePoint]) => glyphId > 0 && glyphId <= 65535 && codePoint > 0 && codePoint <= 1114111).sort(([left], [right]) => left - right);
+  const sections = [];
+  for (let index = 0; index < entries.length; index += CMAP_BFCHAR_CHUNK_SIZE) {
+    const chunk = entries.slice(index, index + CMAP_BFCHAR_CHUNK_SIZE);
+    sections.push([
+      `${chunk.length} beginbfchar`,
+      ...chunk.map(([glyphId, codePoint]) => `<${toHex(glyphId)}> <${encodeUnicodeCodePoint(codePoint)}>`),
+      "endbfchar"
+    ].join("\n"));
+  }
+  return [
+    "/CIDInit /ProcSet findresource begin",
+    "12 dict begin",
+    "begincmap",
+    "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+    "/CMapName /Adobe-Identity-UCS def",
+    "/CMapType 2 def",
+    "1 begincodespacerange",
+    "<0000> <FFFF>",
+    "endcodespacerange",
+    ...sections,
+    "endcmap",
+    "CMapName currentdict /CMap defineresource pop",
+    "end",
+    "end"
+  ].join("\n");
+};
+var familiesOverlap = (left, right) => {
+  for (const key of left) {
+    if (right.has(key)) {
+      return true;
+    }
+  }
+  return false;
+};
+var repairMalformedIdentityCjkFonts = async (sourceBytes, candidateFamilies = []) => {
+  if (!sourceBytes.byteLength || sourceBytes.byteLength > MAX_REPAIR_SOURCE_BYTES) {
+    return { bytes: sourceBytes, repairedFonts: 0, repairedFamilies: [] };
+  }
+  const candidateKeys = new Set(candidateFamilies.map(normalizeFontFamily).filter(Boolean));
+  const pdfDocument = await PDFDocument.load(sourceBytes, {
+    updateMetadata: false
+  });
+  const records = collectFontRecords(pdfDocument);
+  const sourceMaps = /* @__PURE__ */ new Map();
+  const getSourceMap = (record) => {
+    const cached = sourceMaps.get(record);
+    if (cached) {
+      return cached;
+    }
+    if (!record.embeddedFont) {
+      return void 0;
+    }
+    const decoded = decodePDFRawStream(record.embeddedFont).decode();
+    if (decoded.byteLength > MAX_DECODED_FONT_BYTES) {
+      throw new Error("Embedded TrueType font exceeds the Identity repair limit.");
+    }
+    const glyphMap = parseTrueTypeGlyphToUnicode(decoded);
+    sourceMaps.set(record, glyphMap);
+    return glyphMap;
+  };
+  let repairedFonts = 0;
+  const repairedFamilies = /* @__PURE__ */ new Set();
+  for (const target of records) {
+    if (target.font.has(TO_UNICODE) || target.embeddedFont || !target.identityCidToGidMap || ![...target.familyKeys].some((key) => isCjkFontFamily(key)) || candidateKeys.size > 0 && ![...target.familyKeys].some((key) => candidateKeys.has(key))) {
+      continue;
+    }
+    let bestMap;
+    for (const source of records) {
+      if (!source.embeddedFont || !familiesOverlap(target.familyKeys, source.familyKeys)) {
+        continue;
+      }
+      try {
+        const sourceMap = getSourceMap(source);
+        if (sourceMap && (!bestMap || sourceMap.size > bestMap.size)) {
+          bestMap = sourceMap;
+        }
+      } catch {
+      }
+    }
+    if (!bestMap || bestMap.size < 2) {
+      continue;
+    }
+    const cmap = createToUnicodeCmap(bestMap);
+    const cmapRef = pdfDocument.context.register(pdfDocument.context.flateStream(cmap));
+    target.font.set(TO_UNICODE, cmapRef);
+    repairedFonts += 1;
+    repairedFamilies.add(target.baseFont || [...target.familyKeys][0] || "CJK font");
+  }
+  if (!repairedFonts) {
+    return { bytes: sourceBytes, repairedFonts: 0, repairedFamilies: [] };
+  }
+  return {
+    bytes: await pdfDocument.save({ useObjectStreams: true }),
+    repairedFonts,
+    repairedFamilies: [...repairedFamilies]
+  };
+};
+
+// src/index.ts
+var enableFileViewerPdfIdentityFontRepair = () => {
+  registerFileViewerPdfIdentityFontRepair(repairMalformedIdentityCjkFonts);
 };
 enableFileViewerPdfIdentityFontRepair();
-export { repairMalformedIdentityCjkFonts };
+export {
+  enableFileViewerPdfIdentityFontRepair,
+  repairMalformedIdentityCjkFonts
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/capability-pdf-identity-repair",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "description": "Opt-in malformed Identity CJK font repair for the File Viewer PDF renderer.",
@@ -22,10 +22,11 @@
     "README.en.md"
   ],
   "dependencies": {
-    "@file-viewer/renderer-pdf": "3.0.2",
+    "@file-viewer/renderer-pdf": "3.1.0",
     "pdf-lib": "1.17.1"
   },
   "devDependencies": {
+    "esbuild": "^0.28.2",
     "typescript": "^6.0.3"
   },
   "fileViewer": {
@@ -42,7 +43,7 @@
   },
   "license": "Apache-2.0",
   "scripts": {
-    "build": "tsc -b tsconfig.json",
+    "build": "tsc -b tsconfig.json && node scripts/build.mjs && node --test test/*.test.mjs",
     "type-check": "tsc -b tsconfig.json"
   }
 }