pdfjs-dist 2.5.207 → 2.6.347

package/lib/core/chunked_stream.js

@@ -37,8 +37,7 @@ class ChunkedStream {
     this.pos = 0;
     this.end = length;
     this.chunkSize = chunkSize;
-    this.loadedChunks = [];
-    this.numChunksLoaded = 0;
+    this._loadedChunks = new Set();
     this.numChunks = Math.ceil(length / chunkSize);
     this.manager = manager;
     this.progressiveDataLength = 0;
@@ -49,7 +48,7 @@ class ChunkedStream {
     const chunks = [];
 
     for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
-      if (!this.loadedChunks[chunk]) {
+      if (!this._loadedChunks.has(chunk)) {
         chunks.push(chunk);
       }
     }
@@ -61,6 +60,10 @@ class ChunkedStream {
     return [this];
   }
 
+  get numChunksLoaded() {
+    return this._loadedChunks.size;
+  }
+
   allChunksLoaded() {
     return this.numChunksLoaded === this.numChunks;
   }
@@ -83,10 +86,7 @@ class ChunkedStream {
     const endChunk = Math.floor((end - 1) / chunkSize) + 1;
 
     for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
-      if (!this.loadedChunks[curChunk]) {
-        this.loadedChunks[curChunk] = true;
-        ++this.numChunksLoaded;
-      }
+      this._loadedChunks.add(curChunk);
     }
   }
 
@@ -99,10 +99,7 @@ class ChunkedStream {
     const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
 
     for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
-      if (!this.loadedChunks[curChunk]) {
-        this.loadedChunks[curChunk] = true;
-        ++this.numChunksLoaded;
-      }
+      this._loadedChunks.add(curChunk);
     }
   }
 
@@ -117,7 +114,7 @@ class ChunkedStream {
       return;
     }
 
-    if (!this.loadedChunks[chunk]) {
+    if (!this._loadedChunks.has(chunk)) {
       throw new _core_utils.MissingDataException(pos, pos + 1);
     }
 
@@ -138,7 +135,7 @@ class ChunkedStream {
     const endChunk = Math.floor((end - 1) / chunkSize) + 1;
 
     for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
-      if (!this.loadedChunks[chunk]) {
+      if (!this._loadedChunks.has(chunk)) {
         throw new _core_utils.MissingDataException(begin, end);
       }
     }
@@ -150,7 +147,7 @@ class ChunkedStream {
     for (let i = 0; i < numChunks; ++i) {
       const chunk = (beginChunk + i) % numChunks;
 
-      if (!this.loadedChunks[chunk]) {
+      if (!this._loadedChunks.has(chunk)) {
         return chunk;
       }
     }
@@ -159,7 +156,7 @@ class ChunkedStream {
   }
 
   hasChunk(chunk) {
-    return !!this.loadedChunks[chunk];
+    return this._loadedChunks.has(chunk);
   }
 
   get length() {
@@ -302,7 +299,7 @@ class ChunkedStream {
       const missingChunks = [];
 
       for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
-        if (!this.loadedChunks[chunk]) {
+        if (!this._loadedChunks.has(chunk)) {
           missingChunks.push(chunk);
         }
       }
@@ -338,9 +335,9 @@ class ChunkedStreamManager {
     this.disableAutoFetch = args.disableAutoFetch;
     this.msgHandler = args.msgHandler;
     this.currRequestId = 0;
-    this.chunksNeededByRequest = Object.create(null);
-    this.requestsByChunk = Object.create(null);
-    this.promisesByRequest = Object.create(null);
+    this._chunksNeededByRequest = new Map();
+    this._requestsByChunk = new Map();
+    this._promisesByRequest = new Map();
     this.progressiveDataLength = 0;
     this.aborted = false;
     this._loadedStreamCapability = (0, _util.createPromiseCapability)();
@@ -409,47 +406,57 @@ class ChunkedStreamManager {
 
   _requestChunks(chunks) {
     const requestId = this.currRequestId++;
-    const chunksNeeded = Object.create(null);
-    this.chunksNeededByRequest[requestId] = chunksNeeded;
+    const chunksNeeded = new Set();
+
+    this._chunksNeededByRequest.set(requestId, chunksNeeded);
 
     for (const chunk of chunks) {
       if (!this.stream.hasChunk(chunk)) {
-        chunksNeeded[chunk] = true;
+        chunksNeeded.add(chunk);
       }
     }
 
-    if ((0, _util.isEmptyObj)(chunksNeeded)) {
+    if (chunksNeeded.size === 0) {
       return Promise.resolve();
     }
 
     const capability = (0, _util.createPromiseCapability)();
-    this.promisesByRequest[requestId] = capability;
+
+    this._promisesByRequest.set(requestId, capability);
+
     const chunksToRequest = [];
 
-    for (let chunk in chunksNeeded) {
-      chunk = chunk | 0;
+    for (const chunk of chunksNeeded) {
+      let requestIds = this._requestsByChunk.get(chunk);
+
+      if (!requestIds) {
+        requestIds = [];
+
+        this._requestsByChunk.set(chunk, requestIds);
 
-      if (!(chunk in this.requestsByChunk)) {
-        this.requestsByChunk[chunk] = [];
         chunksToRequest.push(chunk);
       }
 
-      this.requestsByChunk[chunk].push(requestId);
-    }
-
-    if (!chunksToRequest.length) {
-      return capability.promise;
+      requestIds.push(requestId);
     }
 
-    const groupedChunksToRequest = this.groupChunks(chunksToRequest);
+    if (chunksToRequest.length > 0) {
+      const groupedChunksToRequest = this.groupChunks(chunksToRequest);
 
-    for (const groupedChunk of groupedChunksToRequest) {
-      const begin = groupedChunk.beginChunk * this.chunkSize;
-      const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
-      this.sendRequest(begin, end);
+      for (const groupedChunk of groupedChunksToRequest) {
+        const begin = groupedChunk.beginChunk * this.chunkSize;
+        const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
+        this.sendRequest(begin, end);
+      }
     }
 
-    return capability.promise;
+    return capability.promise.catch(reason => {
+      if (this.aborted) {
+        return;
+      }
+
+      throw reason;
+    });
   }
 
   getStream() {
@@ -551,17 +558,22 @@ class ChunkedStreamManager {
     const loadedRequests = [];
 
     for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
-      const requestIds = this.requestsByChunk[curChunk] || [];
-      delete this.requestsByChunk[curChunk];
+      const requestIds = this._requestsByChunk.get(curChunk);
+
+      if (!requestIds) {
+        continue;
+      }
+
+      this._requestsByChunk.delete(curChunk);
 
       for (const requestId of requestIds) {
-        const chunksNeeded = this.chunksNeededByRequest[requestId];
+        const chunksNeeded = this._chunksNeededByRequest.get(requestId);
 
-        if (curChunk in chunksNeeded) {
-          delete chunksNeeded[curChunk];
+        if (chunksNeeded.has(curChunk)) {
+          chunksNeeded.delete(curChunk);
         }
 
-        if (!(0, _util.isEmptyObj)(chunksNeeded)) {
+        if (chunksNeeded.size > 0) {
           continue;
         }
 
@@ -569,7 +581,7 @@ class ChunkedStreamManager {
       }
     }
 
-    if (!this.disableAutoFetch && (0, _util.isEmptyObj)(this.requestsByChunk)) {
+    if (!this.disableAutoFetch && this._requestsByChunk.size === 0) {
       let nextEmptyChunk;
 
       if (this.stream.numChunksLoaded === 1) {
@@ -588,8 +600,10 @@ class ChunkedStreamManager {
     }
 
     for (const requestId of loadedRequests) {
-      const capability = this.promisesByRequest[requestId];
-      delete this.promisesByRequest[requestId];
+      const capability = this._promisesByRequest.get(requestId);
+
+      this._promisesByRequest.delete(requestId);
+
       capability.resolve();
     }
 
@@ -618,8 +632,8 @@ class ChunkedStreamManager {
       this.pdfNetworkStream.cancelAllRequests(reason);
     }
 
-    for (const requestId in this.promisesByRequest) {
-      this.promisesByRequest[requestId].reject(reason);
+    for (const capability of this._promisesByRequest.values()) {
+      capability.reject(reason);
     }
   }
 

package/lib/core/colorspace.js

@@ -30,6 +30,8 @@ var _util = require("../shared/util.js");
 
 var _primitives = require("./primitives.js");
 
+var _core_utils = require("./core_utils.js");
+
 function resizeRgbImage(src, dest, w1, h1, w2, h2, alpha01) {
   const COMPONENTS = 3;
   alpha01 = alpha01 !== 1 ? 0 : alpha01;
@@ -162,135 +164,162 @@ class ColorSpace {
     return (0, _util.shadow)(this, "usesZeroToOneRange", true);
   }
 
-  static parse(cs, xref, res, pdfFunctionFactory) {
-    const IR = this.parseToIR(cs, xref, res, pdfFunctionFactory);
-    return this.fromIR(IR);
-  }
+  static _cache(cacheKey, xref, localColorSpaceCache, parsedColorSpace) {
+    if (!localColorSpaceCache) {
+      throw new Error('ColorSpace._cache - expected "localColorSpaceCache" argument.');
+    }
 
-  static fromIR(IR) {
-    const name = Array.isArray(IR) ? IR[0] : IR;
-    let whitePoint, blackPoint, gamma;
+    if (!parsedColorSpace) {
+      throw new Error('ColorSpace._cache - expected "parsedColorSpace" argument.');
+    }
 
-    switch (name) {
-      case "DeviceGrayCS":
-        return this.singletons.gray;
+    let csName, csRef;
 
-      case "DeviceRgbCS":
-        return this.singletons.rgb;
+    if (cacheKey instanceof _primitives.Ref) {
+      csRef = cacheKey;
+      cacheKey = xref.fetch(cacheKey);
+    }
 
-      case "DeviceCmykCS":
-        return this.singletons.cmyk;
+    if (cacheKey instanceof _primitives.Name) {
+      csName = cacheKey.name;
+    }
 
-      case "CalGrayCS":
-        whitePoint = IR[1];
-        blackPoint = IR[2];
-        gamma = IR[3];
-        return new CalGrayCS(whitePoint, blackPoint, gamma);
+    if (csName || csRef) {
+      localColorSpaceCache.set(csName, csRef, parsedColorSpace);
+    }
+  }
 
-      case "CalRGBCS":
-        whitePoint = IR[1];
-        blackPoint = IR[2];
-        gamma = IR[3];
-        const matrix = IR[4];
-        return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
+  static getCached(cacheKey, xref, localColorSpaceCache) {
+    if (!localColorSpaceCache) {
+      throw new Error('ColorSpace.getCached - expected "localColorSpaceCache" argument.');
+    }
+
+    if (cacheKey instanceof _primitives.Ref) {
+      const localColorSpace = localColorSpaceCache.getByRef(cacheKey);
 
-      case "PatternCS":
-        let basePatternCS = IR[1];
+      if (localColorSpace) {
+        return localColorSpace;
+      }
 
-        if (basePatternCS) {
-          basePatternCS = this.fromIR(basePatternCS);
+      try {
+        cacheKey = xref.fetch(cacheKey);
+      } catch (ex) {
+        if (ex instanceof _core_utils.MissingDataException) {
+          throw ex;
         }
+      }
+    }
 
-        return new PatternCS(basePatternCS);
+    if (cacheKey instanceof _primitives.Name) {
+      const localColorSpace = localColorSpaceCache.getByName(cacheKey.name);
 
-      case "IndexedCS":
-        const baseIndexedCS = IR[1];
-        const hiVal = IR[2];
-        const lookup = IR[3];
-        return new IndexedCS(this.fromIR(baseIndexedCS), hiVal, lookup);
+      if (localColorSpace) {
+        return localColorSpace;
+      }
+    }
 
-      case "AlternateCS":
-        const numComps = IR[1];
-        const alt = IR[2];
-        const tintFn = IR[3];
-        return new AlternateCS(numComps, this.fromIR(alt), tintFn);
+    return null;
+  }
+
+  static async parseAsync({
+    cs,
+    xref,
+    resources = null,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
 
-      case "LabCS":
-        whitePoint = IR[1];
-        blackPoint = IR[2];
-        const range = IR[3];
-        return new LabCS(whitePoint, blackPoint, range);
+    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
+
+    return parsedColorSpace;
+  }
 
-      default:
-        throw new _util.FormatError(`Unknown colorspace name: ${name}`);
+  static parse({
+    cs,
+    xref,
+    resources = null,
+    pdfFunctionFactory,
+    localColorSpaceCache
+  }) {
+    const cachedColorSpace = this.getCached(cs, xref, localColorSpaceCache);
+
+    if (cachedColorSpace) {
+      return cachedColorSpace;
     }
+
+    const parsedColorSpace = this._parse(cs, xref, resources, pdfFunctionFactory);
+
+    this._cache(cs, xref, localColorSpaceCache, parsedColorSpace);
+
+    return parsedColorSpace;
   }
 
-  static parseToIR(cs, xref, res = null, pdfFunctionFactory) {
+  static _parse(cs, xref, resources = null, pdfFunctionFactory) {
     cs = xref.fetchIfRef(cs);
 
     if ((0, _primitives.isName)(cs)) {
       switch (cs.name) {
         case "DeviceGray":
         case "G":
-          return "DeviceGrayCS";
+          return this.singletons.gray;
 
         case "DeviceRGB":
         case "RGB":
-          return "DeviceRgbCS";
+          return this.singletons.rgb;
 
         case "DeviceCMYK":
         case "CMYK":
-          return "DeviceCmykCS";
+          return this.singletons.cmyk;
 
         case "Pattern":
-          return ["PatternCS", null];
+          return new PatternCS(null);
 
         default:
-          if ((0, _primitives.isDict)(res)) {
-            const colorSpaces = res.get("ColorSpace");
+          if ((0, _primitives.isDict)(resources)) {
+            const colorSpaces = resources.get("ColorSpace");
 
             if ((0, _primitives.isDict)(colorSpaces)) {
-              const resCS = colorSpaces.get(cs.name);
+              const resourcesCS = colorSpaces.get(cs.name);
 
-              if (resCS) {
-                if ((0, _primitives.isName)(resCS)) {
-                  return this.parseToIR(resCS, xref, res, pdfFunctionFactory);
+              if (resourcesCS) {
+                if ((0, _primitives.isName)(resourcesCS)) {
+                  return this._parse(resourcesCS, xref, resources, pdfFunctionFactory);
                 }
 
-                cs = resCS;
+                cs = resourcesCS;
                 break;
               }
             }
           }
 
-          throw new _util.FormatError(`unrecognized colorspace ${cs.name}`);
+          throw new _util.FormatError(`Unrecognized ColorSpace: ${cs.name}`);
       }
     }
 
     if (Array.isArray(cs)) {
       const mode = xref.fetchIfRef(cs[0]).name;
-      let numComps, params, alt, whitePoint, blackPoint, gamma;
+      let params, numComps, baseCS, whitePoint, blackPoint, gamma;
 
       switch (mode) {
         case "DeviceGray":
         case "G":
-          return "DeviceGrayCS";
+          return this.singletons.gray;
 
         case "DeviceRGB":
         case "RGB":
-          return "DeviceRgbCS";
+          return this.singletons.rgb;
 
         case "DeviceCMYK":
         case "CMYK":
-          return "DeviceCmykCS";
+          return this.singletons.cmyk;
 
         case "CalGray":
           params = xref.fetchIfRef(cs[1]);
           whitePoint = params.getArray("WhitePoint");
           blackPoint = params.getArray("BlackPoint");
           gamma = params.get("Gamma");
-          return ["CalGrayCS", whitePoint, blackPoint, gamma];
+          return new CalGrayCS(whitePoint, blackPoint, gamma);
 
         case "CalRGB":
           params = xref.fetchIfRef(cs[1]);
@@ -298,77 +327,71 @@ class ColorSpace {
           blackPoint = params.getArray("BlackPoint");
           gamma = params.getArray("Gamma");
           const matrix = params.getArray("Matrix");
-          return ["CalRGBCS", whitePoint, blackPoint, gamma, matrix];
+          return new CalRGBCS(whitePoint, blackPoint, gamma, matrix);
 
         case "ICCBased":
           const stream = xref.fetchIfRef(cs[1]);
           const dict = stream.dict;
           numComps = dict.get("N");
-          alt = dict.get("Alternate");
+          const alt = dict.get("Alternate");
 
           if (alt) {
-            const altIR = this.parseToIR(alt, xref, res, pdfFunctionFactory);
-            const altCS = this.fromIR(altIR, pdfFunctionFactory);
+            const altCS = this._parse(alt, xref, resources, pdfFunctionFactory);
 
             if (altCS.numComps === numComps) {
-              return altIR;
+              return altCS;
             }
 
             (0, _util.warn)("ICCBased color space: Ignoring incorrect /Alternate entry.");
           }
 
           if (numComps === 1) {
-            return "DeviceGrayCS";
+            return this.singletons.gray;
           } else if (numComps === 3) {
-            return "DeviceRgbCS";
+            return this.singletons.rgb;
           } else if (numComps === 4) {
-            return "DeviceCmykCS";
+            return this.singletons.cmyk;
           }
 
           break;
 
         case "Pattern":
-          let basePatternCS = cs[1] || null;
+          baseCS = cs[1] || null;
 
-          if (basePatternCS) {
-            basePatternCS = this.parseToIR(basePatternCS, xref, res, pdfFunctionFactory);
+          if (baseCS) {
+            baseCS = this._parse(baseCS, xref, resources, pdfFunctionFactory);
           }
 
-          return ["PatternCS", basePatternCS];
+          return new PatternCS(baseCS);
 
         case "Indexed":
         case "I":
-          const baseIndexedCS = this.parseToIR(cs[1], xref, res, pdfFunctionFactory);
+          baseCS = this._parse(cs[1], xref, resources, pdfFunctionFactory);
           const hiVal = xref.fetchIfRef(cs[2]) + 1;
-          let lookup = xref.fetchIfRef(cs[3]);
-
-          if ((0, _primitives.isStream)(lookup)) {
-            lookup = lookup.getBytes();
-          }
-
-          return ["IndexedCS", baseIndexedCS, hiVal, lookup];
+          const lookup = xref.fetchIfRef(cs[3]);
+          return new IndexedCS(baseCS, hiVal, lookup);
 
         case "Separation":
         case "DeviceN":
           const name = xref.fetchIfRef(cs[1]);
           numComps = Array.isArray(name) ? name.length : 1;
-          alt = this.parseToIR(cs[2], xref, res, pdfFunctionFactory);
-          const tintFn = pdfFunctionFactory.create(xref.fetchIfRef(cs[3]));
-          return ["AlternateCS", numComps, alt, tintFn];
+          baseCS = this._parse(cs[2], xref, resources, pdfFunctionFactory);
+          const tintFn = pdfFunctionFactory.create(cs[3]);
+          return new AlternateCS(numComps, baseCS, tintFn);
 
         case "Lab":
           params = xref.fetchIfRef(cs[1]);
           whitePoint = params.getArray("WhitePoint");
           blackPoint = params.getArray("BlackPoint");
           const range = params.getArray("Range");
-          return ["LabCS", whitePoint, blackPoint, range];
+          return new LabCS(whitePoint, blackPoint, range);
 
         default:
-          throw new _util.FormatError(`unimplemented color space object "${mode}"`);
+          throw new _util.FormatError(`Unimplemented ColorSpace object: ${mode}`);
       }
     }
 
-    throw new _util.FormatError(`unrecognized color space object: "${cs}"`);
+    throw new _util.FormatError(`Unrecognized ColorSpace object: ${cs}`);
   }
 
   static isDefaultDecode(decode, numComps) {
@@ -484,23 +507,18 @@ class IndexedCS extends ColorSpace {
     super("Indexed", 1);
     this.base = base;
     this.highVal = highVal;
-    const baseNumComps = base.numComps;
-    const length = baseNumComps * highVal;
+    const length = base.numComps * highVal;
+    this.lookup = new Uint8Array(length);
 
     if ((0, _primitives.isStream)(lookup)) {
-      this.lookup = new Uint8Array(length);
       const bytes = lookup.getBytes(length);
       this.lookup.set(bytes);
-    } else if ((0, _util.isString)(lookup)) {
-      this.lookup = new Uint8Array(length);
-
+    } else if (typeof lookup === "string") {
       for (let i = 0; i < length; ++i) {
-        this.lookup[i] = lookup.charCodeAt(i);
+        this.lookup[i] = lookup.charCodeAt(i) & 0xff;
       }
-    } else if (lookup instanceof Uint8Array) {
-      this.lookup = lookup;
     } else {
-      throw new _util.FormatError(`Unrecognized lookup table: ${lookup}`);
+      throw new _util.FormatError(`IndexedCS - unrecognized lookup table: ${lookup}`);
     }
   }
 
@@ -762,6 +780,10 @@ const CalRGBCS = function CalRGBCSClosure() {
       return adjustToRange(0, 1, 12.92 * color);
     }
 
+    if (color >= 0.99554525) {
+      return 1;
+    }
+
     return adjustToRange(0, 1, (1 + 0.055) * color ** (1 / 2.4) - 0.055);
   }
 
@@ -834,9 +856,9 @@ const CalRGBCS = function CalRGBCSClosure() {
     const A = adjustToRange(0, 1, src[srcOffset] * scale);
     const B = adjustToRange(0, 1, src[srcOffset + 1] * scale);
     const C = adjustToRange(0, 1, src[srcOffset + 2] * scale);
-    const AGR = A ** cs.GR;
-    const BGG = B ** cs.GG;
-    const CGB = C ** cs.GB;
+    const AGR = A === 1 ? 1 : A ** cs.GR;
+    const BGG = B === 1 ? 1 : B ** cs.GG;
+    const CGB = C === 1 ? 1 : C ** cs.GB;
     const X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB;
     const Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB;
     const Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB;