https://rieckservices.com/wp-content/plugins/pdfembedder-premium/js/pdfjs/pdf.worker.js

1/* Copyright 2017 Mozilla Foundation
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16(function webpackUniversalModuleDefinition(root, factory) {
17	if(typeof exports === 'object' && typeof module === 'object')
18		module.exports = factory();
19	else if(typeof define === 'function' && define.amd)
20		define("pdfjs-dist/build/pdf.worker", [], factory);
21	else if(typeof exports === 'object')
22		exports["pdfjs-dist/build/pdf.worker"] = factory();
23	else
24		root["pdfjs-dist/build/pdf.worker"] = root.pdfjsDistBuildPdfWorker = factory();
25})(this, function() {
26return /******/ (function(modules) { // webpackBootstrap
27/******/ 	// The module cache
28/******/ 	var installedModules = {};
29/******/
30/******/ 	// The require function
31/******/ 	function __w_pdfjs_require__(moduleId) {
32/******/
33/******/ 		// Check if module is in cache
34/******/ 		if(installedModules[moduleId]) {
35/******/ 			return installedModules[moduleId].exports;
36/******/ 		}
37/******/ 		// Create a new module (and put it into the cache)
38/******/ 		var module = installedModules[moduleId] = {
39/******/ 			i: moduleId,
40/******/ 			l: false,
41/******/ 			exports: {}
42/******/ 		};
43/******/
44/******/ 		// Execute the module function
45/******/ 		modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
46/******/
47/******/ 		// Flag the module as loaded
48/******/ 		module.l = true;
49/******/
50/******/ 		// Return the exports of the module
51/******/ 		return module.exports;
52/******/ 	}
53/******/
54/******/
55/******/ 	// expose the modules object (__webpack_modules__)
56/******/ 	__w_pdfjs_require__.m = modules;
57/******/
58/******/ 	// expose the module cache
59/******/ 	__w_pdfjs_require__.c = installedModules;
60/******/
61/******/ 	// define getter function for harmony exports
62/******/ 	__w_pdfjs_require__.d = function(exports, name, getter) {
63/******/ 		if(!__w_pdfjs_require__.o(exports, name)) {
64/******/ 			Object.defineProperty(exports, name, {
65/******/ 				configurable: false,
66/******/ 				enumerable: true,
67/******/ 				get: getter
68/******/ 			});
69/******/ 		}
70/******/ 	};
71/******/
72/******/ 	// getDefaultExport function for compatibility with non-harmony modules
73/******/ 	__w_pdfjs_require__.n = function(module) {
74/******/ 		var getter = module && module.__esModule ?
75/******/ 			function getDefault() { return module['default']; } :
76/******/ 			function getModuleExports() { return module; };
77/******/ 		__w_pdfjs_require__.d(getter, 'a', getter);
78/******/ 		return getter;
79/******/ 	};
80/******/
81/******/ 	// Object.prototype.hasOwnProperty.call
82/******/ 	__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
83/******/
84/******/ 	// __webpack_public_path__
85/******/ 	__w_pdfjs_require__.p = "";
86/******/
87/******/ 	// Load entry module and return exports
88/******/ 	return __w_pdfjs_require__(__w_pdfjs_require__.s = 72);
89/******/ })
90/************************************************************************/
91/******/ ([
92/* 0 */
93/***/ (function(module, exports, __w_pdfjs_require__) {
94
95"use strict";
96
97
98Object.defineProperty(exports, "__esModule", {
99  value: true
100});
101exports.unreachable = exports.warn = exports.utf8StringToString = exports.stringToUTF8String = exports.stringToPDFString = exports.stringToBytes = exp

624  }
625}
626var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
627var Util = function UtilClosure() {
628  function Util() {}
629  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];
630  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
631    rgbBuf[1] = r;
632    rgbBuf[3] = g;
633    rgbBuf[5] = b;
634    return rgbBuf.join('');
635  };
636  Util.transform = function Util_transform(m1, m2) {
637    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
638  };
639  Util.applyTransform = function Util_applyTransform(p, m) {
640    var xt = p[0] * m[0] + p[1] * m[2] + m[4];
641    var yt = p[0] * m[1] + p[1] * m[3] + m[5];
642    return [xt, yt];
643  };
644  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
645    var d = m[0] * m[3] - m[1] * m[2];
646    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
647    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
648    return [xt, yt];
649  };
650  Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
651    var p1 = Util.applyTransform(r, m);
652    var p2 = Util.applyTransform(r.slice(2, 4), m);
653    var p3 = Util.applyTransform([r[0], r[3]], m);
654    var p4 = Util.applyTransform([r[2], r[1]], m);
655    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
656  };
657  Util.inverseTransform = function Util_inverseTransform(m) {
658    var d = m[0] * m[3] - m[1] * m[2];
659    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
660  };
661  Util.apply3dTransform = function Util_apply3dTransform(m, v) {
662    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
663  };
664  Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
665    var transpose = [m[0], m[2], m[1], m[3]];
666    var a = m[0] * transpose[0] + m[1] * transpose[2];
667    var b = m[0] * transpose[1] + m[1] * transpose[3];
668    var c = m[2] * transpose[0] + m[3] * transpose[2];
669    var d = m[2] * transpose[1] + m[3] * transpose[3];
670    var first = (a + d) / 2;
671    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
672    var sx = first + second || 1;
673    var sy = first - second || 1;
674    return [Math.sqrt(sx), Math.sqrt(sy)];
675  };
676  Util.normalizeRect = function Util_normalizeRect(rect) {
677    var r = rect.slice(0);
678    if (rect[0] > rect[2]) {
679      r[0] = rect[2];
680      r[2] = rect[0];
681    }
682    if (rect[1] > rect[3]) {
683      r[1] = rect[3];
684      r[3] = rect[1];
685    }
686    return r;
687  };
688  Util.intersect = function Util_intersect(rect1, rect2) {
689    function compare(a, b) {
690      return a - b;
691    }
692    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),

693        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
694        result = [];
695    rect1 = Util.normalizeRect(rect1);
696    rect2 = Util.normalizeRect(rect2);
697    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
698      result[0] = orderedX[1];
699      result[2] = orderedX[2];
700    } else {
701      return false;
702    }
703    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
704      result[1] = orderedY[1];
705      result[3] = orderedY[2];
706    } else {
707      return false;
708    }
709    return result;
710  };
711  var ROMAN_NUMBER_MAP = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'];
712  Util.toRoman = function Util_toRoman(number, lowerCase) {
713    assert(Number.isInteger(number) && number > 0, 'The number should be a positive integer.');
714    var pos,
715        romanBuf = [];
716    while (number >= 1000) {
717      number -= 1000;
718      romanBuf.push('M');
719    }
720    pos = number / 100 | 0;
721    number %= 100;
722    romanBuf.push(ROMAN_NUMBER_MAP[pos]);
723    pos = number / 10 | 0;
724    number %= 10;
725    romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
726    romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
727    var romanStr = romanBuf.join('');
728    return lowerCase ? romanStr.toLowerCase() : romanStr;
729  };
730  Util.appendToArray = function Util_appendToArray(arr1, arr2) {
731    Array.prototype.push.apply(arr1, arr2);
732  };
733  Util.prependToArray = function Util_prependToArray(arr1, arr2) {
734    Array.prototype.unshift.apply(arr1, arr2);
735  };
736  Util.extendObj = function extendObj(obj1, obj2) {
737    for (var key in obj2) {
738      obj1[key] = obj2[key];
739    }
740  };
741  Util.getInheritableProperty = function Util_getInheritableProperty(dict, name, getArray) {
742    while (dict && !dict.has(name)) {
743      dict = dict.get('Parent');
744    }
745    if (!dict) {
746      return null;
747    }
748    return getArray ? dict.getArray(name) : dict.get(name);
749  };
750  Util.inherit = function Util_inherit(sub, base, prototype) {
751    sub.prototype = Object.create(base.prototype);
752    sub.prototype.constructor = sub;
753    for (var prop in prototype) {
754      sub.prototype[prop] = prototype[prop];
755    }
756  };
757  Util.loadScript = function Util_loadScript(src, callback) {
758    var script = document.createElement('script');
759    var loaded = false;
760    script.setAttribute('src', src);
761    if (callback) {
762      script.onload = function () {
763        if (!loaded) {
764          callback();
765        }
766        loaded = true;
767      };
768    }
769    document.getElementsByTagName('head')[0].appendChild(script);
770  };
771  return Util;
772}();
773var PageViewport = function PageViewportClosure() {
774  function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
775    this.viewBox = viewBox;
776    this.scale = scale;
777    this.rotation = rotation;
778    this.offsetX = offsetX;
779    this.offsetY = offsetY;
780    var centerX = (viewBox[2] + viewBox[0]) / 2;
781    var centerY = (viewBox[3] + viewBox[1]) / 2;
782    var rotateA, rotateB, rotateC, rotateD;
783    rotation = rotation % 360;
784    rotation = rotation < 0 ? rotation + 360 : rotation;
785    switch (rotation) {
786      case 180:
787        rotateA = -1;
788        rotateB = 0;
789        rotateC = 0;
790        rotateD = 1;
791        break;
792      case 90:
793        rotateA = 0;
794        rotateB = 1;
795        rotateC = 1;
796        rotateD = 0;
797        break;
798      case 270:
799        rotateA = 0;
800        rotateB = -1;
801        rotateC = -1;
802        rotateD = 0;
803        break;
804      default:
805        rotateA = 1;
806        rotateB = 0;
807        rotateC = 0;
808        rotateD = -1;
809        break;
810    }
811    if (dontFlip) {
812      rotateC = -rotateC;
813      rotateD = -rotateD;
814    }
815    var offsetCanvasX, offsetCanvasY;
816    var width, height;
817    if (rotateA === 0) {
818      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
819      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
820      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
821      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
822    } else {
823      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
824      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
825      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
826      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
827    }
828    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
829    this.width = width;
830    this.height = height;
831    this.fontScale = scale;
832  }
833  PageViewport.prototype = {
834    clone: function PageViewPort_clone(args) {
835      args = args || {};
836      var scale = 'scale' in args ? args.scale : this.scale;
837      var rotation = 'rotation' in args ? args.rotation : this.rotation;
838      return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip);
839    },
840    convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
841      return Util.applyTransform([x, y], this.transform);
842    },
843    convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) {
844      var tl = Util.applyTransform([rect[0], rect[1]], this.transform);
845      var br = Util.applyTransform([rect[2], rect[3]], this.transform);
846      return [tl[0], tl[1], br[0], br[1]];
847    },
848    convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
849      return Util.applyInverseTransform([x, y], this.transform);
850    }
851  };
852  return PageViewport;
853}();
854var PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
855function stringToPDFString(str) {
856  var i,
857      n = str.length,
858      strBuf = [];
859  if (str[0] === '\xFE' && str[1] === '\xFF') {
860    for (i = 2; i < n; i += 2) {
861      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
862    }
863  } else {
864    for (i = 0; i < n; ++i) {
865      var code = PDFStringTranslateTable[str.charCodeAt(i)];
866      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
867    }
868  }
869  return strBuf.join('');
870}
871function stringToUTF8String(str) {
872  return decodeURIComponent(escape(str));
873}
874function utf8StringToString(str) {
875  return unescape(encodeURIComponent(str));
876}
877function isEmptyObj(obj) {
878  for (var key in obj) {
879    return false;

1250        sendStreamRequest({
1251          stream: 'error',
1252          reason: reason
1253        });
1254      },
1255
1256      sinkCapability: capability,
1257      onPull: null,
1258      onCancel: null,
1259      isCancelled: false,
1260      desiredSize: desiredSize,
1261      ready: null
1262    };
1263    streamSink.sinkCapability.resolve();
1264    streamSink.ready = streamSink.sinkCapability.promise;
1265    this.streamSinks[streamId] = streamSink;
1266    resolveCall(action[0], [data.data, streamSink], action[1]).then(function () {
1267      sendStreamRequest({
1268        stream: 'start_complete',
1269        success: true
1270      });
1271    }, function (reason) {
1272      sendStreamRequest({
1273        stream: 'start_complete',
1274        success: false,
1275        reason: reason
1276      });
1277    });
1278  },
1279  _processStreamMessage: function _processStreamMessage(data) {
1280    var _this4 = this;
1281
1282    var sourceName = this.sourceName;
1283    var targetName = data.sourceName;
1284    var streamId = data.streamId;
1285    var sendStreamResponse = function sendStreamResponse(_ref2) {
1286      var stream = _ref2.stream,
1287          success = _ref2.success,
1288          reason = _ref2.reason;
1289
1290      _this4.comObj.postMessage({
1291        sourceName: sourceName,
1292        targetName: targetName,
1293        stream: stream,
1294        success: success,
1295        streamId: streamId,
1296        reason: reason
1297      });
1298    };
1299    var deleteStreamController = function deleteStreamController() {
1300      Promise.all([_this4.streamControllers[data.streamId].startCall, _this4.streamControllers[data.streamId].pullCall, _this4.streamControllers[data.streamId].cancelCall].map(function (capability) {
1301        return capability && finalize(capability.promise);
1302      })).then(function () {
1303        delete _this4.streamControllers[data.streamId];
1304      });
1305    };
1306    switch (data.stream) {
1307      case 'start_complete':
1308        resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason));
1309        break;
1310      case 'pull_complete':
1311        resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason));
1312        break;
1313      case 'pull':
1314        if (!this.streamSinks[data.streamId]) {
1315          sendStreamResponse({
1316            stream: 'pull_complete',
1317            success: true
1318          });
1319          break;
1320        }
1321        if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) {
1322          this.streamSinks[data.streamId].sinkCapability.resolve();
1323        }
1324        this.streamSinks[data.streamId].desiredSize = data.desiredSize;
1325        resolveCall(this.streamSinks[data.streamId].onPull).then(function () {
1326          sendStreamResponse({
1327            stream: 'pull_complete',
1328            success: true
1329          });
1330        }, function (reason) {
1331          sendStreamResponse({
1332            stream: 'pull_complete',
1333            success: false,
1334            reason: reason
1335          });
1336        });
1337        break;
1338      case 'enqueue':
1339        assert(this.streamControllers[data.streamId], 'enqueue should have stream controller');
1340        if (!this.streamControllers[data.streamId].isClosed) {
1341          this.streamControllers[data.streamId].controller.enqueue(data.chunk);
1342        }
1343        break;
1344      case 'close':
1345        assert(this.streamControllers[data.streamId], 'close should have stream controller');
1346        if (this.streamControllers[data.streamId].isClosed) {
1347          break;
1348        }
1349        this.streamControllers[data.streamId].isClosed = true;
1350        this.streamControllers[data.streamId].controller.close();
1351        deleteStreamController();
1352        break;
1353      case 'error':
1354        assert(this.streamControllers[data.streamId], 'error should have stream controller');
1355        this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));
1356        deleteStreamController();
1357        break;
1358      case 'cancel_complete':
1359        resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason));
1360        deleteStreamController();
1361        break;
1362      case 'cancel':
1363        if (!this.streamSinks[data.streamId]) {
1364          break;
1365        }
1366        resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(function () {
1367          sendStreamResponse({
1368            stream: 'cancel_complete',
1369            success: true
1370          });
1371        }, function (reason) {
1372          sendStreamResponse({
1373            stream: 'cancel_complete',
1374            success: false,
1375            reason: reason
1376          });
1377        });
1378        this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason));
1379        this.streamSinks[data.streamId].isCancelled = true;
1380        delete this.streamSinks[data.streamId];
1381        break;
1382      default:
1383        throw new Error('Unexpected stream case');
1384    }
1385  },
1386  postMessage: function postMessage(message, transfers) {
1387    if (transfers && this.postMessageTransfers) {
1388      this.comObj.postMessage(message, transfers);
1389    } else {
1390      this.comObj.postMessage(message);
1391    }
1392  },
1393  destroy: function destroy() {
1394    this.comObj.removeEventListener('message', this._onComObjOnMessage);
1395  }
1396};
1397function loadJpegStream(id, imageUrl, objs) {
1398  var img = new Image();
1399  img.onload = function loadJpegStream_onloadClosure() {
1400    objs.resolve(id, img);
1401  };
1402  img.onerror = function loadJpegStream_onerrorClosure() {
1403    objs.resolve(id, null);
1404    warn('Error during JPEG image loading');
1405  };
1406  img.src = imageUrl;
1407}
1408exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
1409exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
1410exports.OPS = OPS;
1411exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
1412exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1413exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
1414exports.AnnotationFieldFlag = AnnotationFieldFlag;
1415exports.AnnotationFlag = AnnotationFlag;
1416exports.AnnotationType = AnnotationType;
1417exports.FontType = FontType;
1418exports.ImageKind = ImageKind;
1419exports.CMapCompressionType = CMapCompressionType;
1420exports.AbortException = AbortException;
1421exports.InvalidPDFException = InvalidPDFException;
1422exports.MessageHandler = MessageHandler;
1423exports.MissingDataException = MissingDataException;
1424exports.MissingPDFException = MissingPDFException;
1425exports.NativeImageDecoding = NativeImageDecoding;
1426exports.NotImplementedException = NotImplementedException;
1427exports.PageViewport = PageViewport;
1428exports.PasswordException = PasswordException;
1429exports.PasswordResponses = PasswordResponses;
1430exports.StatTimer = StatTimer;
1431exports.StreamType = StreamType;
1432exports.TextRenderingMode = TextRenderingMode;
1433exports.UnexpectedResponseException = UnexpectedResponseException;
1434exports.UnknownErrorException = UnknownErrorException;
1435exports.Util = Util;
1436exports.XRefParseException = XRefParseException;
1437exports.FormatError = FormatError;
1438exports.arrayByteLength = arrayByteLength;
1439exports.arraysToBytes = arraysToBytes;
1440exports.assert = assert;
1441exports.bytesToString = bytesToString;
1442exports.createBlob = createBlob;
1443exports.createPromiseCapability = createPromiseCapability;
1444exports.createObjectURL = createObjectURL;
1445exports.deprecated = deprecated;
1446exports.getLookupTableFactory = getLookupTableFactory;
1447exports.getVerbosityLevel = getVerbosityLevel;
1448exports.info = info;
1449exports.isArrayBuffer = isArrayBuffer;
1450exports.isBool = isBool;
1451exports.isEmptyObj = isEmptyObj;
1452exports.isNum = isNum;
1453exports.isString = isString;
1454exports.isSpace = isSpace;
1455exports.isNodeJS = isNodeJS;
1456exports.isSameOrigin = isSameOrigin;
1457exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
1458exports.isLittleEndian = isLittleEndian;
1459exports.isEvalSupported = isEvalSupported;
1460exports.loadJpegStream = loadJpegStream;
1461exports.log2 = log2;
1462exports.readInt8 = readInt8;
1463exports.readUint16 = readUint16;
1464exports.readUint32 = readUint32;
1465exports.removeNullCharacters = removeNullCharacters;
1466exports.ReadableStream = _streams_polyfill.ReadableStream;
1467exports.setVerbosityLevel = setVerbosityLevel;
1468exports.shadow = shadow;
1469exports.string32 = string32;
1470exports.stringToBytes = stringToBytes;
1471exports.stringToPDFString = stringToPDFString;
1472exports.stringToUTF8String = stringToUTF8String;
1473exports.utf8StringToString = utf8StringToString;
1474exports.warn = warn;
1475exports.unreachable = unreachable;
1476
1477/***/ }),
1478/* 1 */
1479/***/ (function(module, exports, __w_pdfjs_require__) {
1480
1481"use strict";
1482
1483
1484var store = __w_pdfjs_require__(51)('wks');
1485var uid = __w_pdfjs_require__(14);
1486var _Symbol = __w_pdfjs_require__(3).Symbol;
1487var USE_SYMBOL = typeof _Symbol == 'function';

1872    this.buffer = emptyBuffer;
1873    this.minBufferLength = 512;
1874    if (maybeMinBufferLength) {
1875      while (this.minBufferLength < maybeMinBufferLength) {
1876        this.minBufferLength *= 2;
1877      }
1878    }
1879  }
1880  DecodeStream.prototype = {
1881    get isEmpty() {
1882      while (!this.eof && this.bufferLength === 0) {
1883        this.readBlock();
1884      }
1885      return this.bufferLength === 0;
1886    },
1887    ensureBuffer: function DecodeStream_ensureBuffer(requested) {
1888      var buffer = this.buffer;
1889      if (requested <= buffer.byteLength) {
1890        return buffer;
1891      }
1892      var size = this.minBufferLength;
1893      while (size < requested) {
1894        size *= 2;
1895      }
1896      var buffer2 = new Uint8Array(size);
1897      buffer2.set(buffer);
1898      return this.buffer = buffer2;
1899    },
1900    getByte: function DecodeStream_getByte() {
1901      var pos = this.pos;
1902      while (this.bufferLength <= pos) {
1903        if (this.eof) {
1904          return -1;
1905        }
1906        this.readBlock();
1907      }
1908      return this.buffer[this.pos++];
1909    },
1910    getUint16: function DecodeStream_getUint16() {
1911      var b0 = this.getByte();
1912      var b1 = this.getByte();
1913      if (b0 === -1 || b1 === -1) {
1914        return -1;
1915      }
1916      return (b0 << 8) + b1;
1917    },
1918    getInt32: function DecodeStream_getInt32() {
1919      var b0 = this.getByte();
1920      var b1 = this.getByte();
1921      var b2 = this.getByte();
1922      var b3 = this.getByte();
1923      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1924    },
1925    getBytes: function DecodeStream_getBytes(length) {
1926      var end,
1927          pos = this.pos;
1928      if (length) {
1929        this.ensureBuffer(pos + length);
1930        end = pos + length;
1931        while (!this.eof && this.bufferLength < end) {
1932          this.readBlock();
1933        }
1934        var bufEnd = this.bufferLength;
1935        if (end > bufEnd) {
1936          end = bufEnd;
1937        }
1938      } else {
1939        while (!this.eof) {
1940          this.readBlock();
1941        }
1942        end = this.bufferLength;
1943      }
1944      this.pos = end;
1945      return this.buffer.subarray(pos, end);
1946    },
1947    peekByte: function DecodeStream_peekByte() {
1948      var peekedByte = this.getByte();
1949      this.pos--;
1950      return peekedByte;
1951    },
1952    peekBytes: function DecodeStream_peekBytes(length) {
1953      var bytes = this.getBytes(length);
1954      this.pos -= bytes.length;
1955      return bytes;
1956    },
1957    makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
1958      var end = start + length;
1959      while (this.bufferLength <= end && !this.eof) {
1960        this.readBlock();
1961      }
1962      return new Stream(this.buffer, start, length, dict);
1963    },
1964    skip: function DecodeStream_skip(n) {
1965      if (!n) {
1966        n = 1;
1967      }
1968      this.pos += n;
1969    },
1970    reset: function DecodeStream_reset() {
1971      this.pos = 0;
1972    },
1973    getBaseStreams: function DecodeStream_getBaseStreams() {
1974      if (this.str && this.str.getBaseStreams) {
1975        return this.str.getBaseStreams();
1976      }
1977      return [];
1978    }
1979  };
1980  return DecodeStream;
1981}();
1982var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
1983  function StreamsSequenceStream(streams) {
1984    this.streams = streams;
1985    DecodeStream.call(this, null);
1986  }
1987  StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
1988  StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
1989    var streams = this.streams;
1990    if (streams.length === 0) {
1991      this.eof = true;
1992      return;
1993    }
1994    var stream = streams.shift();
1995    var chunk = stream.getBytes();
1996    var bufferLength = this.bufferLength;
1997    var newLength = bufferLength + chunk.length;
1998    var buffer = this.ensureBuffer(newLength);
1999    buffer.set(chunk, bufferLength);
2000    this.bufferLength = newLength;
2001  };
2002  StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
2003    var baseStreams = [];
2004    for (var i = 0, ii = this.streams.length; i < ii; i++) {
2005      var stream = this.streams[i];
2006      if (stream.getBaseStreams) {
2007        _util.Util.appendToArray(baseStreams, stream.getBaseStreams());
2008      }
2009    }
2010    return baseStreams;
2011  };
2012  return StreamsSequenceStream;
2013}();
2014var FlateStream = function FlateStreamClosure() {
2015  var codeLenCodeMap = new Int32Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
2016  var lengthDecode = new Int32Array([0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a, 0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f, 0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073, 0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102]);
2017  var distDecode = new Int32Array([0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d, 0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1, 0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01, 0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001]);

20180x900f7, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf, 0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef, 0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df, 0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff]), 9];
2019  var fixedDistCodeTab = [new Int32Array([0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c, 0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000, 0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d, 0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000]), 5];
2020  function FlateStream(str, maybeLength) {
2021    this.str = str;
2022    this.dict = str.dict;
2023    var cmf = str.getByte();
2024    var flg = str.getByte();
2025    if (cmf === -1 || flg === -1) {
2026      throw new _util.FormatError('Invalid header in flate stream: ' + cmf + ', ' + flg);
2027    }
2028    if ((cmf & 0x0f) !== 0x08) {
2029      throw new _util.FormatError('Unknown compression method in flate stream: ' + cmf + ', ' + flg);
2030    }
2031    if (((cmf << 8) + flg) % 31 !== 0) {
2032      throw new _util.FormatError('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);
2033    }
2034    if (flg & 0x20) {
2035      throw new _util.FormatError('FDICT bit set in flate stream: ' + cmf + ', ' + flg);
2036    }
2037    this.codeSize = 0;
2038    this.codeBuf = 0;
2039    DecodeStream.call(this, maybeLength);
2040  }
2041  FlateStream.prototype = Object.create(DecodeStream.prototype);
2042  FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
2043    var str = this.str;
2044    var codeSize = this.codeSize;
2045    var codeBuf = this.codeBuf;
2046    var b;
2047    while (codeSize < bits) {
2048      if ((b = str.getByte()) === -1) {
2049        throw new _util.FormatError('Bad encoding in flate stream');
2050      }
2051      codeBuf |= b << codeSize;
2052      codeSize += 8;
2053    }
2054    b = codeBuf & (1 << bits) - 1;
2055    this.codeBuf = codeBuf >> bits;
2056    this.codeSize = codeSize -= bits;
2057    return b;
2058  };
2059  FlateStream.prototype.getCode = function FlateStream_getCode(table) {
2060    var str = this.str;
2061    var codes = table[0];
2062    var maxLen = table[1];
2063    var codeSize = this.codeSize;
2064    var codeBuf = this.codeBuf;
2065    var b;
2066    while (codeSize < maxLen) {
2067      if ((b = str.getByte()) === -1) {
2068        break;
2069      }
2070      codeBuf |= b << codeSize;
2071      codeSize += 8;
2072    }
2073    var code = codes[codeBuf & (1 << maxLen) - 1];
2074    var codeLen = code >> 16;
2075    var codeVal = code & 0xffff;
2076    if (codeLen < 1 || codeSize < codeLen) {
2077      throw new _util.FormatError('Bad encoding in flate stream');
2078    }
2079    this.codeBuf = codeBuf >> codeLen;
2080    this.codeSize = codeSize - codeLen;
2081    return codeVal;
2082  };
2083  FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
2084    var n = lengths.length;
2085    var maxLen = 0;
2086    var i;
2087    for (i = 0; i < n; ++i) {
2088      if (lengths[i] > maxLen) {
2089        maxLen = lengths[i];
2090      }
2091    }
2092    var size = 1 << maxLen;
2093    var codes = new Int32Array(size);
2094    for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
2095      for (var val = 0; val < n; ++val) {
2096        if (lengths[val] === len) {
2097          var code2 = 0;
2098          var t = code;
2099          for (i = 0; i < len; ++i) {
2100            code2 = code2 << 1 | t & 1;
2101            t >>= 1;
2102          }
2103          for (i = code2; i < size; i += skip) {
2104            codes[i] = len << 16 | val;
2105          }
2106          ++code;
2107        }
2108      }
2109    }
2110    return [codes, maxLen];
2111  };
2112  FlateStream.prototype.readBlock = function FlateStream_readBlock() {
2113    var buffer, len;
2114    var str = this.str;
2115    var hdr = this.getBits(3);
2116    if (hdr & 1) {
2117      this.eof = true;
2118    }
2119    hdr >>= 1;
2120    if (hdr === 0) {
2121      var b;
2122      if ((b = str.getByte()) === -1) {
2123        throw new _util.FormatError('Bad block header in flate stream');
2124      }
2125      var blockLen = b;
2126      if ((b = str.getByte()) === -1) {
2127        throw new _util.FormatError('Bad block header in flate stream');
2128      }
2129      blockLen |= b << 8;
2130      if ((b = str.getByte()) === -1) {
2131        throw new _util.FormatError('Bad block header in flate stream');
2132      }
2133      var check = b;
2134      if ((b = str.getByte()) === -1) {
2135        throw new _util.FormatError('Bad block header in flate stream');
2136      }
2137      check |= b << 8;
2138      if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
2139        throw new _util.FormatError('Bad uncompressed block length in flate stream');
2140      }
2141      this.codeBuf = 0;
2142      this.codeSize = 0;
2143      var bufferLength = this.bufferLength;
2144      buffer = this.ensureBuffer(bufferLength + blockLen);
2145      var end = bufferLength + blockLen;
2146      this.bufferLength = end;
2147      if (blockLen === 0) {
2148        if (str.peekByte() === -1) {
2149          this.eof = true;
2150        }
2151      } else {
2152        for (var n = bufferLength; n < end; ++n) {
2153          if ((b = str.getByte()) === -1) {
2154            this.eof = true;
2155            break;
2156          }
2157          buffer[n] = b;
2158        }
2159      }
2160      return;
2161    }
2162    var litCodeTable;
2163    var distCodeTable;
2164    if (hdr === 1) {

2165      litCodeTable = fixedLitCodeTab;
2166      distCodeTable = fixedDistCodeTab;
2167    } else if (hdr === 2) {
2168      var numLitCodes = this.getBits(5) + 257;
2169      var numDistCodes = this.getBits(5) + 1;
2170      var numCodeLenCodes = this.getBits(4) + 4;
2171      var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
2172      var i;
2173      for (i = 0; i < numCodeLenCodes; ++i) {
2174        codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
2175      }
2176      var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
2177      len = 0;
2178      i = 0;
2179      var codes = numLitCodes + numDistCodes;
2180      var codeLengths = new Uint8Array(codes);
2181      var bitsLength, bitsOffset, what;
2182      while (i < codes) {
2183        var code = this.getCode(codeLenCodeTab);
2184        if (code === 16) {
2185          bitsLength = 2;
2186          bitsOffset = 3;
2187          what = len;
2188        } else if (code === 17) {
2189          bitsLength = 3;
2190          bitsOffset = 3;
2191          what = len = 0;
2192        } else if (code === 18) {
2193          bitsLength = 7;
2194          bitsOffset = 11;
2195          what = len = 0;
2196        } else {
2197          codeLengths[i++] = len = code;
2198          continue;
2199        }
2200        var repeatLength = this.getBits(bitsLength) + bitsOffset;
2201        while (repeatLength-- > 0) {
2202          codeLengths[i++] = what;
2203        }
2204      }
2205      litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
2206      distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
2207    } else {
2208      throw new _util.FormatError('Unknown block type in flate stream');
2209    }
2210    buffer = this.buffer;
2211    var limit = buffer ? buffer.length : 0;
2212    var pos = this.bufferLength;
2213    while (true) {
2214      var code1 = this.getCode(litCodeTable);
2215      if (code1 < 256) {
2216        if (pos + 1 >= limit) {
2217          buffer = this.ensureBuffer(pos + 1);
2218          limit = buffer.length;
2219        }
2220        buffer[pos++] = code1;
2221        continue;
2222      }
2223      if (code1 === 256) {
2224        this.bufferLength = pos;
2225        return;
2226      }
2227      code1 -= 257;
2228      code1 = lengthDecode[code1];
2229      var code2 = code1 >> 16;
2230      if (code2 > 0) {
2231        code2 = this.getBits(code2);
2232      }
2233      len = (code1 & 0xffff) + code2;
2234      code1 = this.getCode(distCodeTable);
2235      code1 = distDecode[code1];
2236      code2 = code1 >> 16;
2237      if (code2 > 0) {
2238        code2 = this.getBits(code2);
2239      }
2240      var dist = (code1 & 0xffff) + code2;
2241      if (pos + len >= limit) {
2242        buffer = this.ensureBuffer(pos + len);
2243        limit = buffer.length;
2244      }
2245      for (var k = 0; k < len; ++k, ++pos) {
2246        buffer[pos] = buffer[pos - dist];
2247      }
2248    }
2249  };
2250  return FlateStream;
2251}();
2252var PredictorStream = function PredictorStreamClosure() {
2253  function PredictorStream(str, maybeLength, params) {
2254    if (!(0, _primitives.isDict)(params)) {
2255      return str;
2256    }
2257    var predictor = this.predictor = params.get('Predictor') || 1;
2258    if (predictor <= 1) {
2259      return str;
2260    }
2261    if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
2262      throw new _util.FormatError('Unsupported predictor: ' + predictor);
2263    }
2264    if (predictor === 2) {
2265      this.readBlock = this.readBlockTiff;
2266    } else {
2267      this.readBlock = this.readBlockPng;
2268    }
2269    this.str = str;
2270    this.dict = str.dict;
2271    var colors = this.colors = params.get('Colors') || 1;
2272    var bits = this.bits = params.get('BitsPerComponent') || 8;
2273    var columns = this.columns = params.get('Columns') || 1;
2274    this.pixBytes = colors * bits + 7 >> 3;
2275    this.rowBytes = columns * colors * bits + 7 >> 3;
2276    DecodeStream.call(this, maybeLength);
2277    return this;
2278  }
2279  PredictorStream.prototype = Object.create(DecodeStream.prototype);
2280  PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
2281    var rowBytes = this.rowBytes;
2282    var bufferLength = this.bufferLength;
2283    var buffer = this.ensureBuffer(bufferLength + rowBytes);
2284    var bits = this.bits;
2285    var colors = this.colors;
2286    var rawBytes = this.str.getBytes(rowBytes);
2287    this.eof = !rawBytes.length;
2288    if (this.eof) {
2289      return;
2290    }
2291    var inbuf = 0,
2292        outbuf = 0;
2293    var inbits = 0,
2294        outbits = 0;
2295    var pos = bufferLength;
2296    var i;
2297    if (bits === 1 && colors === 1) {
2298      for (i = 0; i < rowBytes; ++i) {
2299        var c = rawBytes[i] ^ inbuf;
2300        c ^= c >> 1;
2301        c ^= c >> 2;
2302        c ^= c >> 4;
2303        inbuf = (c & 1) << 7;
2304        buffer[pos++] = c;
2305      }
2306    } else if (bits === 8) {
2307      for (i = 0; i < colors; ++i) {
2308        buffer[pos++] = rawBytes[i];
2309      }
2310      for (; i < rowBytes; ++i) {
2311        buffer[pos] = buffer[pos - colors] + rawBytes[i];
2312        pos++;
2313      }
2314    } else if (bits === 16) {
2315      var bytesPerPixel = colors * 2;
2316      for (i = 0; i < bytesPerPixel; ++i) {
2317        buffer[pos++] = rawBytes[i];
2318      }
2319      for (; i < rowBytes; i += 2) {
2320        var sum = ((rawBytes[i] & 0xFF) << 8) + (rawBytes[i + 1] & 0xFF) + ((buffer[pos - bytesPerPixel] & 0xFF) << 8) + (buffer[pos - bytesPerPixel + 1] & 0xFF);
2321        buffer[pos++] = sum >> 8 & 0xFF;
2322        buffer[pos++] = sum & 0xFF;
2323      }
2324    } else {
2325      var compArray = new Uint8Array(colors + 1);
2326      var bitMask = (1 << bits) - 1;
2327      var j = 0,
2328          k = bufferLength;
2329      var columns = this.columns;
2330      for (i = 0; i < columns; ++i) {
2331        for (var kk = 0; kk < colors; ++kk) {
2332          if (inbits < bits) {
2333            inbuf = inbuf << 8 | rawBytes[j++] & 0xFF;
2334            inbits += 8;
2335          }
2336          compArray[kk] = compArray[kk] + (inbuf >> inbits - bits) & bitMask;
2337          inbits -= bits;
2338          outbuf = outbuf << bits | compArray[kk];
2339          outbits += bits;
2340          if (outbits >= 8) {
2341            buffer[k++] = outbuf >> outbits - 8 & 0xFF;
2342            outbits -= 8;
2343          }
2344        }
2345      }
2346      if (outbits > 0) {
2347        buffer[k++] = (outbuf << 8 - outbits) + (inbuf & (1 << 8 - outbits) - 1);
2348      }
2349    }
2350    this.bufferLength += rowBytes;
2351  };
2352  PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
2353    var rowBytes = this.rowBytes;
2354    var pixBytes = this.pixBytes;
2355    var predictor = this.str.getByte();
2356    var rawBytes = this.str.getBytes(rowBytes);
2357    this.eof = !rawBytes.length;
2358    if (this.eof) {
2359      return;
2360    }
2361    var bufferLength = this.bufferLength;
2362    var buffer = this.ensureBuffer(bufferLength + rowBytes);
2363    var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
2364    if (prevRow.length === 0) {
2365      prevRow = new Uint8Array(rowBytes);
2366    }
2367    var i,
2368        j = bufferLength,
2369        up,
2370        c;
2371    switch (predictor) {
2372      case 0:
2373        for (i = 0; i < rowBytes; ++i) {
2374          buffer[j++] = rawBytes[i];
2375        }
2376        break;
2377      case 1:
2378        for (i = 0; i < pixBytes; ++i) {
2379          buffer[j++] = rawBytes[i];
2380        }
2381        for (; i < rowBytes; ++i) {
2382          buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xFF;
2383          j++;
2384        }
2385        break;
2386      case 2:
2387        for (i = 0; i < rowBytes; ++i) {
2388          buffer[j++] = prevRow[i] + rawBytes[i] & 0xFF;
2389        }
2390        break;
2391      case 3:
2392        for (i = 0; i < pixBytes; ++i) {
2393          buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
2394        }
2395        for (; i < rowBytes; ++i) {
2396          buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xFF;
2397          j++;
2398        }
2399        break;
2400      case 4:
2401        for (i = 0; i < pixBytes; ++i) {
2402          up = prevRow[i];
2403          c = rawBytes[i];
2404          buffer[j++] = up + c;
2405        }
2406        for (; i < rowBytes; ++i) {
2407          up = prevRow[i];
2408          var upLeft = prevRow[i - pixBytes];
2409          var left = buffer[j - pixBytes];
2410          var p = left + up - upLeft;
2411          var pa = p - left;
2412          if (pa < 0) {
2413            pa = -pa;
2414          }
2415          var pb = p - up;
2416          if (pb < 0) {
2417            pb = -pb;
2418          }
2419          var pc = p - upLeft;
2420          if (pc < 0) {
2421            pc = -pc;
2422          }
2423          c = rawBytes[i];
2424          if (pa <= pb && pa <= pc) {
2425            buffer[j++] = left + c;
2426          } else if (pb <= pc) {
2427            buffer[j++] = up + c;
2428          } else {
2429            buffer[j++] = upLeft + c;
2430          }
2431        }
2432        break;
2433      default:
2434        throw new _util.FormatError('Unsupported predictor: ' + predictor);
2435    }
2436    this.bufferLength += rowBytes;
2437  };
2438  return PredictorStream;
2439}();
2440var JpegStream = function JpegStreamClosure() {
2441  function JpegStream(stream, maybeLength, dict, params) {
2442    var ch;
2443    while ((ch = stream.getByte()) !== -1) {
2444      if (ch === 0xFF) {
2445        stream.skip(-1);
2446        break;
2447      }
2448    }
2449    this.stream = stream;
2450    this.maybeLength = maybeLength;
2451    this.dict = dict;
2452    this.params = params;
2453    DecodeStream.call(this, maybeLength);
2454  }
2455  JpegStream.prototype = Object.create(DecodeStream.prototype);
2456  Object.defineProperty(JpegStream.prototype, 'bytes', {
2457    get: function JpegStream_bytes() {
2458      return (0, _util.shadow)(this, 'bytes', this.stream.getBytes(this.maybeLength));
2459    },
2460    configurable: true
2461  });
2462  JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) {
2463    if (this.bufferLength) {
2464      return;
2465    }
2466    var jpegImage = new _jpg.JpegImage();
2467    var decodeArr = this.dict.getArray('Decode', 'D');
2468    if (this.forceRGB && Array.isArray(decodeArr)) {
2469      var bitsPerComponent = this.dict.get('BitsPerComponent') || 8;
2470      var decodeArrLength = decodeArr.length;
2471      var transform = new Int32Array(decodeArrLength);
2472      var transformNeeded = false;

2615    DecodeStream.call(this, maybeLength);
2616  }
2617  var chunkSize = 512;
2618  DecryptStream.prototype = Object.create(DecodeStream.prototype);
2619  DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
2620    var chunk;
2621    if (this.initialized) {
2622      chunk = this.nextChunk;
2623    } else {
2624      chunk = this.str.getBytes(chunkSize);
2625      this.initialized = true;
2626    }
2627    if (!chunk || chunk.length === 0) {
2628      this.eof = true;
2629      return;
2630    }
2631    this.nextChunk = this.str.getBytes(chunkSize);
2632    var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
2633    var decrypt = this.decrypt;
2634    chunk = decrypt(chunk, !hasMoreData);
2635    var bufferLength = this.bufferLength;
2636    var i,
2637        n = chunk.length;
2638    var buffer = this.ensureBuffer(bufferLength + n);
2639    for (i = 0; i < n; i++) {
2640      buffer[bufferLength++] = chunk[i];
2641    }
2642    this.bufferLength = bufferLength;
2643  };
2644  return DecryptStream;
2645}();
2646var Ascii85Stream = function Ascii85StreamClosure() {
2647  function Ascii85Stream(str, maybeLength) {
2648    this.str = str;
2649    this.dict = str.dict;
2650    this.input = new Uint8Array(5);
2651    if (maybeLength) {
2652      maybeLength = 0.8 * maybeLength;
2653    }
2654    DecodeStream.call(this, maybeLength);
2655  }
2656  Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
2657  Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
2658    var TILDA_CHAR = 0x7E;
2659    var Z_LOWER_CHAR = 0x7A;
2660    var EOF = -1;
2661    var str = this.str;
2662    var c = str.getByte();
2663    while ((0, _util.isSpace)(c)) {
2664      c = str.getByte();
2665    }
2666    if (c === EOF || c === TILDA_CHAR) {
2667      this.eof = true;
2668      return;
2669    }
2670    var bufferLength = this.bufferLength,
2671        buffer;
2672    var i;
2673    if (c === Z_LOWER_CHAR) {
2674      buffer = this.ensureBuffer(bufferLength + 4);
2675      for (i = 0; i < 4; ++i) {
2676        buffer[bufferLength + i] = 0;
2677      }
2678      this.bufferLength += 4;
2679    } else {
2680      var input = this.input;
2681      input[0] = c;
2682      for (i = 1; i < 5; ++i) {
2683        c = str.getByte();
2684        while ((0, _util.isSpace)(c)) {
2685          c = str.getByte();
2686        }
2687        input[i] = c;
2688        if (c === EOF || c === TILDA_CHAR) {
2689          break;
2690        }
2691      }
2692      buffer = this.ensureBuffer(bufferLength + i - 1);
2693      this.bufferLength += i - 1;
2694      if (i < 5) {
2695        for (; i < 5; ++i) {
2696          input[i] = 0x21 + 84;
2697        }
2698        this.eof = true;
2699      }
2700      var t = 0;
2701      for (i = 0; i < 5; ++i) {
2702        t = t * 85 + (input[i] - 0x21);
2703      }
2704      for (i = 3; i >= 0; --i) {
2705        buffer[bufferLength + i] = t & 0xFF;
2706        t >>= 8;
2707      }
2708    }
2709  };
2710  return Ascii85Stream;
2711}();
2712var AsciiHexStream = function AsciiHexStreamClosure() {
2713  function AsciiHexStream(str, maybeLength) {
2714    this.str = str;
2715    this.dict = str.dict;
2716    this.firstDigit = -1;
2717    if (maybeLength) {
2718      maybeLength = 0.5 * maybeLength;
2719    }
2720    DecodeStream.call(this, maybeLength);
2721  }
2722  AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
2723  AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
2724    var UPSTREAM_BLOCK_SIZE = 8000;
2725    var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
2726    if (!bytes.length) {
2727      this.eof = true;
2728      return;
2729    }
2730    var maxDecodeLength = bytes.length + 1 >> 1;
2731    var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
2732    var bufferLength = this.bufferLength;
2733    var firstDigit = this.firstDigit;
2734    for (var i = 0, ii = bytes.length; i < ii; i++) {
2735      var ch = bytes[i],
2736          digit;
2737      if (ch >= 0x30 && ch <= 0x39) {
2738        digit = ch & 0x0F;
2739      } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
2740        digit = (ch & 0x0F) + 9;
2741      } else if (ch === 0x3E) {
2742        this.eof = true;
2743        break;
2744      } else {
2745        continue;
2746      }
2747      if (firstDigit < 0) {
2748        firstDigit = digit;
2749      } else {
2750        buffer[bufferLength++] = firstDigit << 4 | digit;
2751        firstDigit = -1;
2752      }
2753    }
2754    if (firstDigit >= 0 && this.eof) {
2755      buffer[bufferLength++] = firstDigit << 4;
2756      firstDigit = -1;
2757    }
2758    this.firstDigit = firstDigit;
2759    this.bufferLength = bufferLength;
2760  };
2761  return AsciiHexStream;
2762}();
2763var RunLengthStream = function RunLengthStreamClosure() {
2764  function RunLengthStream(str, maybeLength) {
2765    this.str = str;
2766    this.dict = str.dict;
2767    DecodeStream.call(this, maybeLength);
2768  }
2769  RunLengthStream.prototype = Object.create(DecodeStream.prototype);
2770  RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
2771    var repeatHeader = this.str.getBytes(2);
2772    if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
2773      this.eof = true;
2774      return;
2775    }
2776    var buffer;
2777    var bufferLength = this.bufferLength;
2778    var n = repeatHeader[0];
2779    if (n < 128) {
2780      buffer = this.ensureBuffer(bufferLength + n + 1);
2781      buffer[bufferLength++] = repeatHeader[1];
2782      if (n > 0) {
2783        var source = this.str.getBytes(n);
2784        buffer.set(source, bufferLength);
2785        bufferLength += n;
2786      }
2787    } else {
2788      n = 257 - n;
2789      var b = repeatHeader[1];
2790      buffer = this.ensureBuffer(bufferLength + n + 1);
2791      for (var i = 0; i < n; i++) {
2792        buffer[bufferLength++] = b;
2793      }
2794    }
2795    this.bufferLength = bufferLength;
2796  };
2797  return RunLengthStream;
2798}();
2799var CCITTFaxStream = function CCITTFaxStreamClosure() {
2800  var ccittEOL = -2;
2801  var ccittEOF = -1;
2802  var twoDimPass = 0;
2803  var twoDimHoriz = 1;
2804  var twoDimVert0 = 2;
2805  var twoDimVertR1 = 3;
2806  var twoDimVertL1 = 4;
2807  var twoDimVertR2 = 5;
2808  var twoDimVertL2 = 6;
2809  var twoDimVertR3 = 7;
2810  var twoDimVertL3 = 8;