aurochs 0.6.3 → 0.6.4

package/dist/_shared/{pdf-parser-Ciztl2kx.js → pdf-parser-NK9_pSDg.js}

@@ -456,7 +456,7 @@ function buildDiagnostics(args) {
     if (decoded.includes("�")) {
       replacementCharMapCount += 1;
     }
-    if (containsPrivateUseCharacter(decoded)) {
+    if (containsPrivateUseCharacter$1(decoded)) {
       privateUseCharMapCount += 1;
     }
   }
@@ -469,7 +469,7 @@ function buildDiagnostics(args) {
     sourceCodeLengthHistogram: histogram
   };
 }
-function containsPrivateUseCharacter(text) {
+function containsPrivateUseCharacter$1(text) {
   return Array.from(text).some((char) => {
     const codePoint = char.codePointAt(0);
     if (codePoint === void 0) {
@@ -1728,6 +1728,401 @@ function decodeCIDFallback(cid, ordering) {
   }
   return null;
 }
+const BYTE_TO_HEX = Array.from(
+  { length: 256 },
+  (_, value) => value.toString(16).padStart(2, "0").toUpperCase()
+);
+function bytesToString(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function rawTextToBytes$1(rawText) {
+  const bytes = new Uint8Array(rawText.length);
+  for (let i2 = 0; i2 < rawText.length; i2++) {
+    bytes[i2] = rawText.charCodeAt(i2) & 255;
+  }
+  return bytes;
+}
+function byteSliceToHex(bytes, start, length) {
+  const parts = new Array(length);
+  for (let i2 = 0; i2 < length; i2++) {
+    parts[i2] = BYTE_TO_HEX[bytes[start + i2] ?? 0];
+  }
+  return parts.join("");
+}
+function resolveSourceCodeByteLengths(byteMapping, preferred) {
+  if (preferred && preferred.length > 0) {
+    const normalized = [...new Set(preferred.filter((length) => Number.isInteger(length) && length > 0))].sort((a, b) => b - a);
+    if (normalized.length > 0) {
+      return normalized;
+    }
+  }
+  const inferred = /* @__PURE__ */ new Set();
+  for (const sourceHex of byteMapping.keys()) {
+    inferred.add(sourceHex.length / 2);
+  }
+  return [...inferred].filter((length) => Number.isInteger(length) && length > 0).sort((a, b) => b - a);
+}
+function containsPrivateUseCharacter(text) {
+  return Array.from(text).some((char) => {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) {
+      return false;
+    }
+    return codePoint >= 57344 && codePoint <= 63743 || codePoint >= 983040 && codePoint <= 1048573 || codePoint >= 1048576 && codePoint <= 1114109;
+  });
+}
+function decodeCidFallback(args) {
+  const { code, ordering, cidCodeToUnicodeFallbackMap } = args;
+  const glyphFallback = cidCodeToUnicodeFallbackMap?.get(code);
+  if (glyphFallback !== void 0) {
+    return glyphFallback;
+  }
+  return decodeCIDFallback(code, ordering ?? null);
+}
+function resolveCidFallbackOrdering(fontInfo) {
+  const ordering = fontInfo.ordering;
+  if (ordering && ordering !== "Identity") {
+    return ordering;
+  }
+  return void 0;
+}
+function isToUnicodeSeverelyCorrupted(fontInfo) {
+  const byteMapping = fontInfo.toUnicodeByteMapping;
+  const diagnostics = fontInfo.toUnicodeDiagnostics;
+  if (!byteMapping || byteMapping.size === 0 || !diagnostics) {
+    return false;
+  }
+  const total = byteMapping.size;
+  const replacementRatio = diagnostics.replacementCharMapCount / total;
+  const privateUseRatio = diagnostics.privateUseCharMapCount / total;
+  return replacementRatio >= 0.5 || privateUseRatio >= 0.5;
+}
+function scoreCharacter(c) {
+  if (c === 9 || c === 10 || c === 13) {
+    return 1;
+  }
+  if (c === 32) {
+    return 2;
+  }
+  if (c < 32 || c === 127) {
+    return -3;
+  }
+  if (c >= 48 && c <= 57) {
+    return 1;
+  }
+  if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+    return 1;
+  }
+  if (`=()[]{}.,;:'"_-+/\\<>`.includes(String.fromCharCode(c))) {
+    return 1;
+  }
+  return 0;
+}
+function scoreAsciiQuality(s) {
+  if (s.length === 0) {
+    return 0;
+  }
+  const totalScore = Array.from(s).reduce((acc, char) => acc + scoreCharacter(char.charCodeAt(0)), 0);
+  return totalScore / s.length;
+}
+function maybeNormalizeSingleByteRawText(rawText) {
+  if (!rawText.includes("\0")) {
+    return rawText;
+  }
+  const bytes = new Array(rawText.length);
+  for (let i2 = 0; i2 < rawText.length; i2++) {
+    bytes[i2] = rawText.charCodeAt(i2) & 255;
+  }
+  const candidates = [];
+  candidates.push(bytesToString(bytes.filter((b) => b !== 0)));
+  if (bytes.length >= 6 && bytes.length % 2 === 0) {
+    const pairs = bytes.length / 2;
+    const bytePairs = Array.from({ length: pairs }, (_, i2) => ({
+      hi: bytes[i2 * 2],
+      lo: bytes[i2 * 2 + 1]
+    }));
+    const hiNearZero = bytePairs.filter(({ hi }) => hi <= 1).length;
+    const loAscii = bytePairs.filter(({ lo }) => lo >= 3 && lo <= 126).length;
+    if (hiNearZero / pairs >= 0.7 && loAscii / pairs >= 0.7) {
+      const lows = bytePairs.map(({ lo }) => lo);
+      candidates.push(bytesToString(lows));
+    }
+  }
+  const shifted = candidates.map((c) => {
+    const b2 = Array.from(c).map((char) => {
+      const b = char.charCodeAt(0) & 255;
+      return b >= 3 ? b - 3 : 0;
+    });
+    return bytesToString(b2);
+  });
+  const sanitizeXmlText = (s) => {
+    return Array.from(s).filter((char) => char.charCodeAt(0) !== 0).map((char) => {
+      const code = char.charCodeAt(0);
+      const isForbidden = code >= 1 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31;
+      return isForbidden ? " " : char;
+    }).join("");
+  };
+  const all = [...candidates, ...shifted].map((s) => sanitizeXmlText(s));
+  const sanitizedRaw = sanitizeXmlText(rawText);
+  const initial = { best: sanitizedRaw, score: scoreAsciiQuality(sanitizedRaw) };
+  const result = all.reduce((acc, s) => {
+    const score = scoreAsciiQuality(s);
+    return score > acc.score + 0.1 ? { best: s, score } : acc;
+  }, initial);
+  return result.best;
+}
+function sanitizeDecodedText(decoded) {
+  return Array.from(decoded).filter((char) => char.charCodeAt(0) !== 0).map((char) => {
+    const code = char.charCodeAt(0);
+    const isKeepWhitespace = code === 9 || code === 10 || code === 13;
+    const isForbiddenControl = code >= 1 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127;
+    return isForbiddenControl && !isKeepWhitespace ? " " : char;
+  }).join("");
+}
+function findFontInfo(fontName, mappings) {
+  const cleanName = fontName.startsWith("/") ? fontName.slice(1) : fontName;
+  const exactMatch = mappings.get(cleanName);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const plusIndex = cleanName.indexOf("+");
+  if (plusIndex > 0) {
+    const baseName = cleanName.slice(plusIndex + 1);
+    const baseMatch = mappings.get(baseName);
+    if (baseMatch) {
+      return baseMatch;
+    }
+  }
+  for (const [key, value] of mappings.entries()) {
+    if (cleanName.includes(key) || key.includes(cleanName)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function decodeText(rawText, fontName, mappings) {
+  const fontInfo = findFontInfo(fontName, mappings);
+  if (!fontInfo) {
+    return sanitizeDecodedText(rawText);
+  }
+  return decodeTextWithFontInfo(rawText, fontInfo);
+}
+function decodeTextWithFontInfo(rawText, fontInfo) {
+  const {
+    mapping,
+    codeByteWidth,
+    encodingMap,
+    toUnicodeByteMapping,
+    toUnicodeSourceCodeByteLengths,
+    cidCodeToUnicodeFallbackMap
+  } = fontInfo;
+  const cidFallbackOrdering = resolveCidFallbackOrdering(fontInfo);
+  const severeCidMode = isToUnicodeSeverelyCorrupted(fontInfo) && codeByteWidth === 2;
+  if (toUnicodeByteMapping && toUnicodeByteMapping.size > 0) {
+    return sanitizeDecodedText(
+      decodeByToUnicodeByteMapping({
+        rawText,
+        byteMapping: toUnicodeByteMapping,
+        sourceCodeByteLengths: toUnicodeSourceCodeByteLengths,
+        legacyMapping: mapping,
+        codeByteWidth,
+        ordering: cidFallbackOrdering,
+        cidCodeToUnicodeFallbackMap,
+        treatReplacementAsMissing: severeCidMode,
+        treatPrivateUseAsMissing: severeCidMode,
+        allowCidFallbackOnBadToUnicode: severeCidMode,
+        allowCidFallbackOnMiss: severeCidMode
+      })
+    );
+  }
+  if (codeByteWidth === 2) {
+    return sanitizeDecodedText(
+      decodeTwoByteText({
+        rawText,
+        mapping,
+        ordering: cidFallbackOrdering,
+        cidCodeToUnicodeFallbackMap,
+        allowCidFallback: mapping.size === 0
+      })
+    );
+  }
+  if (mapping.size > 0) {
+    return sanitizeDecodedText(decodeSingleByteTextWithFallback(rawText, mapping, encodingMap));
+  }
+  if (encodingMap && encodingMap.size > 0) {
+    const normalized = maybeNormalizeSingleByteRawText(rawText);
+    const mutableMap = new Map(encodingMap);
+    return sanitizeDecodedText(decodeSingleByteText(normalized, mutableMap));
+  }
+  return sanitizeDecodedText(rawText);
+}
+function decodeByToUnicodeByteMapping(args) {
+  const {
+    rawText,
+    byteMapping,
+    sourceCodeByteLengths,
+    legacyMapping,
+    codeByteWidth,
+    ordering,
+    cidCodeToUnicodeFallbackMap,
+    treatReplacementAsMissing = false,
+    treatPrivateUseAsMissing = false,
+    allowCidFallbackOnBadToUnicode = false,
+    allowCidFallbackOnMiss = false
+  } = args;
+  const bytes = rawTextToBytes$1(rawText);
+  const byteLengths = resolveSourceCodeByteLengths(byteMapping, sourceCodeByteLengths);
+  if (byteLengths.length === 0) {
+    return rawText;
+  }
+  const minByteLength = byteLengths[byteLengths.length - 1] ?? 1;
+  const missAdvance = minByteLength;
+  const chars = [];
+  for (let i2 = 0; i2 < bytes.length; ) {
+    const matchState = { mapped: void 0, consumed: 0 };
+    for (const byteLength of byteLengths) {
+      if (i2 + byteLength > bytes.length) {
+        continue;
+      }
+      const sourceHex = byteSliceToHex(bytes, i2, byteLength);
+      const hit = byteMapping.get(sourceHex);
+      if (hit !== void 0) {
+        matchState.mapped = hit;
+        matchState.consumed = byteLength;
+        break;
+      }
+    }
+    if (matchState.mapped !== void 0 && matchState.consumed > 0) {
+      const shouldDiscardReplacement = treatReplacementAsMissing && matchState.mapped.includes("�");
+      const shouldDiscardPrivateUse = treatPrivateUseAsMissing && containsPrivateUseCharacter(matchState.mapped);
+      if (!shouldDiscardReplacement && !shouldDiscardPrivateUse) {
+        chars.push(matchState.mapped);
+        i2 += matchState.consumed;
+        continue;
+      }
+      if (codeByteWidth === 2 && matchState.consumed === 2) {
+        const code = bytes[i2] << 8 | bytes[i2 + 1];
+        if (allowCidFallbackOnBadToUnicode) {
+          const cidFallback = decodeCidFallback({
+            code,
+            ordering,
+            cidCodeToUnicodeFallbackMap
+          });
+          if (cidFallback) {
+            chars.push(cidFallback);
+            i2 += 2;
+            continue;
+          }
+        }
+      }
+      chars.push("�");
+      i2 += matchState.consumed;
+      continue;
+    }
+    if (codeByteWidth === 2 && i2 + 1 < bytes.length) {
+      const code = bytes[i2] << 8 | bytes[i2 + 1];
+      const legacyMapped = legacyMapping.get(code);
+      if (legacyMapped !== void 0) {
+        const shouldDiscardReplacement = treatReplacementAsMissing && legacyMapped.includes("�");
+        const shouldDiscardPrivateUse = treatPrivateUseAsMissing && containsPrivateUseCharacter(legacyMapped);
+        if (!shouldDiscardReplacement && !shouldDiscardPrivateUse) {
+          chars.push(legacyMapped);
+          i2 += 2;
+          continue;
+        }
+        if (allowCidFallbackOnBadToUnicode) {
+          const cidFallback = decodeCidFallback({
+            code,
+            ordering,
+            cidCodeToUnicodeFallbackMap
+          });
+          if (cidFallback) {
+            chars.push(cidFallback);
+            i2 += 2;
+            continue;
+          }
+        }
+      }
+      if (allowCidFallbackOnMiss || byteMapping.size === 0 && legacyMapping.size === 0) {
+        const cidFallback = decodeCidFallback({
+          code,
+          ordering,
+          cidCodeToUnicodeFallbackMap
+        });
+        if (cidFallback) {
+          chars.push(cidFallback);
+          i2 += 2;
+          continue;
+        }
+      }
+    }
+    if (codeByteWidth === 1) {
+      const legacyMapped = legacyMapping.get(bytes[i2]);
+      if (legacyMapped !== void 0) {
+        chars.push(legacyMapped);
+        i2 += 1;
+        continue;
+      }
+    }
+    chars.push("�");
+    i2 += Math.min(Math.max(missAdvance, 1), bytes.length - i2);
+  }
+  return chars.join("");
+}
+function decodeTwoByteText(args) {
+  const {
+    rawText,
+    mapping,
+    ordering,
+    cidCodeToUnicodeFallbackMap,
+    allowCidFallback = false,
+    treatReplacementAsMissing = false,
+    treatPrivateUseAsMissing = false
+  } = args;
+  const chars = [];
+  for (let i2 = 0; i2 < rawText.length; i2 += 2) {
+    const highByte = rawText.charCodeAt(i2);
+    const lowByte = i2 + 1 < rawText.length ? rawText.charCodeAt(i2 + 1) : 0;
+    const code = highByte << 8 | lowByte;
+    const mapped = mapping.get(code);
+    const shouldDiscardReplacement = treatReplacementAsMissing && mapped?.includes("�") === true;
+    const shouldDiscardPrivateUse = treatPrivateUseAsMissing && mapped !== void 0 && containsPrivateUseCharacter(mapped);
+    if (mapped && !shouldDiscardReplacement && !shouldDiscardPrivateUse) {
+      chars.push(mapped);
+      continue;
+    }
+    if (allowCidFallback) {
+      const cidFallback = decodeCidFallback({
+        code,
+        ordering,
+        cidCodeToUnicodeFallbackMap
+      });
+      if (cidFallback) {
+        chars.push(cidFallback);
+        continue;
+      }
+    }
+    chars.push("�");
+  }
+  return chars.join("");
+}
+function decodeSingleByteText(rawText, mapping) {
+  return Array.from(rawText).map((char) => {
+    const code = char.charCodeAt(0);
+    return mapping.get(code) ?? char;
+  }).join("");
+}
+function decodeSingleByteTextWithFallback(rawText, toUnicode, encodingMap) {
+  return Array.from(rawText).map((char) => {
+    const code = char.charCodeAt(0);
+    const mapped = toUnicode.get(code);
+    if (mapped) {
+      return mapped;
+    }
+    const fallback = encodingMap?.get(code);
+    return fallback ?? char;
+  }).join("");
+}
 const WINANSI_ENCODING = /* @__PURE__ */ new Map([
   // 0x20-0x7E: Standard ASCII printable characters
   [32, " "],
@@ -5852,9 +6247,12 @@ function createTextRun(text, textState, gfxState) {
   const endUserY = startUserY + advanceUserY;
   const endPos = transformPoint({ x: endUserX, y: endUserY }, ctm);
   const effectiveFontSize = calculateEffectiveFontSize(currentFontSize, textMatrix, ctm);
+  const decodedText = currentFontInfo ? decodeTextWithFontInfo(text, currentFontInfo) : text;
   const run = {
-    text,
+    text: decodedText,
+    rawText: text,
     rawBytes: rawTextToBytes(text),
+    codeByteWidth: currentCodeByteWidth,
     textMatrix,
     x: startPos.x,
     y: startPos.y,
@@ -22071,7 +22469,7 @@ async function getPdfPageDimensions(data, pageNumber = 1) {
   return pages[pageNumber - 1].getSize();
 }
 export {
-  applyGraphicsSoftMaskToPdfImage as A,
+  decodeText as A,
   DEFAULT_FILL_COLOR as D,
   IDENTITY_MATRIX$2 as I,
   translationMatrix as a,
@@ -22096,9 +22494,9 @@ export {
   transformPoint as t,
   getPdfPageCount as u,
   getPdfPageDimensions as v,
-  decodeCIDFallback as w,
-  DEFAULT_FONT_METRICS as x,
-  calculateTextDisplacement as y,
-  rasterizeSoftMaskedFillPath as z
+  DEFAULT_FONT_METRICS as w,
+  calculateTextDisplacement as x,
+  rasterizeSoftMaskedFillPath as y,
+  applyGraphicsSoftMaskToPdfImage as z
 };
-//# sourceMappingURL=pdf-parser-Ciztl2kx.js.map
+//# sourceMappingURL=pdf-parser-NK9_pSDg.js.map