https://www.bus-luneo.com/wp-content/plugins/pdf-embedder/js/pdfjs/pdf.worker.js

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

685    }
686    if (rect[1] > rect[3]) {
687      r[1] = rect[3];
688      r[3] = rect[1];
689    }
690    return r;
691  };
692  Util.intersect = function Util_intersect(rect1, rect2) {
693    function compare(a, b) {
694      return a - b;
695    }
696    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),
697        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
698        result = [];
699    rect1 = Util.normalizeRect(rect1);
700    rect2 = Util.normalizeRect(rect2);
701    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
702      result[0] = orderedX[1];
703      result[2] = orderedX[2];
704    } else {
705      return false;
706    }
707    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
708      result[1] = orderedY[1];
709      result[3] = orderedY[2];
710    } else {
711      return false;
712    }
713    return result;
714  };
715  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'];
716  Util.toRoman = function Util_toRoman(number, lowerCase) {
717    assert(Number.isInteger(number) && number > 0, 'The number should be a positive integer.');
718    var pos,
719        romanBuf = [];
720    while (number >= 1000) {
721      number -= 1000;
722      romanBuf.push('M');
723    }
724    pos = number / 100 | 0;
725    number %= 100;
726    romanBuf.push(ROMAN_NUMBER_MAP[pos]);
727    pos = number / 10 | 0;
728    number %= 10;
729    romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
730    romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
731    var romanStr = romanBuf.join('');
732    return lowerCase ? romanStr.toLowerCase() : romanStr;
733  };
734  Util.appendToArray = function Util_appendToArray(arr1, arr2) {
735    Array.prototype.push.apply(arr1, arr2);
736  };
737  Util.prependToArray = function Util_prependToArray(arr1, arr2) {
738    Array.prototype.unshift.apply(arr1, arr2);
739  };
740  Util.extendObj = function extendObj(obj1, obj2) {
741    for (var key in obj2) {
742      obj1[key] = obj2[key];
743    }
744  };
745  Util.getInheritableProperty = function Util_getInheritableProperty(dict, name, getArray) {
746    while (dict && !dict.has(name)) {
747      dict = dict.get('Parent');
748    }
749    if (!dict) {
750      return null;
751    }
752    return getArray ? dict.getArray(name) : dict.get(name);
753  };
754  Util.inherit = function Util_inherit(sub, base, prototype) {
755    sub.prototype = Object.create(base.prototype);
756    sub.prototype.constructor = sub;
757    for (var prop in prototype) {
758      sub.prototype[prop] = prototype[prop];
759    }
760  };
761  Util.loadScript = function Util_loadScript(src, callback) {
762    var script = document.createElement('script');
763    var loaded = false;
764    script.setAttribute('src', src);
765    if (callback) {
766      script.onload = function () {
767        if (!loaded) {
768          callback();
769        }
770        loaded = true;
771      };
772    }
773    document.getElementsByTagName('head')[0].appendChild(script);
774  };
775  return Util;
776}();
777var PageViewport = function PageViewportClosure() {
778  function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
779    this.viewBox = viewBox;
780    this.scale = scale;
781    this.rotation = rotation;
782    this.offsetX = offsetX;
783    this.offsetY = offsetY;
784    var centerX = (viewBox[2] + viewBox[0]) / 2;
785    var centerY = (viewBox[3] + viewBox[1]) / 2;
786    var rotateA, rotateB, rotateC, rotateD;
787    rotation = rotation % 360;
788    rotation = rotation < 0 ? rotation + 360 : rotation;
789    switch (rotation) {
790      case 180:
791        rotateA = -1;
792        rotateB = 0;
793        rotateC = 0;
794        rotateD = 1;
795        break;
796      case 90:
797        rotateA = 0;
798        rotateB = 1;
799        rotateC = 1;
800        rotateD = 0;
801        break;
802      case 270:
803        rotateA = 0;
804        rotateB = -1;
805        rotateC = -1;
806        rotateD = 0;
807        break;
808      default:
809        rotateA = 1;
810        rotateB = 0;
811        rotateC = 0;
812        rotateD = -1;
813        break;
814    }
815    if (dontFlip) {
816      rotateC = -rotateC;
817      rotateD = -rotateD;
818    }
819    var offsetCanvasX, offsetCanvasY;
820    var width, height;
821    if (rotateA === 0) {
822      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
823      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
824      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
825      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
826    } else {
827      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
828      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
829      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
830      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
831    }
832    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
833    this.width = width;
834    this.height = height;
835    this.fontScale = scale;
836  }
837  PageViewport.prototype = {
838    clone: function PageViewPort_clone(args) {
839      args = args || {};
840      var scale = 'scale' in args ? args.scale : this.scale;
841      var rotation = 'rotation' in args ? args.rotation : this.rotation;
842      return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip);
843    },
844    convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
845      return Util.applyTransform([x, y], this.transform);
846    },
847    convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) {
848      var tl = Util.applyTransform([rect[0], rect[1]], this.transform);
849      var br = Util.applyTransform([rect[2], rect[3]], this.transform);
850      return [tl[0], tl[1], br[0], br[1]];
851    },
852    convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
853      return Util.applyInverseTransform([x, y], this.transform);
854    }
855  };
856  return PageViewport;
857}();

1194        sendStreamRequest({
1195          stream: 'error',
1196          reason: reason
1197        });
1198      },
1199
1200      sinkCapability: capability,
1201      onPull: null,
1202      onCancel: null,
1203      isCancelled: false,
1204      desiredSize: desiredSize,
1205      ready: null
1206    };
1207    streamSink.sinkCapability.resolve();
1208    streamSink.ready = streamSink.sinkCapability.promise;
1209    this.streamSinks[streamId] = streamSink;
1210    resolveCall(action[0], [data.data, streamSink], action[1]).then(function () {
1211      sendStreamRequest({
1212        stream: 'start_complete',
1213        success: true
1214      });
1215    }, function (reason) {
1216      sendStreamRequest({
1217        stream: 'start_complete',
1218        success: false,
1219        reason: reason
1220      });
1221    });
1222  },
1223  _processStreamMessage: function _processStreamMessage(data) {
1224    var _this4 = this;
1225
1226    var sourceName = this.sourceName;
1227    var targetName = data.sourceName;
1228    var streamId = data.streamId;
1229    var sendStreamResponse = function sendStreamResponse(_ref2) {
1230      var stream = _ref2.stream,
1231          success = _ref2.success,
1232          reason = _ref2.reason;
1233
1234      _this4.comObj.postMessage({
1235        sourceName: sourceName,
1236        targetName: targetName,
1237        stream: stream,
1238        success: success,
1239        streamId: streamId,
1240        reason: reason
1241      });
1242    };
1243    var deleteStreamController = function deleteStreamController() {
1244      Promise.all([_this4.streamControllers[data.streamId].startCall, _this4.streamControllers[data.streamId].pullCall, _this4.streamControllers[data.streamId].cancelCall].map(function (capability) {
1245        return capability && finalize(capability.promise);
1246      })).then(function () {
1247        delete _this4.streamControllers[data.streamId];
1248      });
1249    };
1250    switch (data.stream) {
1251      case 'start_complete':
1252        resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason));
1253        break;
1254      case 'pull_complete':
1255        resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason));
1256        break;
1257      case 'pull':
1258        if (!this.streamSinks[data.streamId]) {
1259          sendStreamResponse({
1260            stream: 'pull_complete',
1261            success: true
1262          });
1263          break;
1264        }
1265        if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) {
1266          this.streamSinks[data.streamId].sinkCapability.resolve();
1267        }
1268        this.streamSinks[data.streamId].desiredSize = data.desiredSize;
1269        resolveCall(this.streamSinks[data.streamId].onPull).then(function () {
1270          sendStreamResponse({
1271            stream: 'pull_complete',
1272            success: true
1273          });
1274        }, function (reason) {
1275          sendStreamResponse({
1276            stream: 'pull_complete',
1277            success: false,
1278            reason: reason
1279          });
1280        });
1281        break;
1282      case 'enqueue':
1283        assert(this.streamControllers[data.streamId], 'enqueue should have stream controller');
1284        if (!this.streamControllers[data.streamId].isClosed) {
1285          this.streamControllers[data.streamId].controller.enqueue(data.chunk);
1286        }
1287        break;
1288      case 'close':
1289        assert(this.streamControllers[data.streamId], 'close should have stream controller');
1290        if (this.streamControllers[data.streamId].isClosed) {
1291          break;
1292        }
1293        this.streamControllers[data.streamId].isClosed = true;
1294        this.streamControllers[data.streamId].controller.close();
1295        deleteStreamController();
1296        break;
1297      case 'error':
1298        assert(this.streamControllers[data.streamId], 'error should have stream controller');
1299        this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));
1300        deleteStreamController();
1301        break;
1302      case 'cancel_complete':
1303        resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason));
1304        deleteStreamController();
1305        break;
1306      case 'cancel':
1307        if (!this.streamSinks[data.streamId]) {
1308          break;
1309        }
1310        resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(function () {
1311          sendStreamResponse({
1312            stream: 'cancel_complete',
1313            success: true
1314          });
1315        }, function (reason) {
1316          sendStreamResponse({
1317            stream: 'cancel_complete',
1318            success: false,
1319            reason: reason
1320          });
1321        });
1322        this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason));
1323        this.streamSinks[data.streamId].isCancelled = true;
1324        delete this.streamSinks[data.streamId];
1325        break;
1326      default:
1327        throw new Error('Unexpected stream case');
1328    }
1329  },
1330  postMessage: function postMessage(message, transfers) {
1331    if (transfers && this.postMessageTransfers) {
1332      this.comObj.postMessage(message, transfers);
1333    } else {
1334      this.comObj.postMessage(message);
1335    }
1336  },
1337  destroy: function destroy() {
1338    this.comObj.removeEventListener('message', this._onComObjOnMessage);
1339  }
1340};
1341function loadJpegStream(id, imageUrl, objs) {
1342  var img = new Image();
1343  img.onload = function loadJpegStream_onloadClosure() {
1344    objs.resolve(id, img);
1345  };
1346  img.onerror = function loadJpegStream_onerrorClosure() {
1347    objs.resolve(id, null);
1348    warn('Error during JPEG image loading');
1349  };
1350  img.src = imageUrl;
1351}
1352exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
1353exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
1354exports.OPS = OPS;
1355exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
1356exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1357exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
1358exports.AnnotationFieldFlag = AnnotationFieldFlag;
1359exports.AnnotationFlag = AnnotationFlag;
1360exports.AnnotationType = AnnotationType;
1361exports.FontType = FontType;
1362exports.ImageKind = ImageKind;
1363exports.CMapCompressionType = CMapCompressionType;
1364exports.AbortException = AbortException;
1365exports.InvalidPDFException = InvalidPDFException;
1366exports.MessageHandler = MessageHandler;
1367exports.MissingDataException = MissingDataException;
1368exports.MissingPDFException = MissingPDFException;
1369exports.NativeImageDecoding = NativeImageDecoding;
1370exports.NotImplementedException = NotImplementedException;
1371exports.PageViewport = PageViewport;
1372exports.PasswordException = PasswordException;
1373exports.PasswordResponses = PasswordResponses;
1374exports.StreamType = StreamType;
1375exports.TextRenderingMode = TextRenderingMode;
1376exports.UnexpectedResponseException = UnexpectedResponseException;
1377exports.UnknownErrorException = UnknownErrorException;
1378exports.Util = Util;
1379exports.XRefParseException = XRefParseException;
1380exports.FormatError = FormatError;
1381exports.arrayByteLength = arrayByteLength;
1382exports.arraysToBytes = arraysToBytes;
1383exports.assert = assert;
1384exports.bytesToString = bytesToString;
1385exports.createBlob = createBlob;
1386exports.createPromiseCapability = createPromiseCapability;
1387exports.createObjectURL = createObjectURL;
1388exports.deprecated = deprecated;
1389exports.getLookupTableFactory = getLookupTableFactory;

1683      return this.end - this.start;
1684    },
1685    get isEmpty() {
1686      return this.length === 0;
1687    },
1688    getByte: function Stream_getByte() {
1689      if (this.pos >= this.end) {
1690        return -1;
1691      }
1692      return this.bytes[this.pos++];
1693    },
1694    getUint16: function Stream_getUint16() {
1695      var b0 = this.getByte();
1696      var b1 = this.getByte();
1697      if (b0 === -1 || b1 === -1) {
1698        return -1;
1699      }
1700      return (b0 << 8) + b1;
1701    },
1702    getInt32: function Stream_getInt32() {
1703      var b0 = this.getByte();
1704      var b1 = this.getByte();
1705      var b2 = this.getByte();
1706      var b3 = this.getByte();
1707      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1708    },
1709    getBytes: function Stream_getBytes(length) {
1710      var bytes = this.bytes;
1711      var pos = this.pos;
1712      var strEnd = this.end;
1713      if (!length) {
1714        return bytes.subarray(pos, strEnd);
1715      }
1716      var end = pos + length;
1717      if (end > strEnd) {
1718        end = strEnd;
1719      }
1720      this.pos = end;
1721      return bytes.subarray(pos, end);
1722    },
1723    peekByte: function Stream_peekByte() {
1724      var peekedByte = this.getByte();
1725      this.pos--;
1726      return peekedByte;
1727    },
1728    peekBytes: function Stream_peekBytes(length) {
1729      var bytes = this.getBytes(length);
1730      this.pos -= bytes.length;
1731      return bytes;
1732    },
1733    skip: function Stream_skip(n) {
1734      if (!n) {
1735        n = 1;
1736      }
1737      this.pos += n;
1738    },
1739    reset: function Stream_reset() {
1740      this.pos = this.start;
1741    },
1742    moveStart: function Stream_moveStart() {
1743      this.start = this.pos;
1744    },
1745    makeSubStream: function Stream_makeSubStream(start, length, dict) {
1746      return new Stream(this.bytes.buffer, start, length, dict);
1747    }
1748  };
1749  return Stream;
1750}();
1751var StringStream = function StringStreamClosure() {
1752  function StringStream(str) {
1753    var bytes = (0, _util.stringToBytes)(str);
1754    Stream.call(this, bytes);
1755  }
1756  StringStream.prototype = Stream.prototype;
1757  return StringStream;
1758}();
1759var DecodeStream = function DecodeStreamClosure() {
1760  var emptyBuffer = new Uint8Array(0);
1761  function DecodeStream(maybeMinBufferLength) {
1762    this.pos = 0;
1763    this.bufferLength = 0;
1764    this.eof = false;
1765    this.buffer = emptyBuffer;
1766    this.minBufferLength = 512;
1767    if (maybeMinBufferLength) {
1768      while (this.minBufferLength < maybeMinBufferLength) {
1769        this.minBufferLength *= 2;
1770      }
1771    }
1772  }
1773  DecodeStream.prototype = {
1774    get isEmpty() {
1775      while (!this.eof && this.bufferLength === 0) {
1776        this.readBlock();
1777      }
1778      return this.bufferLength === 0;
1779    },
1780    ensureBuffer: function DecodeStream_ensureBuffer(requested) {
1781      var buffer = this.buffer;
1782      if (requested <= buffer.byteLength) {
1783        return buffer;
1784      }
1785      var size = this.minBufferLength;
1786      while (size < requested) {
1787        size *= 2;
1788      }
1789      var buffer2 = new Uint8Array(size);
1790      buffer2.set(buffer);
1791      return this.buffer = buffer2;
1792    },
1793    getByte: function DecodeStream_getByte() {
1794      var pos = this.pos;
1795      while (this.bufferLength <= pos) {
1796        if (this.eof) {
1797          return -1;
1798        }
1799        this.readBlock();
1800      }
1801      return this.buffer[this.pos++];
1802    },
1803    getUint16: function DecodeStream_getUint16() {
1804      var b0 = this.getByte();
1805      var b1 = this.getByte();
1806      if (b0 === -1 || b1 === -1) {
1807        return -1;
1808      }
1809      return (b0 << 8) + b1;
1810    },
1811    getInt32: function DecodeStream_getInt32() {
1812      var b0 = this.getByte();
1813      var b1 = this.getByte();
1814      var b2 = this.getByte();
1815      var b3 = this.getByte();
1816      return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1817    },
1818    getBytes: function DecodeStream_getBytes(length) {
1819      var end,
1820          pos = this.pos;
1821      if (length) {
1822        this.ensureBuffer(pos + length);
1823        end = pos + length;
1824        while (!this.eof && this.bufferLength < end) {
1825          this.readBlock();
1826        }
1827        var bufEnd = this.bufferLength;
1828        if (end > bufEnd) {
1829          end = bufEnd;
1830        }
1831      } else {
1832        while (!this.eof) {
1833          this.readBlock();
1834        }
1835        end = this.bufferLength;
1836      }
1837      this.pos = end;
1838      return this.buffer.subarray(pos, end);
1839    },
1840    peekByte: function DecodeStream_peekByte() {
1841      var peekedByte = this.getByte();
1842      this.pos--;
1843      return peekedByte;
1844    },
1845    peekBytes: function DecodeStream_peekBytes(length) {
1846      var bytes = this.getBytes(length);
1847      this.pos -= bytes.length;
1848      return bytes;
1849    },
1850    makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
1851      var end = start + length;
1852      while (this.bufferLength <= end && !this.eof) {
1853        this.readBlock();
1854      }
1855      return new Stream(this.buffer, start, length, dict);
1856    },
1857    skip: function DecodeStream_skip(n) {
1858      if (!n) {
1859        n = 1;
1860      }
1861      this.pos += n;
1862    },
1863    reset: function DecodeStream_reset() {
1864      this.pos = 0;
1865    },
1866    getBaseStreams: function DecodeStream_getBaseStreams() {
1867      if (this.str && this.str.getBaseStreams) {
1868        return this.str.getBaseStreams();
1869      }
1870      return [];
1871    }
1872  };
1873  return DecodeStream;
1874}();
1875var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
1876  function StreamsSequenceStream(streams) {
1877    this.streams = streams;
1878    DecodeStream.call(this, null);
1879  }
1880  StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
1881  StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
1882    var streams = this.streams;
1883    if (streams.length === 0) {
1884      this.eof = true;
1885      return;
1886    }
1887    var stream = streams.shift();
1888    var chunk = stream.getBytes();
1889    var bufferLength = this.bufferLength;
1890    var newLength = bufferLength + chunk.length;
1891    var buffer = this.ensureBuffer(newLength);
1892    buffer.set(chunk, bufferLength);
1893    this.bufferLength = newLength;
1894  };
1895  StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
1896    var baseStreams = [];
1897    for (var i = 0, ii = this.streams.length; i < ii; i++) {
1898      var stream = this.streams[i];
1899      if (stream.getBaseStreams) {
1900        _util.Util.appendToArray(baseStreams, stream.getBaseStreams());
1901      }
1902    }
1903    return baseStreams;
1904  };
1905  return StreamsSequenceStream;
1906}();
1907var FlateStream = function FlateStreamClosure() {
1908  var codeLenCodeMap = new Int32Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
1909  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]);
1910  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]);
1911  var fixedLitCodeTab = [new Int32Array([0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0, 0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0, 0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0, 0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8, 0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8, 0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8, 0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4, 0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4, 0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4, 0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc, 0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec, 0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc, 0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2, 0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2, 0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2, 0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca, 0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea, 0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da, 0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6, 0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6, 0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6, 0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce, 0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee, 0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de, 0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe, 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1, 0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1, 0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1, 0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9, 0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9, 0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9, 0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5, 0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5, 0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5, 0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd, 0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed, 0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd, 0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3, 0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3, 0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3, 0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb, 0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb, 0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db, 0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7, 0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7, 0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7, 0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 

19110x900f7, 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];
1912  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];
1913  function FlateStream(str, maybeLength) {
1914    this.str = str;
1915    this.dict = str.dict;
1916    var cmf = str.getByte();
1917    var flg = str.getByte();
1918    if (cmf === -1 || flg === -1) {
1919      throw new _util.FormatError('Invalid header in flate stream: ' + cmf + ', ' + flg);
1920    }
1921    if ((cmf & 0x0f) !== 0x08) {
1922      throw new _util.FormatError('Unknown compression method in flate stream: ' + cmf + ', ' + flg);
1923    }
1924    if (((cmf << 8) + flg) % 31 !== 0) {
1925      throw new _util.FormatError('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);
1926    }
1927    if (flg & 0x20) {
1928      throw new _util.FormatError('FDICT bit set in flate stream: ' + cmf + ', ' + flg);
1929    }
1930    this.codeSize = 0;
1931    this.codeBuf = 0;
1932    DecodeStream.call(this, maybeLength);
1933  }
1934  FlateStream.prototype = Object.create(DecodeStream.prototype);
1935  FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
1936    var str = this.str;
1937    var codeSize = this.codeSize;
1938    var codeBuf = this.codeBuf;
1939    var b;
1940    while (codeSize < bits) {
1941      if ((b = str.getByte()) === -1) {
1942        throw new _util.FormatError('Bad encoding in flate stream');
1943      }
1944      codeBuf |= b << codeSize;
1945      codeSize += 8;
1946    }
1947    b = codeBuf & (1 << bits) - 1;
1948    this.codeBuf = codeBuf >> bits;
1949    this.codeSize = codeSize -= bits;
1950    return b;
1951  };
1952  FlateStream.prototype.getCode = function FlateStream_getCode(table) {
1953    var str = this.str;
1954    var codes = table[0];
1955    var maxLen = table[1];
1956    var codeSize = this.codeSize;
1957    var codeBuf = this.codeBuf;
1958    var b;
1959    while (codeSize < maxLen) {
1960      if ((b = str.getByte()) === -1) {
1961        break;
1962      }
1963      codeBuf |= b << codeSize;
1964      codeSize += 8;
1965    }
1966    var code = codes[codeBuf & (1 << maxLen) - 1];
1967    var codeLen = code >> 16;
1968    var codeVal = code & 0xffff;
1969    if (codeLen < 1 || codeSize < codeLen) {
1970      throw new _util.FormatError('Bad encoding in flate stream');
1971    }
1972    this.codeBuf = codeBuf >> codeLen;
1973    this.codeSize = codeSize - codeLen;
1974    return codeVal;
1975  };
1976  FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
1977    var n = lengths.length;
1978    var maxLen = 0;
1979    var i;
1980    for (i = 0; i < n; ++i) {
1981      if (lengths[i] > maxLen) {
1982        maxLen = lengths[i];
1983      }
1984    }
1985    var size = 1 << maxLen;
1986    var codes = new Int32Array(size);
1987    for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
1988      for (var val = 0; val < n; ++val) {
1989        if (lengths[val] === len) {
1990          var code2 = 0;
1991          var t = code;
1992          for (i = 0; i < len; ++i) {
1993            code2 = code2 << 1 | t & 1;
1994            t >>= 1;
1995          }
1996          for (i = code2; i < size; i += skip) {
1997            codes[i] = len << 16 | val;
1998          }
1999          ++code;
2000        }
2001      }
2002    }
2003    return [codes, maxLen];
2004  };
2005  FlateStream.prototype.readBlock = function FlateStream_readBlock() {
2006    var buffer, len;
2007    var str = this.str;
2008    var hdr = this.getBits(3);
2009    if (hdr & 1) {
2010      this.eof = true;
2011    }
2012    hdr >>= 1;
2013    if (hdr === 0) {
2014      var b;
2015      if ((b = str.getByte()) === -1) {
2016        throw new _util.FormatError('Bad block header in flate stream');
2017      }
2018      var blockLen = b;
2019      if ((b = str.getByte()) === -1) {
2020        throw new _util.FormatError('Bad block header in flate stream');
2021      }
2022      blockLen |= b << 8;
2023      if ((b = str.getByte()) === -1) {
2024        throw new _util.FormatError('Bad block header in flate stream');
2025      }
2026      var check = b;
2027      if ((b = str.getByte()) === -1) {
2028        throw new _util.FormatError('Bad block header in flate stream');
2029      }
2030      check |= b << 8;
2031      if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
2032        throw new _util.FormatError('Bad uncompressed block length in flate stream');
2033      }
2034      this.codeBuf = 0;
2035      this.codeSize = 0;
2036      var bufferLength = this.bufferLength;
2037      buffer = this.ensureBuffer(bufferLength + blockLen);
2038      var end = bufferLength + blockLen;
2039      this.bufferLength = end;
2040      if (blockLen === 0) {
2041        if (str.peekByte() === -1) {
2042          this.eof = true;
2043        }
2044      } else {
2045        for (var n = bufferLength; n < end; ++n) {
2046          if ((b = str.getByte()) === -1) {
2047            this.eof = true;
2048            break;
2049          }
2050          buffer[n] = b;
2051        }
2052      }
2053      return;
2054    }
2055    var litCodeTable;
2056    var distCodeTable;
2057    if (hdr === 1) {

2058      litCodeTable = fixedLitCodeTab;
2059      distCodeTable = fixedDistCodeTab;
2060    } else if (hdr === 2) {
2061      var numLitCodes = this.getBits(5) + 257;
2062      var numDistCodes = this.getBits(5) + 1;
2063      var numCodeLenCodes = this.getBits(4) + 4;
2064      var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
2065      var i;
2066      for (i = 0; i < numCodeLenCodes; ++i) {
2067        codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
2068      }
2069      var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
2070      len = 0;
2071      i = 0;
2072      var codes = numLitCodes + numDistCodes;
2073      var codeLengths = new Uint8Array(codes);
2074      var bitsLength, bitsOffset, what;
2075      while (i < codes) {
2076        var code = this.getCode(codeLenCodeTab);
2077        if (code === 16) {
2078          bitsLength = 2;
2079          bitsOffset = 3;
2080          what = len;
2081        } else if (code === 17) {
2082          bitsLength = 3;
2083          bitsOffset = 3;
2084          what = len = 0;
2085        } else if (code === 18) {
2086          bitsLength = 7;
2087          bitsOffset = 11;
2088          what = len = 0;
2089        } else {
2090          codeLengths[i++] = len = code;
2091          continue;
2092        }
2093        var repeatLength = this.getBits(bitsLength) + bitsOffset;
2094        while (repeatLength-- > 0) {
2095          codeLengths[i++] = what;
2096        }
2097      }
2098      litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
2099      distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
2100    } else {
2101      throw new _util.FormatError('Unknown block type in flate stream');
2102    }
2103    buffer = this.buffer;
2104    var limit = buffer ? buffer.length : 0;
2105    var pos = this.bufferLength;
2106    while (true) {
2107      var code1 = this.getCode(litCodeTable);
2108      if (code1 < 256) {
2109        if (pos + 1 >= limit) {
2110          buffer = this.ensureBuffer(pos + 1);
2111          limit = buffer.length;
2112        }
2113        buffer[pos++] = code1;
2114        continue;
2115      }
2116      if (code1 === 256) {
2117        this.bufferLength = pos;
2118        return;
2119      }
2120      code1 -= 257;
2121      code1 = lengthDecode[code1];
2122      var code2 = code1 >> 16;
2123      if (code2 > 0) {
2124        code2 = this.getBits(code2);
2125      }
2126      len = (code1 & 0xffff) + code2;
2127      code1 = this.getCode(distCodeTable);
2128      code1 = distDecode[code1];
2129      code2 = code1 >> 16;
2130      if (code2 > 0) {
2131        code2 = this.getBits(code2);
2132      }
2133      var dist = (code1 & 0xffff) + code2;
2134      if (pos + len >= limit) {
2135        buffer = this.ensureBuffer(pos + len);
2136        limit = buffer.length;
2137      }
2138      for (var k = 0; k < len; ++k, ++pos) {
2139        buffer[pos] = buffer[pos - dist];
2140      }
2141    }
2142  };
2143  return FlateStream;
2144}();
2145var PredictorStream = function PredictorStreamClosure() {
2146  function PredictorStream(str, maybeLength, params) {
2147    if (!(0, _primitives.isDict)(params)) {
2148      return str;
2149    }
2150    var predictor = this.predictor = params.get('Predictor') || 1;
2151    if (predictor <= 1) {
2152      return str;
2153    }
2154    if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
2155      throw new _util.FormatError('Unsupported predictor: ' + predictor);
2156    }
2157    if (predictor === 2) {
2158      this.readBlock = this.readBlockTiff;
2159    } else {
2160      this.readBlock = this.readBlockPng;
2161    }
2162    this.str = str;
2163    this.dict = str.dict;
2164    var colors = this.colors = params.get('Colors') || 1;
2165    var bits = this.bits = params.get('BitsPerComponent') || 8;
2166    var columns = this.columns = params.get('Columns') || 1;
2167    this.pixBytes = colors * bits + 7 >> 3;
2168    this.rowBytes = columns * colors * bits + 7 >> 3;
2169    DecodeStream.call(this, maybeLength);
2170    return this;
2171  }
2172  PredictorStream.prototype = Object.create(DecodeStream.prototype);
2173  PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
2174    var rowBytes = this.rowBytes;
2175    var bufferLength = this.bufferLength;
2176    var buffer = this.ensureBuffer(bufferLength + rowBytes);
2177    var bits = this.bits;
2178    var colors = this.colors;
2179    var rawBytes = this.str.getBytes(rowBytes);
2180    this.eof = !rawBytes.length;
2181    if (this.eof) {
2182      return;
2183    }
2184    var inbuf = 0,
2185        outbuf = 0;
2186    var inbits = 0,
2187        outbits = 0;
2188    var pos = bufferLength;
2189    var i;
2190    if (bits === 1 && colors === 1) {
2191      for (i = 0; i < rowBytes; ++i) {
2192        var c = rawBytes[i] ^ inbuf;
2193        c ^= c >> 1;
2194        c ^= c >> 2;
2195        c ^= c >> 4;
2196        inbuf = (c & 1) << 7;
2197        buffer[pos++] = c;
2198      }
2199    } else if (bits === 8) {
2200      for (i = 0; i < colors; ++i) {
2201        buffer[pos++] = rawBytes[i];
2202      }
2203      for (; i < rowBytes; ++i) {
2204        buffer[pos] = buffer[pos - colors] + rawBytes[i];
2205        pos++;
2206      }
2207    } else if (bits === 16) {
2208      var bytesPerPixel = colors * 2;
2209      for (i = 0; i < bytesPerPixel; ++i) {
2210        buffer[pos++] = rawBytes[i];
2211      }
2212      for (; i < rowBytes; i += 2) {
2213        var sum = ((rawBytes[i] & 0xFF) << 8) + (rawBytes[i + 1] & 0xFF) + ((buffer[pos - bytesPerPixel] & 0xFF) << 8) + (buffer[pos - bytesPerPixel + 1] & 0xFF);
2214        buffer[pos++] = sum >> 8 & 0xFF;
2215        buffer[pos++] = sum & 0xFF;
2216      }
2217    } else {
2218      var compArray = new Uint8Array(colors + 1);
2219      var bitMask = (1 << bits) - 1;
2220      var j = 0,
2221          k = bufferLength;
2222      var columns = this.columns;
2223      for (i = 0; i < columns; ++i) {
2224        for (var kk = 0; kk < colors; ++kk) {
2225          if (inbits < bits) {
2226            inbuf = inbuf << 8 | rawBytes[j++] & 0xFF;
2227            inbits += 8;
2228          }
2229          compArray[kk] = compArray[kk] + (inbuf >> inbits - bits) & bitMask;
2230          inbits -= bits;
2231          outbuf = outbuf << bits | compArray[kk];
2232          outbits += bits;
2233          if (outbits >= 8) {
2234            buffer[k++] = outbuf >> outbits - 8 & 0xFF;
2235            outbits -= 8;
2236          }
2237        }
2238      }
2239      if (outbits > 0) {
2240        buffer[k++] = (outbuf << 8 - outbits) + (inbuf & (1 << 8 - outbits) - 1);
2241      }
2242    }
2243    this.bufferLength += rowBytes;
2244  };
2245  PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
2246    var rowBytes = this.rowBytes;
2247    var pixBytes = this.pixBytes;
2248    var predictor = this.str.getByte();
2249    var rawBytes = this.str.getBytes(rowBytes);
2250    this.eof = !rawBytes.length;
2251    if (this.eof) {
2252      return;
2253    }
2254    var bufferLength = this.bufferLength;
2255    var buffer = this.ensureBuffer(bufferLength + rowBytes);
2256    var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
2257    if (prevRow.length === 0) {
2258      prevRow = new Uint8Array(rowBytes);
2259    }
2260    var i,
2261        j = bufferLength,
2262        up,
2263        c;
2264    switch (predictor) {
2265      case 0:
2266        for (i = 0; i < rowBytes; ++i) {
2267          buffer[j++] = rawBytes[i];
2268        }
2269        break;
2270      case 1:
2271        for (i = 0; i < pixBytes; ++i) {
2272          buffer[j++] = rawBytes[i];
2273        }
2274        for (; i < rowBytes; ++i) {
2275          buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xFF;
2276          j++;
2277        }
2278        break;
2279      case 2:
2280        for (i = 0; i < rowBytes; ++i) {
2281          buffer[j++] = prevRow[i] + rawBytes[i] & 0xFF;
2282        }
2283        break;
2284      case 3:
2285        for (i = 0; i < pixBytes; ++i) {
2286          buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
2287        }
2288        for (; i < rowBytes; ++i) {
2289          buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xFF;
2290          j++;
2291        }
2292        break;
2293      case 4:
2294        for (i = 0; i < pixBytes; ++i) {
2295          up = prevRow[i];
2296          c = rawBytes[i];
2297          buffer[j++] = up + c;
2298        }
2299        for (; i < rowBytes; ++i) {
2300          up = prevRow[i];
2301          var upLeft = prevRow[i - pixBytes];
2302          var left = buffer[j - pixBytes];
2303          var p = left + up - upLeft;
2304          var pa = p - left;
2305          if (pa < 0) {
2306            pa = -pa;
2307          }
2308          var pb = p - up;
2309          if (pb < 0) {
2310            pb = -pb;
2311          }
2312          var pc = p - upLeft;
2313          if (pc < 0) {
2314            pc = -pc;
2315          }
2316          c = rawBytes[i];
2317          if (pa <= pb && pa <= pc) {
2318            buffer[j++] = left + c;
2319          } else if (pb <= pc) {
2320            buffer[j++] = up + c;
2321          } else {
2322            buffer[j++] = upLeft + c;
2323          }
2324        }
2325        break;
2326      default:
2327        throw new _util.FormatError('Unsupported predictor: ' + predictor);
2328    }
2329    this.bufferLength += rowBytes;
2330  };
2331  return PredictorStream;
2332}();
2333var DecryptStream = function DecryptStreamClosure() {
2334  function DecryptStream(str, maybeLength, decrypt) {
2335    this.str = str;
2336    this.dict = str.dict;
2337    this.decrypt = decrypt;
2338    this.nextChunk = null;
2339    this.initialized = false;
2340    DecodeStream.call(this, maybeLength);
2341  }
2342  var chunkSize = 512;
2343  DecryptStream.prototype = Object.create(DecodeStream.prototype);
2344  DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
2345    var chunk;
2346    if (this.initialized) {
2347      chunk = this.nextChunk;
2348    } else {
2349      chunk = this.str.getBytes(chunkSize);
2350      this.initialized = true;
2351    }
2352    if (!chunk || chunk.length === 0) {
2353      this.eof = true;
2354      return;
2355    }
2356    this.nextChunk = this.str.getBytes(chunkSize);
2357    var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
2358    var decrypt = this.decrypt;
2359    chunk = decrypt(chunk, !hasMoreData);
2360    var bufferLength = this.bufferLength;
2361    var i,
2362        n = chunk.length;
2363    var buffer = this.ensureBuffer(bufferLength + n);
2364    for (i = 0; i < n; i++) {
2365      buffer[bufferLength++] = chunk[i];
2366    }
2367    this.bufferLength = bufferLength;
2368  };
2369  return DecryptStream;
2370}();
2371var Ascii85Stream = function Ascii85StreamClosure() {
2372  function Ascii85Stream(str, maybeLength) {
2373    this.str = str;
2374    this.dict = str.dict;
2375    this.input = new Uint8Array(5);
2376    if (maybeLength) {
2377      maybeLength = 0.8 * maybeLength;
2378    }
2379    DecodeStream.call(this, maybeLength);
2380  }
2381  Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
2382  Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
2383    var TILDA_CHAR = 0x7E;
2384    var Z_LOWER_CHAR = 0x7A;
2385    var EOF = -1;
2386    var str = this.str;
2387    var c = str.getByte();
2388    while ((0, _util.isSpace)(c)) {
2389      c = str.getByte();
2390    }
2391    if (c === EOF || c === TILDA_CHAR) {
2392      this.eof = true;
2393      return;
2394    }
2395    var bufferLength = this.bufferLength,
2396        buffer;
2397    var i;
2398    if (c === Z_LOWER_CHAR) {
2399      buffer = this.ensureBuffer(bufferLength + 4);
2400      for (i = 0; i < 4; ++i) {
2401        buffer[bufferLength + i] = 0;
2402      }
2403      this.bufferLength += 4;
2404    } else {
2405      var input = this.input;
2406      input[0] = c;
2407      for (i = 1; i < 5; ++i) {
2408        c = str.getByte();
2409        while ((0, _util.isSpace)(c)) {
2410          c = str.getByte();
2411        }
2412        input[i] = c;
2413        if (c === EOF || c === TILDA_CHAR) {
2414          break;
2415        }
2416      }
2417      buffer = this.ensureBuffer(bufferLength + i - 1);
2418      this.bufferLength += i - 1;
2419      if (i < 5) {
2420        for (; i < 5; ++i) {
2421          input[i] = 0x21 + 84;
2422        }
2423        this.eof = true;
2424      }
2425      var t = 0;
2426      for (i = 0; i < 5; ++i) {
2427        t = t * 85 + (input[i] - 0x21);
2428      }
2429      for (i = 3; i >= 0; --i) {
2430        buffer[bufferLength + i] = t & 0xFF;
2431        t >>= 8;
2432      }
2433    }
2434  };
2435  return Ascii85Stream;
2436}();
2437var AsciiHexStream = function AsciiHexStreamClosure() {
2438  function AsciiHexStream(str, maybeLength) {
2439    this.str = str;
2440    this.dict = str.dict;
2441    this.firstDigit = -1;
2442    if (maybeLength) {
2443      maybeLength = 0.5 * maybeLength;
2444    }
2445    DecodeStream.call(this, maybeLength);
2446  }
2447  AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
2448  AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
2449    var UPSTREAM_BLOCK_SIZE = 8000;
2450    var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
2451    if (!bytes.length) {
2452      this.eof = true;
2453      return;
2454    }
2455    var maxDecodeLength = bytes.length + 1 >> 1;
2456    var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
2457    var bufferLength = this.bufferLength;
2458    var firstDigit = this.firstDigit;
2459    for (var i = 0, ii = bytes.length; i < ii; i++) {
2460      var ch = bytes[i],
2461          digit;
2462      if (ch >= 0x30 && ch <= 0x39) {
2463        digit = ch & 0x0F;
2464      } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
2465        digit = (ch & 0x0F) + 9;
2466      } else if (ch === 0x3E) {
2467        this.eof = true;
2468        break;
2469      } else {
2470        continue;
2471      }
2472      if (firstDigit < 0) {
2473        firstDigit = digit;
2474      } else {
2475        buffer[bufferLength++] = firstDigit << 4 | digit;
2476        firstDigit = -1;
2477      }
2478    }
2479    if (firstDigit >= 0 && this.eof) {
2480      buffer[bufferLength++] = firstDigit << 4;
2481      firstDigit = -1;
2482    }
2483    this.firstDigit = firstDigit;
2484    this.bufferLength = bufferLength;
2485  };
2486  return AsciiHexStream;
2487}();
2488var RunLengthStream = function RunLengthStreamClosure() {
2489  function RunLengthStream(str, maybeLength) {
2490    this.str = str;
2491    this.dict = str.dict;
2492    DecodeStream.call(this, maybeLength);
2493  }
2494  RunLengthStream.prototype = Object.create(DecodeStream.prototype);
2495  RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
2496    var repeatHeader = this.str.getBytes(2);
2497    if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
2498      this.eof = true;
2499      return;
2500    }
2501    var buffer;
2502    var bufferLength = this.bufferLength;
2503    var n = repeatHeader[0];
2504    if (n < 128) {
2505      buffer = this.ensureBuffer(bufferLength + n + 1);
2506      buffer[bufferLength++] = repeatHeader[1];
2507      if (n > 0) {
2508        var source = this.str.getBytes(n);
2509        buffer.set(source, bufferLength);
2510        bufferLength += n;
2511      }
2512    } else {
2513      n = 257 - n;
2514      var b = repeatHeader[1];
2515      buffer = this.ensureBuffer(bufferLength + n + 1);
2516      for (var i = 0; i < n; i++) {
2517        buffer[bufferLength++] = b;
2518      }
2519    }
2520    this.bufferLength = bufferLength;
2521  };
2522  return RunLengthStream;
2523}();
2524var LZWStream = function LZWStreamClosure() {
2525  function LZWStream(str, maybeLength, earlyChange) {
2526    this.str = str;
2527    this.dict = str.dict;
2528    this.cachedData = 0;
2529    this.bitsCached = 0;
2530    var maxLzwDictionarySize = 4096;
2531    var lzwState = {
2532      earlyChange: earlyChange,
2533      codeLength: 9,
2534      nextCode: 258,
2535      dictionaryValues: new Uint8Array(maxLzwDictionarySize),
2536      dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
2537      dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
2538      currentSequence: new Uint8Array(maxLzwDictionarySize),
2539      currentSequenceLength: 0
2540    };
2541    for (var i = 0; i < 256; ++i) {
2542      lzwState.dictionaryValues[i] = i;
2543      lzwState.dictionaryLengths[i] = 1;
2544    }
2545    this.lzwState = lzwState;
2546    DecodeStream.call(this, maybeLength);
2547  }
2548  LZWStream.prototype = Object.create(DecodeStream.prototype);
2549  LZWStream.prototype.readBits = function LZWStream_readBits(n) {
2550    var bitsCached = this.bitsCached;
2551    var cachedData = this.cachedData;
2552    while (bitsCached < n) {
2553      var c = this.str.getByte();
2554      if (c === -1) {
2555        this.eof = true;
2556        return null;
2557      }
2558      cachedData = cachedData << 8 | c;
2559      bitsCached += 8;
2560    }
2561    this.bitsCached = bitsCached -= n;
2562    this.cachedData = cachedData;
2563    this.lastCode = null;
2564    return cachedData >>> bitsCached & (1 << n) - 1;
2565  };
2566  LZWStream.prototype.readBlock = function LZWStream_readBlock() {
2567    var blockSize = 512;
2568    var estimatedDecodedSize = blockSize * 2,
2569        decodedSizeDelta = blockSize;
2570    var i, j, q;
2571    var lzwState = this.lzwState;
2572    if (!lzwState) {
2573      return;
2574    }
2575    var earlyChange = lzwState.earlyChange;
2576    var nextCode = lzwState.nextCode;
2577    var dictionaryValues = lzwState.dictionaryValues;
2578    var dictionaryLengths = lzwState.dictionaryLengths;
2579    var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
2580    var codeLength = lzwState.codeLength;
2581    var prevCode = lzwState.prevCode;
2582    var currentSequence = lzwState.currentSequence;
2583    var currentSequenceLength = lzwState.currentSequenceLength;
2584    var decodedLength = 0;
2585    var currentBufferLength = this.bufferLength;
2586    var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
2587    for (i = 0; i < blockSize; i++) {
2588      var code = this.readBits(codeLength);
2589      var hasPrev = currentSequenceLength > 0;
2590      if (code < 256) {
2591        currentSequence[0] = code;
2592        currentSequenceLength = 1;
2593      } else if (code >= 258) {