@chialab/pdfjs-lib 1.0.0-alpha.36 → 1.0.0-alpha.37

package/dist/node/worker.js

@@ -1,14 +1,6 @@
 import {
-  DateFormats,
-  FontInfo,
-  MessageHandler,
-  MurmurHash3_64,
-  TimeFormats,
-  convertBlackAndWhiteToRGBA,
-  convertToRGBA,
-  grayToRGBA,
-  wrapReason
-} from "./chunk-4Y7OZIIX.js";
+  bidi
+} from "./chunk-AFWVANFS.js";
 import {
   AbortException,
   AnnotationActionEventType,
@@ -22,16 +14,20 @@ import {
   AnnotationType,
   BASELINE_FACTOR,
   BaseException,
+  DateFormats,
   DocumentActionEventType,
   DrawOPS,
   FONT_IDENTITY_MATRIX,
   FeatureTest,
+  FontInfo,
   FormatError,
   ImageKind,
   InvalidPDFException,
   LINE_DESCENT_FACTOR,
   LINE_FACTOR,
   MathClamp,
+  MessageHandler,
+  MurmurHash3_64,
   OPS,
   PageActionEventType,
   PasswordException,
@@ -39,15 +35,19 @@ import {
   PermissionFlag,
   RenderingIntentFlag,
   TextRenderingMode,
+  TimeFormats,
   Util,
   VerbosityLevel,
   _isValidExplicitDest,
   assert,
   bytesToString,
+  convertBlackAndWhiteToRGBA,
+  convertToRGBA,
   createValidAbsoluteUrl,
   fromBase64Util,
   getModificationDate,
   getVerbosityLevel,
+  grayToRGBA,
   hexNumbers,
   info,
   isArrayEqual,
@@ -63,8 +63,9 @@ import {
   toHexUtil,
   unreachable,
   utf8StringToString,
-  warn
-} from "./chunk-T2JWSGAF.js";
+  warn,
+  wrapReason
+} from "./chunk-7NGJYFOM.js";
 import {
   __privateAdd,
   __privateGet,
@@ -22515,9 +22516,9 @@ var CFFCompiler = class _CFFCompiler {
         continue;
       }
       let values = dict.values[key];
-      let types2 = dict.types[key];
-      if (!Array.isArray(types2)) {
-        types2 = [types2];
+      let types = dict.types[key];
+      if (!Array.isArray(types)) {
+        types = [types];
       }
       if (!Array.isArray(values)) {
         values = [values];
@@ -22525,8 +22526,8 @@ var CFFCompiler = class _CFFCompiler {
       if (values.length === 0) {
         continue;
       }
-      for (let j = 0, jj = types2.length; j < jj; ++j) {
-        const type = types2[j];
+      for (let j = 0, jj = types.length; j < jj; ++j) {
+        const type = types[j];
         const value = values[j];
         switch (type) {
           case "num":
@@ -31922,52 +31923,52 @@ var Font = class {
     );
     return this._glyphCache[charcode] = glyph;
   }
-  charsToGlyphs(chars2) {
-    let glyphs = this._charsCache[chars2];
+  charsToGlyphs(chars) {
+    let glyphs = this._charsCache[chars];
     if (glyphs) {
       return glyphs;
     }
     glyphs = [];
     if (this.cMap) {
-      const c = /* @__PURE__ */ Object.create(null), ii = chars2.length;
+      const c = /* @__PURE__ */ Object.create(null), ii = chars.length;
       let i = 0;
       while (i < ii) {
-        this.cMap.readCharCode(chars2, i, c);
+        this.cMap.readCharCode(chars, i, c);
         const { charcode, length } = c;
         i += length;
         const glyph = this._charToGlyph(
           charcode,
-          length === 1 && chars2.charCodeAt(i - 1) === 32
+          length === 1 && chars.charCodeAt(i - 1) === 32
         );
         glyphs.push(glyph);
       }
     } else {
-      for (let i = 0, ii = chars2.length; i < ii; ++i) {
-        const charcode = chars2.charCodeAt(i);
+      for (let i = 0, ii = chars.length; i < ii; ++i) {
+        const charcode = chars.charCodeAt(i);
         const glyph = this._charToGlyph(charcode, charcode === 32);
         glyphs.push(glyph);
       }
     }
-    return this._charsCache[chars2] = glyphs;
+    return this._charsCache[chars] = glyphs;
   }
   /**
    * Chars can have different sizes (depends on the encoding).
    * @param {String} a string encoded with font encoding.
    * @returns {Array<Array<number>>} the positions of each char in the string.
    */
-  getCharPositions(chars2) {
+  getCharPositions(chars) {
     const positions = [];
     if (this.cMap) {
       const c = /* @__PURE__ */ Object.create(null);
       let i = 0;
-      while (i < chars2.length) {
-        this.cMap.readCharCode(chars2, i, c);
+      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 = chars2.length; i < ii; ++i) {
+      for (let i = 0, ii = chars.length; i < ii; ++i) {
         positions.push([i, i + 1]);
       }
     }
@@ -32026,8 +32027,8 @@ var ErrorFont = class {
   charsToGlyphs() {
     return [];
   }
-  encodeString(chars2) {
-    return [chars2];
+  encodeString(chars) {
+    return [chars];
   }
   exportData() {
     return { error: this.error };
@@ -51005,750 +51006,6 @@ var PostScriptCompiler = class {
   }
 };
 
-// src/pdf.js/src/core/bidi.js
-var baseTypes = [
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "S",
-  "B",
-  "S",
-  "WS",
-  "B",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "B",
-  "B",
-  "B",
-  "S",
-  "WS",
-  "ON",
-  "ON",
-  "ET",
-  "ET",
-  "ET",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ES",
-  "CS",
-  "ES",
-  "CS",
-  "CS",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "CS",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "B",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "BN",
-  "CS",
-  "ON",
-  "ET",
-  "ET",
-  "ET",
-  "ET",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "L",
-  "ON",
-  "ON",
-  "BN",
-  "ON",
-  "ON",
-  "ET",
-  "ET",
-  "EN",
-  "EN",
-  "ON",
-  "L",
-  "ON",
-  "ON",
-  "ON",
-  "EN",
-  "L",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "ON",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "ON",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "ON",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L",
-  "L"
-];
-var arabicTypes = [
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "ON",
-  "ON",
-  "AL",
-  "ET",
-  "ET",
-  "AL",
-  "CS",
-  "AL",
-  "ON",
-  "ON",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "AL",
-  "AL",
-  "",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "AN",
-  "ET",
-  "AN",
-  "AN",
-  "AL",
-  "AL",
-  "AL",
-  "NSM",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "AN",
-  "ON",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "AL",
-  "AL",
-  "NSM",
-  "NSM",
-  "ON",
-  "NSM",
-  "NSM",
-  "NSM",
-  "NSM",
-  "AL",
-  "AL",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "EN",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL",
-  "AL"
-];
-function isOdd(i) {
-  return (i & 1) !== 0;
-}
-function isEven(i) {
-  return (i & 1) === 0;
-}
-function findUnequal(arr, start, value) {
-  let j, jj;
-  for (j = start, jj = arr.length; j < jj; ++j) {
-    if (arr[j] !== value) {
-      return j;
-    }
-  }
-  return j;
-}
-function reverseValues(arr, start, end) {
-  for (let i = start, j = end - 1; i < j; ++i, --j) {
-    const temp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = temp;
-  }
-}
-function createBidiText(str, isLTR, vertical = false) {
-  let dir = "ltr";
-  if (vertical) {
-    dir = "ttb";
-  } else if (!isLTR) {
-    dir = "rtl";
-  }
-  return { str, dir };
-}
-var chars = [];
-var types = [];
-function bidi(str, startLevel = -1, vertical = false) {
-  let isLTR = true;
-  const strLength = str.length;
-  if (strLength === 0 || vertical) {
-    return createBidiText(str, isLTR, vertical);
-  }
-  chars.length = strLength;
-  types.length = strLength;
-  let numBidi = 0;
-  let i, ii;
-  for (i = 0; i < strLength; ++i) {
-    chars[i] = str.charAt(i);
-    const charCode = str.charCodeAt(i);
-    let charType = "L";
-    if (charCode <= 255) {
-      charType = baseTypes[charCode];
-    } else if (1424 <= charCode && charCode <= 1524) {
-      charType = "R";
-    } else if (1536 <= charCode && charCode <= 1791) {
-      charType = arabicTypes[charCode & 255];
-      if (!charType) {
-        warn("Bidi: invalid Unicode character " + charCode.toString(16));
-      }
-    } else if (1792 <= charCode && charCode <= 2220 || 64336 <= charCode && charCode <= 65023 || 65136 <= charCode && charCode <= 65279) {
-      charType = "AL";
-    }
-    if (charType === "R" || charType === "AL" || charType === "AN") {
-      numBidi++;
-    }
-    types[i] = charType;
-  }
-  if (numBidi === 0) {
-    isLTR = true;
-    return createBidiText(str, isLTR);
-  }
-  if (startLevel === -1) {
-    if (numBidi / strLength < 0.3 && strLength > 4) {
-      isLTR = true;
-      startLevel = 0;
-    } else {
-      isLTR = false;
-      startLevel = 1;
-    }
-  }
-  const levels = [];
-  for (i = 0; i < strLength; ++i) {
-    levels[i] = startLevel;
-  }
-  const e = isOdd(startLevel) ? "R" : "L";
-  const sor = e;
-  const eor = sor;
-  let lastType = sor;
-  for (i = 0; i < strLength; ++i) {
-    if (types[i] === "NSM") {
-      types[i] = lastType;
-    } else {
-      lastType = types[i];
-    }
-  }
-  lastType = sor;
-  let t;
-  for (i = 0; i < strLength; ++i) {
-    t = types[i];
-    if (t === "EN") {
-      types[i] = lastType === "AL" ? "AN" : "EN";
-    } else if (t === "R" || t === "L" || t === "AL") {
-      lastType = t;
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    t = types[i];
-    if (t === "AL") {
-      types[i] = "R";
-    }
-  }
-  for (i = 1; i < strLength - 1; ++i) {
-    if (types[i] === "ES" && types[i - 1] === "EN" && types[i + 1] === "EN") {
-      types[i] = "EN";
-    }
-    if (types[i] === "CS" && (types[i - 1] === "EN" || types[i - 1] === "AN") && types[i + 1] === types[i - 1]) {
-      types[i] = types[i - 1];
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    if (types[i] === "EN") {
-      for (let j = i - 1; j >= 0; --j) {
-        if (types[j] !== "ET") {
-          break;
-        }
-        types[j] = "EN";
-      }
-      for (let j = i + 1; j < strLength; ++j) {
-        if (types[j] !== "ET") {
-          break;
-        }
-        types[j] = "EN";
-      }
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    t = types[i];
-    if (t === "WS" || t === "ES" || t === "ET" || t === "CS") {
-      types[i] = "ON";
-    }
-  }
-  lastType = sor;
-  for (i = 0; i < strLength; ++i) {
-    t = types[i];
-    if (t === "EN") {
-      types[i] = lastType === "L" ? "L" : "EN";
-    } else if (t === "R" || t === "L") {
-      lastType = t;
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    if (types[i] === "ON") {
-      const end = findUnequal(types, i + 1, "ON");
-      let before = sor;
-      if (i > 0) {
-        before = types[i - 1];
-      }
-      let after = eor;
-      if (end + 1 < strLength) {
-        after = types[end + 1];
-      }
-      if (before !== "L") {
-        before = "R";
-      }
-      if (after !== "L") {
-        after = "R";
-      }
-      if (before === after) {
-        types.fill(before, i, end);
-      }
-      i = end - 1;
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    if (types[i] === "ON") {
-      types[i] = e;
-    }
-  }
-  for (i = 0; i < strLength; ++i) {
-    t = types[i];
-    if (isEven(levels[i])) {
-      if (t === "R") {
-        levels[i] += 1;
-      } else if (t === "AN" || t === "EN") {
-        levels[i] += 2;
-      }
-    } else if (
-      /* isOdd && */
-      t === "L" || t === "AN" || t === "EN"
-    ) {
-      levels[i] += 1;
-    }
-  }
-  let highestLevel = -1;
-  let lowestOddLevel = 99;
-  let level;
-  for (i = 0, ii = levels.length; i < ii; ++i) {
-    level = levels[i];
-    if (highestLevel < level) {
-      highestLevel = level;
-    }
-    if (lowestOddLevel > level && isOdd(level)) {
-      lowestOddLevel = level;
-    }
-  }
-  for (level = highestLevel; level >= lowestOddLevel; --level) {
-    let start = -1;
-    for (i = 0, ii = levels.length; i < ii; ++i) {
-      if (levels[i] < level) {
-        if (start >= 0) {
-          reverseValues(chars, start, i);
-          start = -1;
-        }
-      } else if (start < 0) {
-        start = i;
-      }
-    }
-    if (start >= 0) {
-      reverseValues(chars, start, levels.length);
-    }
-  }
-  for (i = 0, ii = chars.length; i < ii; ++i) {
-    const ch3 = chars[i];
-    if (ch3 === "<" || ch3 === ">") {
-      chars[i] = "";
-    }
-  }
-  return createBidiText(chars.join(""), isLTR);
-}
-
 // src/pdf.js/src/core/font_substitutions.js
 var NORMAL = {
   style: "normal",
@@ -54860,9 +54117,9 @@ var PartialEvaluator = class _PartialEvaluator {
     translated.send(this.handler);
     return translated.loadedName;
   }
-  handleText(chars2, state) {
+  handleText(chars, state) {
     const font = state.font;
-    const glyphs = font.charsToGlyphs(chars2);
+    const glyphs = font.charsToGlyphs(chars);
     if (font.data) {
       const isAddToPathSet = !!(state.textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG);
       if (isAddToPathSet || state.fillColorSpace.name === "Pattern" || font.disableFontFace) {
@@ -56378,9 +55635,9 @@ var PartialEvaluator = class _PartialEvaluator {
       }
       return true;
     }
-    function buildTextContentItem({ chars: chars2, extraSpacing }) {
+    function buildTextContentItem({ chars, extraSpacing }) {
       const font = textState.font;
-      if (!chars2) {
+      if (!chars) {
         const charSpacing = textState.charSpacing + extraSpacing;
         if (charSpacing) {
           if (!font.vertical) {
@@ -56397,7 +55654,7 @@ var PartialEvaluator = class _PartialEvaluator {
         }
         return;
       }
-      const glyphs = font.charsToGlyphs(chars2);
+      const glyphs = font.charsToGlyphs(chars);
       const scale = textState.fontMatrix[0] * textState.fontSize;
       for (let i = 0, ii = glyphs.length; i < ii; i++) {
         const glyph = glyphs[i];
@@ -58573,10 +57830,10 @@ var FakeUnicodeFont = class _FakeUnicodeFont {
     descendantFont.set("FontDescriptor", this.fontDescriptorRef);
     descendantFont.set("DW", 1e3);
     const widths = [];
-    const chars2 = [...this.widths.entries()].sort();
+    const chars = [...this.widths.entries()].sort();
     let currentChar = null;
     let currentWidths = null;
-    for (const [char, width] of chars2) {
+    for (const [char, width] of chars) {
       if (!currentChar) {
         currentChar = char;
         currentWidths = [width];
@@ -83074,12 +82331,12 @@ var Page = class {
     );
     return shadow(this, "jsActions", actions);
   }
-  async collectAnnotationsByType(handler, task, types2, promises, annotationGlobals) {
+  async collectAnnotationsByType(handler, task, types, promises, annotationGlobals) {
     const { pageIndex } = this;
     if (__privateGet(this, _areAnnotationsCached)) {
       const cachedAnnotations = await this._parsedAnnotations;
       for (const { data } of cachedAnnotations) {
-        if (!types2 || types2.has(data.annotationType)) {
+        if (!types || types.has(data.annotationType)) {
           data.pageIndex = pageIndex;
           promises.push(Promise.resolve(data));
         }
@@ -83099,7 +82356,7 @@ var Page = class {
           /* orphanFields */
           null,
           /* collectByType */
-          types2,
+          types,
           this.ref
         ).then(async (annotation) => {
           if (!annotation) {
@@ -85125,7 +84382,7 @@ var _WorkerMessageHandler = class _WorkerMessageHandler {
     });
     handler.on(
       "GetAnnotationsByType",
-      async function({ types: types2, pageIndexesToSkip }) {
+      async function({ types, pageIndexesToSkip }) {
         const [numPages, annotationGlobals] = await Promise.all([
           pdfManager.ensureDoc("numPages"),
           pdfManager.ensureDoc("annotationGlobals")
@@ -85153,7 +84410,7 @@ var _WorkerMessageHandler = class _WorkerMessageHandler {
                 return page.collectAnnotationsByType(
                   handler,
                   task,
-                  types2,
+                  types,
                   annotationPromises,
                   annotationGlobals
                 ) || [];