https://pipelbiz.com/bower_components/pdf.js-viewer/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/******/ 	// identity function for calling harmony imports with the correct context
62/******/ 	__w_pdfjs_require__.i = function(value) { return value; };
63/******/
64/******/ 	// define getter function for harmony exports
65/******/ 	__w_pdfjs_require__.d = function(exports, name, getter) {
66/******/ 		if(!__w_pdfjs_require__.o(exports, name)) {
67/******/ 			Object.defineProperty(exports, name, {
68/******/ 				configurable: false,
69/******/ 				enumerable: true,
70/******/ 				get: getter
71/******/ 			});
72/******/ 		}
73/******/ 	};
74/******/
75/******/ 	// getDefaultExport function for compatibility with non-harmony modules
76/******/ 	__w_pdfjs_require__.n = function(module) {
77/******/ 		var getter = module && module.__esModule ?
78/******/ 			function getDefault() { return module['default']; } :
79/******/ 			function getModuleExports() { return module; };
80/******/ 		__w_pdfjs_require__.d(getter, 'a', getter);
81/******/ 		return getter;
82/******/ 	};
83/******/
84/******/ 	// Object.prototype.hasOwnProperty.call
85/******/ 	__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
86/******/
87/******/ 	// __webpack_public_path__
88/******/ 	__w_pdfjs_require__.p = "";
89/******/
90/******/ 	// Load entry module and return exports
91/******/ 	return __w_pdfjs_require__(__w_pdfjs_require__.s = 37);
92/******/ })
93/************************************************************************/
94/******/ ([
95/* 0 */
96/***/ (function(module, exports, __w_pdfjs_require__) {
97
98"use strict";
99/* WEBPACK VAR INJECTION */(function(global) {
100var compatibility = __w_pdfjs_require__(36);
101var globalScope = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : this;
102var FONT_IDENTITY_MATRIX = [
103 0.001,
104 0,
105 0,
106 0.001,
107 0,
108 0
109];
110var TextRenderingMode = {
111 FILL: 0,
112 STROKE: 1,
113 FILL_STROKE: 2,
114 INVISIBLE: 3,
115 FILL_ADD_TO_PATH: 4,
116 STROKE_ADD_TO_PATH: 5,
117 FILL_STROKE_ADD_TO_PATH: 6,
118 ADD_TO_PATH: 7,
119 FILL_STROKE_MASK: 3,
120 ADD_TO_PATH_FLAG: 4
121};
122var ImageKind = {
123 GRAYSCALE_1BPP: 1,
124 RGB_24BPP: 2,
125 RGBA_32BPP: 3
126};
127var AnnotationType = {
128 TEXT: 1,
129 LINK: 2,
130 FREETEXT: 3,
131 LINE: 4,
132 SQUARE: 5,
133 CIRCLE: 6,
134 POLYGON: 7,
135 POLYLINE: 8,
136 HIGHLIGHT: 9,
137 UNDERLINE: 10,
138 SQUIGGLY: 11,
139 STRIKEOUT: 12,
140 STAMP: 13,
141 CARET: 14,
142 INK: 15,
143 POPUP: 16,
144 FILEATTACHMENT: 17,
145 SOUND: 18,
146 MOVIE: 19,
147 WIDGET: 20,
148 SCREEN: 21,
149 PRINTERMARK: 22,
150 TRAPNET: 23,
151 WATERMARK: 24,
152 THREED: 25,
153 REDACT: 26
154};
155var AnnotationFlag = {
156 INVISIBLE: 0x01,
157 HIDDEN: 0x02,
158 PRINT: 0x04,
159 NOZOOM: 0x08,

611 }
612}
613var Uint32ArrayView = function Uint32ArrayViewClosure() {
614 function Uint32ArrayView(buffer, length) {
615  this.buffer = buffer;
616  this.byteLength = buffer.length;
617  this.length = length === undefined ? this.byteLength >> 2 : length;
618  ensureUint32ArrayViewProps(this.length);
619 }
620 Uint32ArrayView.prototype = Object.create(null);
621 var uint32ArrayViewSetters = 0;
622 function createUint32ArrayProp(index) {
623  return {
624   get: function () {
625    var buffer = this.buffer, offset = index << 2;
626    return (buffer[offset] | buffer[offset + 1] << 8 | buffer[offset + 2] << 16 | buffer[offset + 3] << 24) >>> 0;
627   },
628   set: function (value) {
629    var buffer = this.buffer, offset = index << 2;
630    buffer[offset] = value & 255;
631    buffer[offset + 1] = value >> 8 & 255;
632    buffer[offset + 2] = value >> 16 & 255;
633    buffer[offset + 3] = value >>> 24 & 255;
634   }
635  };
636 }
637 function ensureUint32ArrayViewProps(length) {
638  while (uint32ArrayViewSetters < length) {
639   Object.defineProperty(Uint32ArrayView.prototype, uint32ArrayViewSetters, createUint32ArrayProp(uint32ArrayViewSetters));
640   uint32ArrayViewSetters++;
641  }
642 }
643 return Uint32ArrayView;
644}();
645exports.Uint32ArrayView = Uint32ArrayView;
646var IDENTITY_MATRIX = [
647 1,
648 0,
649 0,
650 1,
651 0,
652 0
653];
654var Util = function UtilClosure() {
655 function Util() {
656 }
657 var rgbBuf = [
658  'rgb(',
659  0,
660  ',',
661  0,
662  ',',
663  0,
664  ')'
665 ];
666 Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
667  rgbBuf[1] = r;
668  rgbBuf[3] = g;
669  rgbBuf[5] = b;
670  return rgbBuf.join('');
671 };
672 Util.transform = function Util_transform(m1, m2) {
673  return [
674   m1[0] * m2[0] + m1[2] * m2[1],
675   m1[1] * m2[0] + m1[3] * m2[1],
676   m1[0] * m2[2] + m1[2] * m2[3],
677   m1[1] * m2[2] + m1[3] * m2[3],
678   m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
679   m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
680  ];
681 };
682 Util.applyTransform = function Util_applyTransform(p, m) {
683  var xt = p[0] * m[0] + p[1] * m[2] + m[4];
684  var yt = p[0] * m[1] + p[1] * m[3] + m[5];
685  return [
686   xt,
687   yt
688  ];
689 };
690 Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
691  var d = m[0] * m[3] - m[1] * m[2];
692  var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
693  var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
694  return [
695   xt,
696   yt
697  ];
698 };
699 Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
700  var p1 = Util.applyTransform(r, m);
701  var p2 = Util.applyTransform(r.slice(2, 4), m);
702  var p3 = Util.applyTransform([
703   r[0],
704   r[3]
705  ], m);
706  var p4 = Util.applyTransform([
707   r[2],
708   r[1]
709  ], m);
710  return [
711   Math.min(p1[0], p2[0], p3[0], p4[0]),
712   Math.min(p1[1], p2[1], p3[1], p4[1]),
713   Math.max(p1[0], p2[0], p3[0], p4[0]),
714   Math.max(p1[1], p2[1], p3[1], p4[1])
715  ];
716 };
717 Util.inverseTransform = function Util_inverseTransform(m) {
718  var d = m[0] * m[3] - m[1] * m[2];
719  return [
720   m[3] / d,
721   -m[1] / d,
722   -m[2] / d,
723   m[0] / d,
724   (m[2] * m[5] - m[4] * m[3]) / d,
725   (m[4] * m[1] - m[5] * m[0]) / d
726  ];
727 };
728 Util.apply3dTransform = function Util_apply3dTransform(m, v) {
729  return [
730   m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
731   m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
732   m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
733  ];
734 };
735 Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
736  var transpose = [
737   m[0],
738   m[2],
739   m[1],
740   m[3]
741  ];
742  var a = m[0] * transpose[0] + m[1] * transpose[2];
743  var b = m[0] * transpose[1] + m[1] * transpose[3];
744  var c = m[2] * transpose[0] + m[3] * transpose[2];
745  var d = m[2] * transpose[1] + m[3] * transpose[3];
746  var first = (a + d) / 2;
747  var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
748  var sx = first + second || 1;
749  var sy = first - second || 1;
750  return [
751   Math.sqrt(sx),
752   Math.sqrt(sy)
753  ];
754 };
755 Util.normalizeRect = function Util_normalizeRect(rect) {
756  var r = rect.slice(0);
757  if (rect[0] > rect[2]) {
758   r[0] = rect[2];
759   r[2] = rect[0];
760  }
761  if (rect[1] > rect[3]) {
762   r[1] = rect[3];
763   r[3] = rect[1];
764  }
765  return r;
766 };
767 Util.intersect = function Util_intersect(rect1, rect2) {
768  function compare(a, b) {
769   return a - b;
770  }
771  var orderedX = [
772    rect1[0],
773    rect1[2],
774    rect2[0],
775    rect2[2]
776   ].sort(compare), orderedY = [
777    rect1[1],
778    rect1[3],
779    rect2[1],
780    rect2[3]
781   ].sort(compare), result = [];
782  rect1 = Util.normalizeRect(rect1);
783  rect2 = Util.normalizeRect(rect2);
784  if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
785   result[0] = orderedX[1];
786   result[2] = orderedX[2];
787  } else {
788   return false;

884     callback();
885    }
886    loaded = true;
887   };
888  }
889  document.getElementsByTagName('head')[0].appendChild(script);
890 };
891 return Util;
892}();
893var PageViewport = function PageViewportClosure() {
894 function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
895  this.viewBox = viewBox;
896  this.scale = scale;
897  this.rotation = rotation;
898  this.offsetX = offsetX;
899  this.offsetY = offsetY;
900  var centerX = (viewBox[2] + viewBox[0]) / 2;
901  var centerY = (viewBox[3] + viewBox[1]) / 2;
902  var rotateA, rotateB, rotateC, rotateD;
903  rotation = rotation % 360;
904  rotation = rotation < 0 ? rotation + 360 : rotation;
905  switch (rotation) {
906  case 180:
907   rotateA = -1;
908   rotateB = 0;
909   rotateC = 0;
910   rotateD = 1;
911   break;
912  case 90:
913   rotateA = 0;
914   rotateB = 1;
915   rotateC = 1;
916   rotateD = 0;
917   break;
918  case 270:
919   rotateA = 0;
920   rotateB = -1;
921   rotateC = -1;
922   rotateD = 0;
923   break;
924  default:
925   rotateA = 1;
926   rotateB = 0;
927   rotateC = 0;
928   rotateD = -1;
929   break;
930  }
931  if (dontFlip) {
932   rotateC = -rotateC;
933   rotateD = -rotateD;
934  }
935  var offsetCanvasX, offsetCanvasY;
936  var width, height;
937  if (rotateA === 0) {
938   offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
939   offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
940   width = Math.abs(viewBox[3] - viewBox[1]) * scale;
941   height = Math.abs(viewBox[2] - viewBox[0]) * scale;
942  } else {
943   offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
944   offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
945   width = Math.abs(viewBox[2] - viewBox[0]) * scale;
946   height = Math.abs(viewBox[3] - viewBox[1]) * scale;
947  }
948  this.transform = [
949   rotateA * scale,
950   rotateB * scale,
951   rotateC * scale,
952   rotateD * scale,
953   offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,
954   offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY
955  ];
956  this.width = width;
957  this.height = height;
958  this.fontScale = scale;
959 }
960 PageViewport.prototype = {
961  clone: function PageViewPort_clone(args) {
962   args = args || {};
963   var scale = 'scale' in args ? args.scale : this.scale;
964   var rotation = 'rotation' in args ? args.rotation : this.rotation;
965   return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip);
966  },
967  convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
968   return Util.applyTransform([
969    x,
970    y
971   ], this.transform);
972  },
973  convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) {
974   var tl = Util.applyTransform([
975    rect[0],
976    rect[1]
977   ], this.transform);
978   var br = Util.applyTransform([
979    rect[2],
980    rect[3]
981   ], this.transform);
982   return [
983    tl[0],
984    tl[1],
985    br[0],
986    br[1]
987   ];
988  },
989  convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
990   return Util.applyInverseTransform([
991    x,
992    y
993   ], this.transform);
994  }
995 };
996 return PageViewport;
997}();
998var PDFStringTranslateTable = [
999 0,
1000 0,
1001 0,
1002 0,
1003 0,
1004 0,
1005 0,
1006 0,
1007 0,
1008 0,
1009 0,
1010 0,
1011 0,
1012 0,
1013 0,
1014 0,
1015 0,
1016 0,
1017 0,
1018 0,
1019 0,
1020 0,
1021 0,
1022 0,
1023 0x2D8,
1024 0x2C7,
1025 0x2C6,
1026 0x2D9,
1027 0x2DD,
1028 0x2DB,
1029 0x2DA,
1030 0x2DC,
1031 0,
1032 0,
1033 0,
1034 0,
1035 0,
1036 0,
1037 0,
1038 0,
1039 0,
1040 0,
1041 0,
1042 0,
1043 0,
1044 0,
1045 0,
1046 0,
1047 0,
1048 0,
1049 0,
1050 0,
1051 0,
1052 0,
1053 0,
1054 0,
1055 0,
1056 0,
1057 0,
1058 0,
1059 0,
1060 0,
1061 0,
1062 0,
1063 0,
1064 0,
1065 0,
1066 0,
1067 0,
1068 0,
1069 0,
1070 0,
1071 0,
1072 0,
1073 0,
1074 0,
1075 0,
1076 0,
1077 0,
1078 0,
1079 0,
1080 0,
1081 0,
1082 0,
1083 0,
1084 0,
1085 0,
1086 0,
1087 0,
1088 0,
1089 0,
1090 0,
1091 0,
1092 0,
1093 0,
1094 0,
1095 0,
1096 0,
1097 0,
1098 0,
1099 0,
1100 0,
1101 0,
1102 0,
1103 0,
1104 0,
1105 0,
1106 0,
1107 0,
1108 0,
1109 0,
1110 0,
1111 0,
1112 0,
1113 0,
1114 0,
1115 0,
1116 0,
1117 0,
1118 0,
1119 0,
1120 0,
1121 0,
1122 0,
1123 0,
1124 0,
1125 0,
1126 0,
1127 0x2022,
1128 0x2020,
1129 0x2021,
1130 0x2026,
1131 0x2014,
1132 0x2013,
1133 0x192,
1134 0x2044,
1135 0x2039,
1136 0x203A,
1137 0x2212,
1138 0x2030,
1139 0x201E,
1140 0x201C,
1141 0x201D,
1142 0x2018,
1143 0x2019,
1144 0x201A,
1145 0x2122,
1146 0xFB01,
1147 0xFB02,
1148 0x141,
1149 0x152,
1150 0x160,
1151 0x178,
1152 0x17D,
1153 0x131,
1154 0x142,
1155 0x153,
1156 0x161,
1157 0x17E,
1158 0,
1159 0x20AC
1160];
1161function stringToPDFString(str) {
1162 var i, n = str.length, strBuf = [];
1163 if (str[0] === '\xFE' && str[1] === '\xFF') {
1164  for (i = 2; i < n; i += 2) {
1165   strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
1166  }
1167 } else {
1168  for (i = 0; i < n; ++i) {
1169   var code = PDFStringTranslateTable[str.charCodeAt(i)];
1170   strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1171  }
1172 }
1173 return strBuf.join('');
1174}
1175function stringToUTF8String(str) {
1176 return decodeURIComponent(escape(str));
1177}
1178function utf8StringToString(str) {
1179 return unescape(encodeURIComponent(str));
1180}
1181function isEmptyObj(obj) {
1182 for (var key in obj) {
1183  return false;

1184 }
1185 return true;
1186}
1187function isBool(v) {
1188 return typeof v === 'boolean';
1189}
1190function isInt(v) {
1191 return typeof v === 'number' && (v | 0) === v;
1192}
1193function isNum(v) {
1194 return typeof v === 'number';
1195}
1196function isString(v) {
1197 return typeof v === 'string';
1198}
1199function isArray(v) {
1200 return v instanceof Array;
1201}
1202function isArrayBuffer(v) {
1203 return typeof v === 'object' && v !== null && v.byteLength !== undefined;
1204}
1205function isSpace(ch) {
1206 return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
1207}
1208function isNodeJS() {
1209 if (typeof __pdfjsdev_webpack__ === 'undefined') {
1210  return typeof process === 'object' && process + '' === '[object process]';
1211 }
1212 return false;
1213}
1214function createPromiseCapability() {
1215 var capability = {};
1216 capability.promise = new Promise(function (resolve, reject) {
1217  capability.resolve = resolve;
1218  capability.reject = reject;
1219 });
1220 return capability;
1221}
1222var StatTimer = function StatTimerClosure() {
1223 function rpad(str, pad, length) {
1224  while (str.length < length) {
1225   str += pad;
1226  }
1227  return str;
1228 }
1229 function StatTimer() {
1230  this.started = Object.create(null);
1231  this.times = [];
1232  this.enabled = true;
1233 }
1234 StatTimer.prototype = {
1235  time: function StatTimer_time(name) {
1236   if (!this.enabled) {
1237    return;
1238   }
1239   if (name in this.started) {
1240    warn('Timer is already running for ' + name);
1241   }
1242   this.started[name] = Date.now();
1243  },
1244  timeEnd: function StatTimer_timeEnd(name) {
1245   if (!this.enabled) {
1246    return;
1247   }
1248   if (!(name in this.started)) {
1249    warn('Timer has not been started for ' + name);
1250   }
1251   this.times.push({
1252    'name': name,
1253    'start': this.started[name],
1254    'end': Date.now()
1255   });
1256   delete this.started[name];
1257  },
1258  toString: function StatTimer_toString() {
1259   var i, ii;
1260   var times = this.times;
1261   var out = '';
1262   var longest = 0;
1263   for (i = 0, ii = times.length; i < ii; ++i) {
1264    var name = times[i]['name'];
1265    if (name.length > longest) {
1266     longest = name.length;
1267    }
1268   }
1269   for (i = 0, ii = times.length; i < ii; ++i) {
1270    var span = times[i];
1271    var duration = span.end - span.start;
1272    out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n';
1273   }
1274   return out;
1275  }
1276 };
1277 return StatTimer;
1278}();
1279var createBlob = function createBlob(data, contentType) {
1280 if (typeof Blob !== 'undefined') {
1281  return new Blob([data], { type: contentType });
1282 }
1283 warn('The "Blob" constructor is not supported.');
1284};
1285var createObjectURL = function createObjectURLClosure() {
1286 var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
1287 return function createObjectURL(data, contentType, forceDataSchema) {
1288  if (!forceDataSchema && typeof URL !== 'undefined' && URL.createObjectURL) {
1289   var blob = createBlob(data, contentType);
1290   return URL.createObjectURL(blob);
1291  }
1292  var buffer = 'data:' + contentType + ';base64,';
1293  for (var i = 0, ii = data.length; i < ii; i += 3) {
1294   var b1 = data[i] & 0xFF;
1295   var b2 = data[i + 1] & 0xFF;
1296   var b3 = data[i + 2] & 0xFF;
1297   var d1 = b1 >> 2, d2 = (b1 & 3) << 4 | b2 >> 4;
1298   var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
1299   var d4 = i + 2 < ii ? b3 & 0x3F : 64;
1300   buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
1301  }
1302  return buffer;
1303 };
1304}();
1305function MessageHandler(sourceName, targetName, comObj) {
1306 this.sourceName = sourceName;
1307 this.targetName = targetName;
1308 this.comObj = comObj;
1309 this.callbackIndex = 1;
1310 this.postMessageTransfers = true;
1311 var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
1312 var ah = this.actionHandler = Object.create(null);
1313 this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) {
1314  var data = event.data;
1315  if (data.targetName !== this.sourceName) {
1316   return;
1317  }
1318  if (data.isReply) {
1319   var callbackId = data.callbackId;
1320   if (data.callbackId in callbacksCapabilities) {
1321    var callback = callbacksCapabilities[callbackId];
1322    delete callbacksCapabilities[callbackId];
1323    if ('error' in data) {
1324     callback.reject(data.error);
1325    } else {
1326     callback.resolve(data.data);
1327    }
1328   } else {
1329    error('Cannot resolve callback ' + callbackId);
1330   }
1331  } else if (data.action in ah) {
1332   var action = ah[data.action];
1333   if (data.callbackId) {
1334    var sourceName = this.sourceName;
1335    var targetName = data.sourceName;
1336    Promise.resolve().then(function () {
1337     return action[0].call(action[1], data.data);
1338    }).then(function (result) {
1339     comObj.postMessage({
1340      sourceName: sourceName,
1341      targetName: targetName,
1342      isReply: true,
1343      callbackId: data.callbackId,
1344      data: result
1345     });
1346    }, function (reason) {
1347     if (reason instanceof Error) {
1348      reason = reason + '';
1349     }
1350     comObj.postMessage({
1351      sourceName: sourceName,
1352      targetName: targetName,
1353      isReply: true,
1354      callbackId: data.callbackId,
1355      error: reason
1356     });
1357    });
1358   } else {
1359    action[0].call(action[1], data.data);
1360   }
1361  } else {
1362   error('Unknown action from worker: ' + data.action);
1363  }
1364 }.bind(this);
1365 comObj.addEventListener('message', this._onComObjOnMessage);
1366}
1367MessageHandler.prototype = {
1368 on: function messageHandlerOn(actionName, handler, scope) {
1369  var ah = this.actionHandler;
1370  if (ah[actionName]) {
1371   error('There is already an actionName called "' + actionName + '"');
1372  }
1373  ah[actionName] = [
1374   handler,
1375   scope
1376  ];
1377 },
1378 send: function messageHandlerSend(actionName, data, transfers) {
1379  var message = {
1380   sourceName: this.sourceName,
1381   targetName: this.targetName,
1382   action: actionName,
1383   data: data
1384  };
1385  this.postMessage(message, transfers);
1386 },

1538  this.__nonSerializable__ = nonSerializable;
1539 }
1540 Dict.prototype = {
1541  assignXref: function Dict_assignXref(newXref) {
1542   this.xref = newXref;
1543  },
1544  get: function Dict_get(key1, key2, key3) {
1545   var value;
1546   var xref = this.xref, suppressEncryption = this.suppressEncryption;
1547   if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || typeof key2 === 'undefined') {
1548    return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
1549   }
1550   if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || typeof key3 === 'undefined') {
1551    return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
1552   }
1553   value = this.map[key3] || null;
1554   return xref ? xref.fetchIfRef(value, suppressEncryption) : value;
1555  },
1556  getAsync: function Dict_getAsync(key1, key2, key3) {
1557   var value;
1558   var xref = this.xref, suppressEncryption = this.suppressEncryption;
1559   if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || typeof key2 === 'undefined') {
1560    if (xref) {
1561     return xref.fetchIfRefAsync(value, suppressEncryption);
1562    }
1563    return Promise.resolve(value);
1564   }
1565   if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || typeof key3 === 'undefined') {
1566    if (xref) {
1567     return xref.fetchIfRefAsync(value, suppressEncryption);
1568    }
1569    return Promise.resolve(value);
1570   }
1571   value = this.map[key3] || null;
1572   if (xref) {
1573    return xref.fetchIfRefAsync(value, suppressEncryption);
1574   }
1575   return Promise.resolve(value);
1576  },
1577  getArray: function Dict_getArray(key1, key2, key3) {
1578   var value = this.get(key1, key2, key3);
1579   var xref = this.xref, suppressEncryption = this.suppressEncryption;
1580   if (!isArray(value) || !xref) {
1581    return value;
1582   }
1583   value = value.slice();
1584   for (var i = 0, ii = value.length; i < ii; i++) {
1585    if (!isRef(value[i])) {
1586     continue;
1587    }
1588    value[i] = xref.fetch(value[i], suppressEncryption);
1589   }
1590   return value;
1591  },
1592  getRaw: function Dict_getRaw(key) {
1593   return this.map[key];
1594  },
1595  getKeys: function Dict_getKeys() {
1596   return Object.keys(this.map);
1597  },
1598  set: function Dict_set(key, value) {
1599   this.map[key] = value;
1600  },
1601  has: function Dict_has(key) {
1602   return key in this.map;
1603  },
1604  forEach: function Dict_forEach(callback) {
1605   for (var key in this.map) {
1606    callback(key, this.get(key));
1607   }
1608  }
1609 };
1610 Dict.empty = new Dict(null);
1611 Dict.merge = function Dict_merge(xref, dictArray) {
1612  var mergedDict = new Dict(xref);
1613  for (var i = 0, ii = dictArray.length; i < ii; i++) {
1614   var dict = dictArray[i];
1615   if (!isDict(dict)) {
1616    continue;
1617   }
1618   for (var keyName in dict.map) {
1619    if (mergedDict.map[keyName]) {
1620     continue;
1621    }
1622    mergedDict.map[keyName] = dict.map[keyName];
1623   }
1624  }
1625  return mergedDict;
1626 };
1627 return Dict;
1628}();
1629var Ref = function RefClosure() {
1630 function Ref(num, gen) {
1631  this.num = num;
1632  this.gen = gen;
1633 }
1634 Ref.prototype = {
1635  toString: function Ref_toString() {
1636   var str = this.num + 'R';
1637   if (this.gen !== 0) {
1638    str += this.gen;
1639   }
1640   return str;
1641  }
1642 };
1643 return Ref;
1644}();
1645var RefSet = function RefSetClosure() {
1646 function RefSet() {
1647  this.dict = Object.create(null);
1648 }
1649 RefSet.prototype = {
1650  has: function RefSet_has(ref) {
1651   return ref.toString() in this.dict;
1652  },
1653  put: function RefSet_put(ref) {
1654   this.dict[ref.toString()] = true;
1655  },
1656  remove: function RefSet_remove(ref) {
1657   delete this.dict[ref.toString()];
1658  }
1659 };
1660 return RefSet;
1661}();
1662var RefSetCache = function RefSetCacheClosure() {
1663 function RefSetCache() {
1664  this.dict = Object.create(null);
1665 }
1666 RefSetCache.prototype = {
1667  get: function RefSetCache_get(ref) {
1668   return this.dict[ref.toString()];
1669  },
1670  has: function RefSetCache_has(ref) {
1671   return ref.toString() in this.dict;
1672  },
1673  put: function RefSetCache_put(ref, obj) {
1674   this.dict[ref.toString()] = obj;
1675  },
1676  putAlias: function RefSetCache_putAlias(ref, aliasRef) {
1677   this.dict[ref.toString()] = this.get(aliasRef);
1678  },
1679  forEach: function RefSetCache_forEach(fn, thisArg) {
1680   for (var i in this.dict) {
1681    fn.call(thisArg, this.dict[i]);
1682   }
1683  },
1684  clear: function RefSetCache_clear() {
1685   this.dict = Object.create(null);
1686  }
1687 };
1688 return RefSetCache;
1689}();
1690function isEOF(v) {
1691 return v === EOF;
1692}
1693function isName(v, name) {
1694 return v instanceof Name && (name === undefined || v.name === name);
1695}
1696function isCmd(v, cmd) {
1697 return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
1698}
1699function isDict(v, type) {
1700 return v instanceof Dict && (type === undefined || isName(v.get('Type'), type));
1701}
1702function isRef(v) {
1703 return v instanceof Ref;
1704}
1705function isRefsEqual(v1, v2) {
1706 return v1.num === v2.num && v1.gen === v2.gen;
1707}
1708function isStream(v) {
1709 return typeof v === 'object' && v !== null && v.getBytes !== undefined;
1710}
1711exports.EOF = EOF;
1712exports.Cmd = Cmd;
1713exports.Dict = Dict;
1714exports.Name = Name;
1715exports.Ref = Ref;
1716exports.RefSet = RefSet;
1717exports.RefSetCache = RefSetCache;
1718exports.isEOF = isEOF;
1719exports.isCmd = isCmd;
1720exports.isDict = isDict;
1721exports.isName = isName;
1722exports.isRef = isRef;
1723exports.isRefsEqual = isRefsEqual;
1724exports.isStream = isStream;
1725
1726/***/ }),
1727/* 2 */
1728/***/ (function(module, exports, __w_pdfjs_require__) {
1729
1730"use strict";
1731
1732var sharedUtil = __w_pdfjs_require__(0);
1733var corePrimitives = __w_pdfjs_require__(1);
1734var coreJbig2 = __w_pdfjs_require__(28);
1735var coreJpg = __w_pdfjs_require__(29);
1736var coreJpx = __w_pdfjs_require__(15);
1737var Util = sharedUtil.Util;
1738var error = sharedUtil.error;
1739var info = sharedUtil.info;
1740var isInt = sharedUtil.isInt;
1741var isArray = sharedUtil.isArray;
1742var createObjectURL = sharedUtil.createObjectURL;
1743var shadow = sharedUtil.shadow;
1744var isSpace = sharedUtil.isSpace;
1745var Dict = corePrimitives.Dict;
1746var isDict = corePrimitives.isDict;
1747var isStream = corePrimitives.isStream;
1748var Jbig2Image = coreJbig2.Jbig2Image;
1749var JpegImage = coreJpg.JpegImage;
1750var JpxImage = coreJpx.JpxImage;
1751var Stream = function StreamClosure() {
1752 function Stream(arrayBuffer, start, length, dict) {
1753  this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
1754  this.start = start || 0;
1755  this.pos = this.start;
1756  this.end = start + length || this.bytes.length;
1757  this.dict = dict;
1758 }
1759 Stream.prototype = {
1760  get length() {
1761   return this.end - this.start;
1762  },
1763  get isEmpty() {
1764   return this.length === 0;
1765  },
1766  getByte: function Stream_getByte() {
1767   if (this.pos >= this.end) {
1768    return -1;
1769   }
1770   return this.bytes[this.pos++];
1771  },
1772  getUint16: function Stream_getUint16() {
1773   var b0 = this.getByte();
1774   var b1 = this.getByte();
1775   if (b0 === -1 || b1 === -1) {
1776    return -1;
1777   }
1778   return (b0 << 8) + b1;
1779  },
1780  getInt32: function Stream_getInt32() {
1781   var b0 = this.getByte();
1782   var b1 = this.getByte();
1783   var b2 = this.getByte();
1784   var b3 = this.getByte();
1785   return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1786  },
1787  getBytes: function Stream_getBytes(length) {
1788   var bytes = this.bytes;
1789   var pos = this.pos;
1790   var strEnd = this.end;
1791   if (!length) {
1792    return bytes.subarray(pos, strEnd);
1793   }
1794   var end = pos + length;
1795   if (end > strEnd) {
1796    end = strEnd;
1797   }
1798   this.pos = end;
1799   return bytes.subarray(pos, end);
1800  },
1801  peekByte: function Stream_peekByte() {
1802   var peekedByte = this.getByte();
1803   this.pos--;
1804   return peekedByte;
1805  },
1806  peekBytes: function Stream_peekBytes(length) {
1807   var bytes = this.getBytes(length);
1808   this.pos -= bytes.length;
1809   return bytes;
1810  },
1811  skip: function Stream_skip(n) {
1812   if (!n) {
1813    n = 1;
1814   }
1815   this.pos += n;
1816  },
1817  reset: function Stream_reset() {
1818   this.pos = this.start;
1819  },
1820  moveStart: function Stream_moveStart() {
1821   this.start = this.pos;
1822  },
1823  makeSubStream: function Stream_makeSubStream(start, length, dict) {
1824   return new Stream(this.bytes.buffer, start, length, dict);
1825  }
1826 };
1827 return Stream;
1828}();
1829var StringStream = function StringStreamClosure() {
1830 function StringStream(str) {
1831  var length = str.length;
1832  var bytes = new Uint8Array(length);
1833  for (var n = 0; n < length; ++n) {
1834   bytes[n] = str.charCodeAt(n);
1835  }
1836  Stream.call(this, bytes);
1837 }
1838 StringStream.prototype = Stream.prototype;
1839 return StringStream;
1840}();
1841var DecodeStream = function DecodeStreamClosure() {
1842 var emptyBuffer = new Uint8Array(0);
1843 function DecodeStream(maybeMinBufferLength) {
1844  this.pos = 0;
1845  this.bufferLength = 0;
1846  this.eof = false;
1847  this.buffer = emptyBuffer;
1848  this.minBufferLength = 512;
1849  if (maybeMinBufferLength) {
1850   while (this.minBufferLength < maybeMinBufferLength) {
1851    this.minBufferLength *= 2;
1852   }
1853  }
1854 }
1855 DecodeStream.prototype = {
1856  get isEmpty() {
1857   while (!this.eof && this.bufferLength === 0) {
1858    this.readBlock();
1859   }
1860   return this.bufferLength === 0;
1861  },
1862  ensureBuffer: function DecodeStream_ensureBuffer(requested) {
1863   var buffer = this.buffer;
1864   if (requested <= buffer.byteLength) {
1865    return buffer;
1866   }
1867   var size = this.minBufferLength;
1868   while (size < requested) {
1869    size *= 2;
1870   }
1871   var buffer2 = new Uint8Array(size);
1872   buffer2.set(buffer);
1873   return this.buffer = buffer2;
1874  },
1875  getByte: function DecodeStream_getByte() {
1876   var pos = this.pos;
1877   while (this.bufferLength <= pos) {
1878    if (this.eof) {
1879     return -1;
1880    }
1881    this.readBlock();
1882   }
1883   return this.buffer[this.pos++];
1884  },
1885  getUint16: function DecodeStream_getUint16() {
1886   var b0 = this.getByte();
1887   var b1 = this.getByte();
1888   if (b0 === -1 || b1 === -1) {
1889    return -1;
1890   }
1891   return (b0 << 8) + b1;
1892  },
1893  getInt32: function DecodeStream_getInt32() {
1894   var b0 = this.getByte();
1895   var b1 = this.getByte();
1896   var b2 = this.getByte();
1897   var b3 = this.getByte();
1898   return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
1899  },
1900  getBytes: function DecodeStream_getBytes(length) {
1901   var end, pos = this.pos;
1902   if (length) {
1903    this.ensureBuffer(pos + length);
1904    end = pos + length;
1905    while (!this.eof && this.bufferLength < end) {
1906     this.readBlock();
1907    }
1908    var bufEnd = this.bufferLength;
1909    if (end > bufEnd) {
1910     end = bufEnd;
1911    }
1912   } else {
1913    while (!this.eof) {
1914     this.readBlock();
1915    }
1916    end = this.bufferLength;
1917   }
1918   this.pos = end;
1919   return this.buffer.subarray(pos, end);
1920  },
1921  peekByte: function DecodeStream_peekByte() {
1922   var peekedByte = this.getByte();
1923   this.pos--;
1924   return peekedByte;
1925  },
1926  peekBytes: function DecodeStream_peekBytes(length) {
1927   var bytes = this.getBytes(length);
1928   this.pos -= bytes.length;
1929   return bytes;
1930  },
1931  makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
1932   var end = start + length;
1933   while (this.bufferLength <= end && !this.eof) {
1934    this.readBlock();
1935   }
1936   return new Stream(this.buffer, start, length, dict);
1937  },
1938  skip: function DecodeStream_skip(n) {
1939   if (!n) {
1940    n = 1;
1941   }
1942   this.pos += n;
1943  },
1944  reset: function DecodeStream_reset() {
1945   this.pos = 0;
1946  },
1947  getBaseStreams: function DecodeStream_getBaseStreams() {
1948   if (this.str && this.str.getBaseStreams) {
1949    return this.str.getBaseStreams();
1950   }
1951   return [];
1952  }
1953 };
1954 return DecodeStream;
1955}();
1956var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
1957 function StreamsSequenceStream(streams) {
1958  this.streams = streams;
1959  DecodeStream.call(this, null);
1960 }
1961 StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
1962 StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
1963  var streams = this.streams;
1964  if (streams.length === 0) {
1965   this.eof = true;
1966   return;
1967  }
1968  var stream = streams.shift();
1969  var chunk = stream.getBytes();
1970  var bufferLength = this.bufferLength;
1971  var newLength = bufferLength + chunk.length;
1972  var buffer = this.ensureBuffer(newLength);
1973  buffer.set(chunk, bufferLength);
1974  this.bufferLength = newLength;
1975 };
1976 StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
1977  var baseStreams = [];
1978  for (var i = 0, ii = this.streams.length; i < ii; i++) {
1979   var stream = this.streams[i];
1980   if (stream.getBaseStreams) {
1981    Util.appendToArray(baseStreams, stream.getBaseStreams());
1982   }
1983  }
1984  return baseStreams;
1985 };
1986 return StreamsSequenceStream;
1987}();
1988var FlateStream = function FlateStreamClosure() {
1989 var codeLenCodeMap = new Int32Array([
1990  16,
1991  17,
1992  18,
1993  0,
1994  8,
1995  7,
1996  9,
1997  6,
1998  10,
1999  5,
2000  11,
2001  4,
2002  12,
2003  3,
2004  13,
2005  2,
2006  14,
2007  1,
2008  15
2009 ]);
2010 var lengthDecode = new Int32Array([
2011  0x00003,
2012  0x00004,
2013  0x00005,
2014  0x00006,
2015  0x00007,
2016  0x00008,
2017  0x00009,
2018  0x0000a,
2019  0x1000b,
2020  0x1000d,
2021  0x1000f,
2022  0x10011,
2023  0x20013,
2024  0x20017,
2025  0x2001b,
2026  0x2001f,
2027  0x30023,
2028  0x3002b,
2029  0x30033,
2030  0x3003b,
2031  0x40043,
2032  0x40053,
2033  0x40063,
2034  0x40073,
2035  0x50083,
2036  0x500a3,
2037  0x500c3,
2038  0x500e3,
2039  0x00102,
2040  0x00102,
2041  0x00102
2042 ]);
2043 var distDecode = new Int32Array([
2044  0x00001,
2045  0x00002,
2046  0x00003,
2047  0x00004,
2048  0x10005,
2049  0x10007,
2050  0x20009,
2051  0x2000d,
2052  0x30011,
2053  0x30019,
2054  0x40021,
2055  0x40031,
2056  0x50041,
2057  0x50061,
2058  0x60081,
2059  0x600c1,
2060  0x70101,
2061  0x70181,
2062  0x80201,
2063  0x80301,
2064  0x90401,
2065  0x90601,
2066  0xa0801,
2067  0xa0c01,
2068  0xb1001,
2069  0xb1801,
2070  0xc2001,
2071  0xc3001,
2072  0xd4001,
2073  0xd6001
2074 ]);
2075 var fixedLitCodeTab = [
2076  new Int32Array([
2077   0x70100,
2078   0x80050,
2079   0x80010,
2080   0x80118,
2081   0x70110,
2082   0x80070,
2083   0x80030,
2084   0x900c0,
2085   0x70108,
2086   0x80060,
2087   0x80020,
2088   0x900a0,
2089   0x80000,
2090   0x80080,
2091   0x80040,
2092   0x900e0,
2093   0x70104,
2094   0x80058,
2095   0x80018,
2096   0x90090,
2097   0x70114,
2098   0x80078,
2099   0x80038,
2100   0x900d0,
2101   0x7010c,
2102   0x80068,
2103   0x80028,
2104   0x900b0,
2105   0x80008,
2106   0x80088,
2107   0x80048,
2108   0x900f0,
2109   0x70102,
2110   0x80054,
2111   0x80014,
2112   0x8011c,
2113   0x70112,
2114   0x80074,
2115   0x80034,
2116   0x900c8,
2117   0x7010a,
2118   0x80064,
2119   0x80024,
2120   0x900a8,
2121   0x80004,
2122   0x80084,
2123   0x80044,
2124   0x900e8,
2125   0x70106,
2126   0x8005c,
2127   0x8001c,
2128   0x90098,
2129   0x70116,
2130   0x8007c,
2131   0x8003c,
2132   0x900d8,
2133   0x7010e,
2134   0x8006c,
2135   0x8002c,
2136   0x900b8,
2137   0x8000c,
2138   0x8008c,
2139   0x8004c,
2140   0x900f8,
2141   0x70101,
2142   0x80052,
2143   0x80012,
2144   0x8011a,
2145   0x70111,
2146   0x80072,
2147   0x80032,
2148   0x900c4,
2149   0x70109,
2150   0x80062,
2151   0x80022,
2152   0x900a4,
2153   0x80002,
2154   0x80082,
2155   0x80042,
2156   0x900e4,
2157   0x70105,
2158   0x8005a,
2159   0x8001a,
2160   0x90094,
2161   0x70115,
2162   0x8007a,
2163   0x8003a,
2164   0x900d4,
2165   0x7010d,
2166   0x8006a,
2167   0x8002a,
2168   0x900b4,
2169   0x8000a,
2170   0x8008a,
2171   0x8004a,
2172   0x900f4,
2173   0x70103,
2174   0x80056,
2175   0x80016,
2176   0x8011e,
2177   0x70113,
2178   0x80076,
2179   0x80036,
2180   0x900cc,
2181   0x7010b,
2182   0x80066,
2183   0x80026,
2184   0x900ac,
2185   0x80006,
2186   0x80086,
2187   0x80046,
2188   0x900ec,
2189   0x70107,
2190   0x8005e,
2191   0x8001e,
2192   0x9009c,
2193   0x70117,
2194   0x8007e,
2195   0x8003e,
2196   0x900dc,
2197   0x7010f,
2198   0x8006e,
2199   0x8002e,
2200   0x900bc,
2201   0x8000e,
2202   0x8008e,
2203   0x8004e,
2204   0x900fc,
2205   0x70100,
2206   0x80051,
2207   0x80011,
2208   0x80119,
2209   0x70110,
2210   0x80071,
2211   0x80031,
2212   0x900c2,
2213   0x70108,
2214   0x80061,
2215   0x80021,
2216   0x900a2,
2217   0x80001,
2218   0x80081,
2219   0x80041,
2220   0x900e2,
2221   0x70104,
2222   0x80059,
2223   0x80019,
2224   0x90092,
2225   0x70114,
2226   0x80079,
2227   0x80039,
2228   0x900d2,
2229   0x7010c,
2230   0x80069,
2231   0x80029,
2232   0x900b2,
2233   0x80009,
2234   0x80089,
2235   0x80049,
2236   0x900f2,
2237   0x70102,
2238   0x80055,
2239   0x80015,
2240   0x8011d,
2241   0x70112,
2242   0x80075,
2243   0x80035,
2244   0x900ca,
2245   0x7010a,
2246   0x80065,
2247   0x80025,
2248   0x900aa,
2249   0x80005,
2250   0x80085,
2251   0x80045,
2252   0x900ea,
2253   0x70106,
2254   0x8005d,
2255   0x8001d,
2256   0x9009a,
2257   0x70116,
2258   0x8007d,
2259   0x8003d,
2260   0x900da,
2261   0x7010e,
2262   0x8006d,
2263   0x8002d,
2264   0x900ba,
2265   0x8000d,
2266   0x8008d,
2267   0x8004d,
2268   0x900fa,
2269   0x70101,
2270   0x80053,
2271   0x80013,
2272   0x8011b,
2273   0x70111,
2274   0x80073,
2275   0x80033,
2276   0x900c6,
2277   0x70109,
2278   0x80063,
2279   0x80023,
2280   0x900a6,
2281   0x80003,
2282   0x80083,
2283   0x80043,
2284   0x900e6,
2285   0x70105,
2286   0x8005b,
2287   0x8001b,
2288   0x90096,
2289   0x70115,
2290   0x8007b,
2291   0x8003b,
2292   0x900d6,
2293   0x7010d,
2294   0x8006b,
2295   0x8002b,
2296   0x900b6,
2297   0x8000b,
2298   0x8008b,
2299   0x8004b,
2300   0x900f6,
2301   0x70103,
2302   0x80057,
2303   0x80017,
2304   0x8011f,
2305   0x70113,
2306   0x80077,
2307   0x80037,
2308   0x900ce,
2309   0x7010b,
2310   0x80067,
2311   0x80027,
2312   0x900ae,
2313   0x80007,
2314   0x80087,
2315   0x80047,
2316   0x900ee,
2317   0x70107,
2318   0x8005f,
2319   0x8001f,
2320   0x9009e,
2321   0x70117,
2322   0x8007f,
2323   0x8003f,
2324   0x900de,
2325   0x7010f,
2326   0x8006f,
2327   0x8002f,
2328   0x900be,
2329   0x8000f,
2330   0x8008f,
2331   0x8004f,
2332   0x900fe,
2333   0x70100,
2334   0x80050,
2335   0x80010,
2336   0x80118,
2337   0x70110,
2338   0x80070,
2339   0x80030,
2340   0x900c1,
2341   0x70108,
2342   0x80060,
2343   0x80020,
2344   0x900a1,
2345   0x80000,
2346   0x80080,
2347   0x80040,
2348   0x900e1,
2349   0x70104,
2350   0x80058,
2351   0x80018,
2352   0x90091,
2353   0x70114,
2354   0x80078,
2355   0x80038,
2356   0x900d1,
2357   0x7010c,
2358   0x80068,
2359   0x80028,
2360   0x900b1,
2361   0x80008,
2362   0x80088,
2363   0x80048,
2364   0x900f1,
2365   0x70102,
2366   0x80054,
2367   0x80014,
2368   0x8011c,
2369   0x70112,
2370   0x80074,
2371   0x80034,
2372   0x900c9,
2373   0x7010a,
2374   0x80064,
2375   0x80024,
2376   0x900a9,
2377   0x80004,
2378   0x80084,
2379   0x80044,
2380   0x900e9,
2381   0x70106,
2382   0x8005c,
2383   0x8001c,
2384   0x90099,
2385   0x70116,
2386   0x8007c,
2387   0x8003c,
2388   0x900d9,
2389   0x7010e,
2390   0x8006c,
2391   0x8002c,
2392   0x900b9,
2393   0x8000c,
2394   0x8008c,
2395   0x8004c,
2396   0x900f9,
2397   0x70101,
2398   0x80052,
2399   0x80012,
2400   0x8011a,
2401   0x70111,
2402   0x80072,
2403   0x80032,
2404   0x900c5,
2405   0x70109,
2406   0x80062,
2407   0x80022,
2408   0x900a5,
2409   0x80002,
2410   0x80082,
2411   0x80042,
2412   0x900e5,
2413   0x70105,
2414   0x8005a,
2415   0x8001a,
2416   0x90095,
2417   0x70115,
2418   0x8007a,
2419   0x8003a,
2420   0x900d5,
2421   0x7010d,
2422   0x8006a,
2423   0x8002a,
2424   0x900b5,
2425   0x8000a,
2426   0x8008a,
2427   0x8004a,
2428   0x900f5,
2429   0x70103,
2430   0x80056,
2431   0x80016,
2432   0x8011e,
2433   0x70113,
2434   0x80076,
2435   0x80036,
2436   0x900cd,
2437   0x7010b,
2438   0x80066,
2439   0x80026,
2440   0x900ad,
2441   0x80006,
2442   0x80086,
2443   0x80046,
2444   0x900ed,
2445   0x70107,
2446   0x8005e,
2447   0x8001e,
2448   0x9009d,
2449   0x70117,
2450   0x8007e,
2451   0x8003e,
2452   0x900dd,
2453   0x7010f,
2454   0x8006e,
2455   0x8002e,
2456   0x900bd,
2457   0x8000e,
2458   0x8008e,
2459   0x8004e,
2460   0x900fd,
2461   0x70100,
2462   0x80051,
2463   0x80011,
2464   0x80119,
2465   0x70110,
2466   0x80071,
2467   0x80031,
2468   0x900c3,
2469   0x70108,
2470   0x80061,
2471   0x80021,
2472   0x900a3,
2473   0x80001,
2474   0x80081,
2475   0x80041,
2476   0x900e3,
2477   0x70104,
2478   0x80059,
2479   0x80019,
2480   0x90093,
2481   0x70114,
2482   0x80079,
2483   0x80039,
2484   0x900d3,
2485   0x7010c,
2486   0x80069,
2487   0x80029,
2488   0x900b3,
2489   0x80009,
2490   0x80089,
2491   0x80049,
2492   0x900f3,
2493   0x70102,
2494   0x80055,
2495   0x80015,
2496   0x8011d,
2497   0x70112,
2498   0x80075,
2499   0x80035,
2500   0x900cb,
2501   0x7010a,
2502   0x80065,
2503   0x80025,
2504   0x900ab,
2505   0x80005,
2506   0x80085,
2507   0x80045,
2508   0x900eb,
2509   0x70106,
2510   0x8005d,
2511   0x8001d,
2512   0x9009b,
2513   0x70116,
2514   0x8007d,
2515   0x8003d,
2516   0x900db,
2517   0x7010e,
2518   0x8006d,
2519   0x8002d,
2520   0x900bb,
2521   0x8000d,
2522   0x8008d,
2523   0x8004d,
2524   0x900fb,
2525   0x70101,
2526   0x80053,
2527   0x80013,
2528   0x8011b,
2529   0x70111,
2530   0x80073,
2531   0x80033,
2532   0x900c7,
2533   0x70109,
2534   0x80063,
2535   0x80023,
2536   0x900a7,
2537   0x80003,
2538   0x80083,
2539   0x80043,
2540   0x900e7,
2541   0x70105,
2542   0x8005b,
2543   0x8001b,
2544   0x90097,
2545   0x70115,
2546   0x8007b,
2547   0x8003b,
2548   0x900d7,
2549   0x7010d,
2550   0x8006b,
2551   0x8002b,
2552   0x900b7,
2553   0x8000b,
2554   0x8008b,
2555   0x8004b,
2556   0x900f7,
2557   0x70103,
2558   0x80057,
2559   0x80017,
2560   0x8011f,
2561   0x70113,
2562   0x80077,
2563   0x80037,
2564   0x900cf,
2565   0x7010b,
2566   0x80067,
2567   0x80027,
2568   0x900af,
2569   0x80007,
2570   0x80087,
2571   0x80047,
2572   0x900ef,
2573   0x70107,
2574   0x8005f,
2575   0x8001f,
2576   0x9009f,
2577   0x70117,
2578   0x8007f,
2579   0x8003f,
2580   0x900df,
2581   0x7010f,
2582   0x8006f,
2583   0x8002f,
2584   0x900bf,
2585   0x8000f,
2586   0x8008f,
2587   0x8004f,
2588   0x900ff
2589  ]),
2590  9
2591 ];
2592 var fixedDistCodeTab = [
2593  new Int32Array([
2594   0x50000,
2595   0x50010,
2596   0x50008,
2597   0x50018,
2598   0x50004,
2599   0x50014,
2600   0x5000c,
2601   0x5001c,
2602   0x50002,
2603   0x50012,
2604   0x5000a,
2605   0x5001a,
2606   0x50006,
2607   0x50016,
2608   0x5000e,
2609   0x00000,
2610   0x50001,
2611   0x50011,
2612   0x50009,
2613   0x50019,
2614   0x50005,
2615   0x50015,
2616   0x5000d,
2617   0x5001d,
2618   0x50003,
2619   0x50013,
2620   0x5000b,
2621   0x5001b,
2622   0x50007,
2623   0x50017,
2624   0x5000f,
2625   0x00000
2626  ]),
2627  5
2628 ];
2629 function FlateStream(str, maybeLength) {
2630  this.str = str;
2631  this.dict = str.dict;
2632  var cmf = str.getByte();
2633  var flg = str.getByte();
2634  if (cmf === -1 || flg === -1) {
2635   error('Invalid header in flate stream: ' + cmf + ', ' + flg);
2636  }
2637  if ((cmf & 0x0f) !== 0x08) {
2638   error('Unknown compression method in flate stream: ' + cmf + ', ' + flg);
2639  }
2640  if (((cmf << 8) + flg) % 31 !== 0) {
2641   error('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);
2642  }
2643  if (flg & 0x20) {
2644   error('FDICT bit set in flate stream: ' + cmf + ', ' + flg);
2645  }
2646  this.codeSize = 0;
2647  this.codeBuf = 0;
2648  DecodeStream.call(this, maybeLength);
2649 }
2650 FlateStream.prototype = Object.create(DecodeStream.prototype);
2651 FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
2652  var str = this.str;

2653  var codeSize = this.codeSize;
2654  var codeBuf = this.codeBuf;
2655  var b;
2656  while (codeSize < bits) {
2657   if ((b = str.getByte()) === -1) {
2658    error('Bad encoding in flate stream');
2659   }
2660   codeBuf |= b << codeSize;
2661   codeSize += 8;
2662  }
2663  b = codeBuf & (1 << bits) - 1;
2664  this.codeBuf = codeBuf >> bits;
2665  this.codeSize = codeSize -= bits;
2666  return b;
2667 };
2668 FlateStream.prototype.getCode = function FlateStream_getCode(table) {
2669  var str = this.str;
2670  var codes = table[0];
2671  var maxLen = table[1];
2672  var codeSize = this.codeSize;
2673  var codeBuf = this.codeBuf;
2674  var b;
2675  while (codeSize < maxLen) {
2676   if ((b = str.getByte()) === -1) {
2677    break;
2678   }
2679   codeBuf |= b << codeSize;
2680   codeSize += 8;
2681  }
2682  var code = codes[codeBuf & (1 << maxLen) - 1];
2683  var codeLen = code >> 16;
2684  var codeVal = code & 0xffff;
2685  if (codeLen < 1 || codeSize < codeLen) {
2686   error('Bad encoding in flate stream');
2687  }
2688  this.codeBuf = codeBuf >> codeLen;
2689  this.codeSize = codeSize - codeLen;
2690  return codeVal;
2691 };
2692 FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
2693  var n = lengths.length;
2694  var maxLen = 0;
2695  var i;
2696  for (i = 0; i < n; ++i) {
2697   if (lengths[i] > maxLen) {
2698    maxLen = lengths[i];
2699   }
2700  }
2701  var size = 1 << maxLen;
2702  var codes = new Int32Array(size);
2703  for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
2704   for (var val = 0; val < n; ++val) {
2705    if (lengths[val] === len) {
2706     var code2 = 0;
2707     var t = code;
2708     for (i = 0; i < len; ++i) {
2709      code2 = code2 << 1 | t & 1;
2710      t >>= 1;
2711     }
2712     for (i = code2; i < size; i += skip) {
2713      codes[i] = len << 16 | val;
2714     }
2715     ++code;
2716    }
2717   }
2718  }
2719  return [
2720   codes,
2721   maxLen
2722  ];
2723 };
2724 FlateStream.prototype.readBlock = function FlateStream_readBlock() {
2725  var buffer, len;
2726  var str = this.str;
2727  var hdr = this.getBits(3);
2728  if (hdr & 1) {
2729   this.eof = true;
2730  }
2731  hdr >>= 1;
2732  if (hdr === 0) {
2733   var b;
2734   if ((b = str.getByte()) === -1) {
2735    error('Bad block header in flate stream');
2736   }
2737   var blockLen = b;
2738   if ((b = str.getByte()) === -1) {
2739    error('Bad block header in flate stream');
2740   }
2741   blockLen |= b << 8;
2742   if ((b = str.getByte()) === -1) {
2743    error('Bad block header in flate stream');
2744   }
2745   var check = b;
2746   if ((b = str.getByte()) === -1) {
2747    error('Bad block header in flate stream');
2748   }
2749   check |= b << 8;
2750   if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
2751    error('Bad uncompressed block length in flate stream');
2752   }
2753   this.codeBuf = 0;
2754   this.codeSize = 0;
2755   var bufferLength = this.bufferLength;
2756   buffer = this.ensureBuffer(bufferLength + blockLen);
2757   var end = bufferLength + blockLen;
2758   this.bufferLength = end;
2759   if (blockLen === 0) {
2760    if (str.peekByte() === -1) {
2761     this.eof = true;
2762    }
2763   } else {
2764    for (var n = bufferLength; n < end; ++n) {
2765     if ((b = str.getByte()) === -1) {
2766      this.eof = true;
2767      break;
2768     }
2769     buffer[n] = b;
2770    }
2771   }
2772   return;
2773  }
2774  var litCodeTable;
2775  var distCodeTable;
2776  if (hdr === 1) {
2777   litCodeTable = fixedLitCodeTab;
2778   distCodeTable = fixedDistCodeTab;
2779  } else if (hdr === 2) {
2780   var numLitCodes = this.getBits(5) + 257;
2781   var numDistCodes = this.getBits(5) + 1;
2782   var numCodeLenCodes = this.getBits(4) + 4;
2783   var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
2784   var i;
2785   for (i = 0; i < numCodeLenCodes; ++i) {
2786    codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
2787   }
2788   var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
2789   len = 0;
2790   i = 0;
2791   var codes = numLitCodes + numDistCodes;
2792   var codeLengths = new Uint8Array(codes);
2793   var bitsLength, bitsOffset, what;
2794   while (i < codes) {
2795    var code = this.getCode(codeLenCodeTab);
2796    if (code === 16) {
2797     bitsLength = 2;
2798     bitsOffset = 3;
2799     what = len;
2800    } else if (code === 17) {
2801     bitsLength = 3;
2802     bitsOffset = 3;
2803     what = len = 0;
2804    } else if (code === 18) {
2805     bitsLength = 7;
2806     bitsOffset = 11;
2807     what = len = 0;
2808    } else {
2809     codeLengths[i++] = len = code;
2810     continue;
2811    }
2812    var repeatLength = this.getBits(bitsLength) + bitsOffset;
2813    while (repeatLength-- > 0) {
2814     codeLengths[i++] = what;
2815    }
2816   }
2817   litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
2818   distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
2819  } else {
2820   error('Unknown block type in flate stream');
2821  }
2822  buffer = this.buffer;
2823  var limit = buffer ? buffer.length : 0;
2824  var pos = this.bufferLength;
2825  while (true) {
2826   var code1 = this.getCode(litCodeTable);
2827   if (code1 < 256) {
2828    if (pos + 1 >= limit) {
2829     buffer = this.ensureBuffer(pos + 1);
2830     limit = buffer.length;
2831    }
2832    buffer[pos++] = code1;
2833    continue;
2834   }
2835   if (code1 === 256) {
2836    this.bufferLength = pos;
2837    return;
2838   }