From 73a1f30e12ba05c547b76e2d0c5b7b3ddbf0a2d3 Mon Sep 17 00:00:00 2001 From: pacien Date: Wed, 18 Jul 2018 21:57:03 +0200 Subject: Import third party lib --- pointless/pdfjs/pdf.js | 17511 ++++++++++++++++ pointless/pdfjs/pdf.worker.js | 45070 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 62581 insertions(+) create mode 100644 pointless/pdfjs/pdf.js create mode 100644 pointless/pdfjs/pdf.worker.js diff --git a/pointless/pdfjs/pdf.js b/pointless/pdfjs/pdf.js new file mode 100644 index 0000000..3d384bc --- /dev/null +++ b/pointless/pdfjs/pdf.js @@ -0,0 +1,17511 @@ +/** + * @licstart The following is the entire license notice for the + * Javascript code in this page + * + * Copyright 2017 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * @licend The above is the entire license notice for the + * Javascript code in this page + */ + +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define("pdfjs-dist/build/pdf", [], factory); + else if(typeof exports === 'object') + exports["pdfjs-dist/build/pdf"] = factory(); + else + root["pdfjs-dist/build/pdf"] = root.pdfjsLib = factory(); +})(typeof self !== 'undefined' ? self : this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __w_pdfjs_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __w_pdfjs_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __w_pdfjs_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __w_pdfjs_require__.d = function(exports, name, getter) { +/******/ if(!__w_pdfjs_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __w_pdfjs_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __w_pdfjs_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __w_pdfjs_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __w_pdfjs_require__(__w_pdfjs_require__.s = 60); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.unreachable = exports.warn = exports.utf8StringToString = exports.stringToUTF8String = exports.stringToPDFString = exports.stringToBytes = exports.string32 = exports.shadow = exports.setVerbosityLevel = exports.ReadableStream = exports.removeNullCharacters = exports.readUint32 = exports.readUint16 = exports.readInt8 = exports.log2 = exports.isEvalSupported = exports.isLittleEndian = exports.createValidAbsoluteUrl = exports.isSameOrigin = exports.isSpace = exports.isString = exports.isNum = exports.isEmptyObj = exports.isBool = exports.isArrayBuffer = exports.info = exports.getVerbosityLevel = exports.getLookupTableFactory = exports.getInheritableProperty = exports.deprecated = exports.createObjectURL = exports.createPromiseCapability = exports.createBlob = exports.bytesToString = exports.assert = exports.arraysToBytes = exports.arrayByteLength = exports.FormatError = exports.XRefParseException = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PasswordResponses = exports.PasswordException = exports.PageViewport = exports.NotImplementedException = exports.NativeImageDecoding = exports.MissingPDFException = exports.MissingDataException = exports.MessageHandler = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = undefined; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +__w_pdfjs_require__(61); + +var _streams_polyfill = __w_pdfjs_require__(115); + +var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0]; +var NativeImageDecoding = { + NONE: 'none', + DECODE: 'decode', + DISPLAY: 'display' +}; +var TextRenderingMode = { + FILL: 0, + STROKE: 1, + FILL_STROKE: 2, + INVISIBLE: 3, + FILL_ADD_TO_PATH: 4, + STROKE_ADD_TO_PATH: 5, + FILL_STROKE_ADD_TO_PATH: 6, + ADD_TO_PATH: 7, + FILL_STROKE_MASK: 3, + ADD_TO_PATH_FLAG: 4 +}; +var ImageKind = { + GRAYSCALE_1BPP: 1, + RGB_24BPP: 2, + RGBA_32BPP: 3 +}; +var AnnotationType = { + TEXT: 1, + LINK: 2, + FREETEXT: 3, + LINE: 4, + SQUARE: 5, + CIRCLE: 6, + POLYGON: 7, + POLYLINE: 8, + HIGHLIGHT: 9, + UNDERLINE: 10, + SQUIGGLY: 11, + STRIKEOUT: 12, + STAMP: 13, + CARET: 14, + INK: 15, + POPUP: 16, + FILEATTACHMENT: 17, + SOUND: 18, + MOVIE: 19, + WIDGET: 20, + SCREEN: 21, + PRINTERMARK: 22, + TRAPNET: 23, + WATERMARK: 24, + THREED: 25, + REDACT: 26 +}; +var AnnotationFlag = { + INVISIBLE: 0x01, + HIDDEN: 0x02, + PRINT: 0x04, + NOZOOM: 0x08, + NOROTATE: 0x10, + NOVIEW: 0x20, + READONLY: 0x40, + LOCKED: 0x80, + TOGGLENOVIEW: 0x100, + LOCKEDCONTENTS: 0x200 +}; +var AnnotationFieldFlag = { + READONLY: 0x0000001, + REQUIRED: 0x0000002, + NOEXPORT: 0x0000004, + MULTILINE: 0x0001000, + PASSWORD: 0x0002000, + NOTOGGLETOOFF: 0x0004000, + RADIO: 0x0008000, + PUSHBUTTON: 0x0010000, + COMBO: 0x0020000, + EDIT: 0x0040000, + SORT: 0x0080000, + FILESELECT: 0x0100000, + MULTISELECT: 0x0200000, + DONOTSPELLCHECK: 0x0400000, + DONOTSCROLL: 0x0800000, + COMB: 0x1000000, + RICHTEXT: 0x2000000, + RADIOSINUNISON: 0x2000000, + COMMITONSELCHANGE: 0x4000000 +}; +var AnnotationBorderStyleType = { + SOLID: 1, + DASHED: 2, + BEVELED: 3, + INSET: 4, + UNDERLINE: 5 +}; +var StreamType = { + UNKNOWN: 0, + FLATE: 1, + LZW: 2, + DCT: 3, + JPX: 4, + JBIG: 5, + A85: 6, + AHX: 7, + CCF: 8, + RL: 9 +}; +var FontType = { + UNKNOWN: 0, + TYPE1: 1, + TYPE1C: 2, + CIDFONTTYPE0: 3, + CIDFONTTYPE0C: 4, + TRUETYPE: 5, + CIDFONTTYPE2: 6, + TYPE3: 7, + OPENTYPE: 8, + TYPE0: 9, + MMTYPE1: 10 +}; +var VerbosityLevel = { + ERRORS: 0, + WARNINGS: 1, + INFOS: 5 +}; +var CMapCompressionType = { + NONE: 0, + BINARY: 1, + STREAM: 2 +}; +var OPS = { + dependency: 1, + setLineWidth: 2, + setLineCap: 3, + setLineJoin: 4, + setMiterLimit: 5, + setDash: 6, + setRenderingIntent: 7, + setFlatness: 8, + setGState: 9, + save: 10, + restore: 11, + transform: 12, + moveTo: 13, + lineTo: 14, + curveTo: 15, + curveTo2: 16, + curveTo3: 17, + closePath: 18, + rectangle: 19, + stroke: 20, + closeStroke: 21, + fill: 22, + eoFill: 23, + fillStroke: 24, + eoFillStroke: 25, + closeFillStroke: 26, + closeEOFillStroke: 27, + endPath: 28, + clip: 29, + eoClip: 30, + beginText: 31, + endText: 32, + setCharSpacing: 33, + setWordSpacing: 34, + setHScale: 35, + setLeading: 36, + setFont: 37, + setTextRenderingMode: 38, + setTextRise: 39, + moveText: 40, + setLeadingMoveText: 41, + setTextMatrix: 42, + nextLine: 43, + showText: 44, + showSpacedText: 45, + nextLineShowText: 46, + nextLineSetSpacingShowText: 47, + setCharWidth: 48, + setCharWidthAndBounds: 49, + setStrokeColorSpace: 50, + setFillColorSpace: 51, + setStrokeColor: 52, + setStrokeColorN: 53, + setFillColor: 54, + setFillColorN: 55, + setStrokeGray: 56, + setFillGray: 57, + setStrokeRGBColor: 58, + setFillRGBColor: 59, + setStrokeCMYKColor: 60, + setFillCMYKColor: 61, + shadingFill: 62, + beginInlineImage: 63, + beginImageData: 64, + endInlineImage: 65, + paintXObject: 66, + markPoint: 67, + markPointProps: 68, + beginMarkedContent: 69, + beginMarkedContentProps: 70, + endMarkedContent: 71, + beginCompat: 72, + endCompat: 73, + paintFormXObjectBegin: 74, + paintFormXObjectEnd: 75, + beginGroup: 76, + endGroup: 77, + beginAnnotations: 78, + endAnnotations: 79, + beginAnnotation: 80, + endAnnotation: 81, + paintJpegXObject: 82, + paintImageMaskXObject: 83, + paintImageMaskXObjectGroup: 84, + paintImageXObject: 85, + paintInlineImageXObject: 86, + paintInlineImageXObjectGroup: 87, + paintImageXObjectRepeat: 88, + paintImageMaskXObjectRepeat: 89, + paintSolidColorImageMask: 90, + constructPath: 91 +}; +var verbosity = VerbosityLevel.WARNINGS; +function setVerbosityLevel(level) { + if (Number.isInteger(level)) { + verbosity = level; + } +} +function getVerbosityLevel() { + return verbosity; +} +function info(msg) { + if (verbosity >= VerbosityLevel.INFOS) { + console.log('Info: ' + msg); + } +} +function warn(msg) { + if (verbosity >= VerbosityLevel.WARNINGS) { + console.log('Warning: ' + msg); + } +} +function deprecated(details) { + console.log('Deprecated API usage: ' + details); +} +function unreachable(msg) { + throw new Error(msg); +} +function assert(cond, msg) { + if (!cond) { + unreachable(msg); + } +} +var UNSUPPORTED_FEATURES = { + unknown: 'unknown', + forms: 'forms', + javaScript: 'javaScript', + smask: 'smask', + shadingPattern: 'shadingPattern', + font: 'font' +}; +function isSameOrigin(baseUrl, otherUrl) { + try { + var base = new URL(baseUrl); + if (!base.origin || base.origin === 'null') { + return false; + } + } catch (e) { + return false; + } + var other = new URL(otherUrl, base); + return base.origin === other.origin; +} +function isValidProtocol(url) { + if (!url) { + return false; + } + switch (url.protocol) { + case 'http:': + case 'https:': + case 'ftp:': + case 'mailto:': + case 'tel:': + return true; + default: + return false; + } +} +function createValidAbsoluteUrl(url, baseUrl) { + if (!url) { + return null; + } + try { + var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url); + if (isValidProtocol(absoluteUrl)) { + return absoluteUrl; + } + } catch (ex) {} + return null; +} +function shadow(obj, prop, value) { + Object.defineProperty(obj, prop, { + value: value, + enumerable: true, + configurable: true, + writable: false + }); + return value; +} +function getLookupTableFactory(initializer) { + var lookup; + return function () { + if (initializer) { + lookup = Object.create(null); + initializer(lookup); + initializer = null; + } + return lookup; + }; +} +var PasswordResponses = { + NEED_PASSWORD: 1, + INCORRECT_PASSWORD: 2 +}; +var PasswordException = function PasswordExceptionClosure() { + function PasswordException(msg, code) { + this.name = 'PasswordException'; + this.message = msg; + this.code = code; + } + PasswordException.prototype = new Error(); + PasswordException.constructor = PasswordException; + return PasswordException; +}(); +var UnknownErrorException = function UnknownErrorExceptionClosure() { + function UnknownErrorException(msg, details) { + this.name = 'UnknownErrorException'; + this.message = msg; + this.details = details; + } + UnknownErrorException.prototype = new Error(); + UnknownErrorException.constructor = UnknownErrorException; + return UnknownErrorException; +}(); +var InvalidPDFException = function InvalidPDFExceptionClosure() { + function InvalidPDFException(msg) { + this.name = 'InvalidPDFException'; + this.message = msg; + } + InvalidPDFException.prototype = new Error(); + InvalidPDFException.constructor = InvalidPDFException; + return InvalidPDFException; +}(); +var MissingPDFException = function MissingPDFExceptionClosure() { + function MissingPDFException(msg) { + this.name = 'MissingPDFException'; + this.message = msg; + } + MissingPDFException.prototype = new Error(); + MissingPDFException.constructor = MissingPDFException; + return MissingPDFException; +}(); +var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() { + function UnexpectedResponseException(msg, status) { + this.name = 'UnexpectedResponseException'; + this.message = msg; + this.status = status; + } + UnexpectedResponseException.prototype = new Error(); + UnexpectedResponseException.constructor = UnexpectedResponseException; + return UnexpectedResponseException; +}(); +var NotImplementedException = function NotImplementedExceptionClosure() { + function NotImplementedException(msg) { + this.message = msg; + } + NotImplementedException.prototype = new Error(); + NotImplementedException.prototype.name = 'NotImplementedException'; + NotImplementedException.constructor = NotImplementedException; + return NotImplementedException; +}(); +var MissingDataException = function MissingDataExceptionClosure() { + function MissingDataException(begin, end) { + this.begin = begin; + this.end = end; + this.message = 'Missing data [' + begin + ', ' + end + ')'; + } + MissingDataException.prototype = new Error(); + MissingDataException.prototype.name = 'MissingDataException'; + MissingDataException.constructor = MissingDataException; + return MissingDataException; +}(); +var XRefParseException = function XRefParseExceptionClosure() { + function XRefParseException(msg) { + this.message = msg; + } + XRefParseException.prototype = new Error(); + XRefParseException.prototype.name = 'XRefParseException'; + XRefParseException.constructor = XRefParseException; + return XRefParseException; +}(); +var FormatError = function FormatErrorClosure() { + function FormatError(msg) { + this.message = msg; + } + FormatError.prototype = new Error(); + FormatError.prototype.name = 'FormatError'; + FormatError.constructor = FormatError; + return FormatError; +}(); +var AbortException = function AbortExceptionClosure() { + function AbortException(msg) { + this.name = 'AbortException'; + this.message = msg; + } + AbortException.prototype = new Error(); + AbortException.constructor = AbortException; + return AbortException; +}(); +var NullCharactersRegExp = /\x00/g; +function removeNullCharacters(str) { + if (typeof str !== 'string') { + warn('The argument for removeNullCharacters must be a string.'); + return str; + } + return str.replace(NullCharactersRegExp, ''); +} +function bytesToString(bytes) { + assert(bytes !== null && (typeof bytes === 'undefined' ? 'undefined' : _typeof(bytes)) === 'object' && bytes.length !== undefined, 'Invalid argument for bytesToString'); + var length = bytes.length; + var MAX_ARGUMENT_COUNT = 8192; + if (length < MAX_ARGUMENT_COUNT) { + return String.fromCharCode.apply(null, bytes); + } + var strBuf = []; + for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) { + var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length); + var chunk = bytes.subarray(i, chunkEnd); + strBuf.push(String.fromCharCode.apply(null, chunk)); + } + return strBuf.join(''); +} +function stringToBytes(str) { + assert(typeof str === 'string', 'Invalid argument for stringToBytes'); + var length = str.length; + var bytes = new Uint8Array(length); + for (var i = 0; i < length; ++i) { + bytes[i] = str.charCodeAt(i) & 0xFF; + } + return bytes; +} +function arrayByteLength(arr) { + if (arr.length !== undefined) { + return arr.length; + } + assert(arr.byteLength !== undefined); + return arr.byteLength; +} +function arraysToBytes(arr) { + if (arr.length === 1 && arr[0] instanceof Uint8Array) { + return arr[0]; + } + var resultLength = 0; + var i, + ii = arr.length; + var item, itemLength; + for (i = 0; i < ii; i++) { + item = arr[i]; + itemLength = arrayByteLength(item); + resultLength += itemLength; + } + var pos = 0; + var data = new Uint8Array(resultLength); + for (i = 0; i < ii; i++) { + item = arr[i]; + if (!(item instanceof Uint8Array)) { + if (typeof item === 'string') { + item = stringToBytes(item); + } else { + item = new Uint8Array(item); + } + } + itemLength = item.byteLength; + data.set(item, pos); + pos += itemLength; + } + return data; +} +function string32(value) { + return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff); +} +function log2(x) { + if (x <= 0) { + return 0; + } + return Math.ceil(Math.log2(x)); +} +function readInt8(data, start) { + return data[start] << 24 >> 24; +} +function readUint16(data, offset) { + return data[offset] << 8 | data[offset + 1]; +} +function readUint32(data, offset) { + return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0; +} +function isLittleEndian() { + var buffer8 = new Uint8Array(4); + buffer8[0] = 1; + var view32 = new Uint32Array(buffer8.buffer, 0, 1); + return view32[0] === 1; +} +function isEvalSupported() { + try { + new Function(''); + return true; + } catch (e) { + return false; + } +} +function getInheritableProperty(_ref) { + var dict = _ref.dict, + key = _ref.key, + _ref$getArray = _ref.getArray, + getArray = _ref$getArray === undefined ? false : _ref$getArray, + _ref$stopWhenFound = _ref.stopWhenFound, + stopWhenFound = _ref$stopWhenFound === undefined ? true : _ref$stopWhenFound; + + var LOOP_LIMIT = 100; + var loopCount = 0; + var values = void 0; + while (dict) { + var value = getArray ? dict.getArray(key) : dict.get(key); + if (value !== undefined) { + if (stopWhenFound) { + return value; + } + if (!values) { + values = []; + } + values.push(value); + } + if (++loopCount > LOOP_LIMIT) { + warn('getInheritableProperty: maximum loop count exceeded for "' + key + '"'); + break; + } + dict = dict.get('Parent'); + } + return values; +} +var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]; +var Util = function UtilClosure() { + function Util() {} + var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')']; + Util.makeCssRgb = function Util_makeCssRgb(r, g, b) { + rgbBuf[1] = r; + rgbBuf[3] = g; + rgbBuf[5] = b; + return rgbBuf.join(''); + }; + Util.transform = function Util_transform(m1, m2) { + return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]]; + }; + Util.applyTransform = function Util_applyTransform(p, m) { + var xt = p[0] * m[0] + p[1] * m[2] + m[4]; + var yt = p[0] * m[1] + p[1] * m[3] + m[5]; + return [xt, yt]; + }; + Util.applyInverseTransform = function Util_applyInverseTransform(p, m) { + var d = m[0] * m[3] - m[1] * m[2]; + var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d; + var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d; + return [xt, yt]; + }; + Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) { + var p1 = Util.applyTransform(r, m); + var p2 = Util.applyTransform(r.slice(2, 4), m); + var p3 = Util.applyTransform([r[0], r[3]], m); + var p4 = Util.applyTransform([r[2], r[1]], m); + return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])]; + }; + Util.inverseTransform = function Util_inverseTransform(m) { + var d = m[0] * m[3] - m[1] * m[2]; + return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d]; + }; + Util.apply3dTransform = function Util_apply3dTransform(m, v) { + return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]; + }; + Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) { + var transpose = [m[0], m[2], m[1], m[3]]; + var a = m[0] * transpose[0] + m[1] * transpose[2]; + var b = m[0] * transpose[1] + m[1] * transpose[3]; + var c = m[2] * transpose[0] + m[3] * transpose[2]; + var d = m[2] * transpose[1] + m[3] * transpose[3]; + var first = (a + d) / 2; + var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2; + var sx = first + second || 1; + var sy = first - second || 1; + return [Math.sqrt(sx), Math.sqrt(sy)]; + }; + Util.normalizeRect = function Util_normalizeRect(rect) { + var r = rect.slice(0); + if (rect[0] > rect[2]) { + r[0] = rect[2]; + r[2] = rect[0]; + } + if (rect[1] > rect[3]) { + r[1] = rect[3]; + r[3] = rect[1]; + } + return r; + }; + Util.intersect = function Util_intersect(rect1, rect2) { + function compare(a, b) { + return a - b; + } + var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare), + orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare), + result = []; + rect1 = Util.normalizeRect(rect1); + rect2 = Util.normalizeRect(rect2); + if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) { + result[0] = orderedX[1]; + result[2] = orderedX[2]; + } else { + return false; + } + if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) { + result[1] = orderedY[1]; + result[3] = orderedY[2]; + } else { + return false; + } + return result; + }; + 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']; + Util.toRoman = function Util_toRoman(number, lowerCase) { + assert(Number.isInteger(number) && number > 0, 'The number should be a positive integer.'); + var pos, + romanBuf = []; + while (number >= 1000) { + number -= 1000; + romanBuf.push('M'); + } + pos = number / 100 | 0; + number %= 100; + romanBuf.push(ROMAN_NUMBER_MAP[pos]); + pos = number / 10 | 0; + number %= 10; + romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]); + romanBuf.push(ROMAN_NUMBER_MAP[20 + number]); + var romanStr = romanBuf.join(''); + return lowerCase ? romanStr.toLowerCase() : romanStr; + }; + Util.appendToArray = function Util_appendToArray(arr1, arr2) { + Array.prototype.push.apply(arr1, arr2); + }; + Util.prependToArray = function Util_prependToArray(arr1, arr2) { + Array.prototype.unshift.apply(arr1, arr2); + }; + Util.extendObj = function extendObj(obj1, obj2) { + for (var key in obj2) { + obj1[key] = obj2[key]; + } + }; + Util.inherit = function Util_inherit(sub, base, prototype) { + sub.prototype = Object.create(base.prototype); + sub.prototype.constructor = sub; + for (var prop in prototype) { + sub.prototype[prop] = prototype[prop]; + } + }; + Util.loadScript = function Util_loadScript(src, callback) { + var script = document.createElement('script'); + var loaded = false; + script.setAttribute('src', src); + if (callback) { + script.onload = function () { + if (!loaded) { + callback(); + } + loaded = true; + }; + } + document.getElementsByTagName('head')[0].appendChild(script); + }; + return Util; +}(); +var PageViewport = function PageViewportClosure() { + function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) { + this.viewBox = viewBox; + this.scale = scale; + this.rotation = rotation; + this.offsetX = offsetX; + this.offsetY = offsetY; + var centerX = (viewBox[2] + viewBox[0]) / 2; + var centerY = (viewBox[3] + viewBox[1]) / 2; + var rotateA, rotateB, rotateC, rotateD; + rotation = rotation % 360; + rotation = rotation < 0 ? rotation + 360 : rotation; + switch (rotation) { + case 180: + rotateA = -1; + rotateB = 0; + rotateC = 0; + rotateD = 1; + break; + case 90: + rotateA = 0; + rotateB = 1; + rotateC = 1; + rotateD = 0; + break; + case 270: + rotateA = 0; + rotateB = -1; + rotateC = -1; + rotateD = 0; + break; + default: + rotateA = 1; + rotateB = 0; + rotateC = 0; + rotateD = -1; + break; + } + if (dontFlip) { + rotateC = -rotateC; + rotateD = -rotateD; + } + var offsetCanvasX, offsetCanvasY; + var width, height; + if (rotateA === 0) { + offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX; + offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY; + width = Math.abs(viewBox[3] - viewBox[1]) * scale; + height = Math.abs(viewBox[2] - viewBox[0]) * scale; + } else { + offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX; + offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY; + width = Math.abs(viewBox[2] - viewBox[0]) * scale; + height = Math.abs(viewBox[3] - viewBox[1]) * scale; + } + this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY]; + this.width = width; + this.height = height; + this.fontScale = scale; + } + PageViewport.prototype = { + clone: function PageViewPort_clone(args) { + args = args || {}; + var scale = 'scale' in args ? args.scale : this.scale; + var rotation = 'rotation' in args ? args.rotation : this.rotation; + return new PageViewport(this.viewBox.slice(), scale, rotation, this.offsetX, this.offsetY, args.dontFlip); + }, + convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) { + return Util.applyTransform([x, y], this.transform); + }, + convertToViewportRectangle: function PageViewport_convertToViewportRectangle(rect) { + var tl = Util.applyTransform([rect[0], rect[1]], this.transform); + var br = Util.applyTransform([rect[2], rect[3]], this.transform); + return [tl[0], tl[1], br[0], br[1]]; + }, + convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) { + return Util.applyInverseTransform([x, y], this.transform); + } + }; + return PageViewport; +}(); +var PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC]; +function stringToPDFString(str) { + var i, + n = str.length, + strBuf = []; + if (str[0] === '\xFE' && str[1] === '\xFF') { + for (i = 2; i < n; i += 2) { + strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1))); + } + } else { + for (i = 0; i < n; ++i) { + var code = PDFStringTranslateTable[str.charCodeAt(i)]; + strBuf.push(code ? String.fromCharCode(code) : str.charAt(i)); + } + } + return strBuf.join(''); +} +function stringToUTF8String(str) { + return decodeURIComponent(escape(str)); +} +function utf8StringToString(str) { + return unescape(encodeURIComponent(str)); +} +function isEmptyObj(obj) { + for (var key in obj) { + return false; + } + return true; +} +function isBool(v) { + return typeof v === 'boolean'; +} +function isNum(v) { + return typeof v === 'number'; +} +function isString(v) { + return typeof v === 'string'; +} +function isArrayBuffer(v) { + return (typeof v === 'undefined' ? 'undefined' : _typeof(v)) === 'object' && v !== null && v.byteLength !== undefined; +} +function isSpace(ch) { + return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A; +} +function createPromiseCapability() { + var capability = {}; + capability.promise = new Promise(function (resolve, reject) { + capability.resolve = resolve; + capability.reject = reject; + }); + return capability; +} +var createBlob = function createBlob(data, contentType) { + if (typeof Blob !== 'undefined') { + return new Blob([data], { type: contentType }); + } + throw new Error('The "Blob" constructor is not supported.'); +}; +var createObjectURL = function createObjectURLClosure() { + var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + return function createObjectURL(data, contentType) { + var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + if (!forceDataSchema && URL.createObjectURL) { + var blob = createBlob(data, contentType); + return URL.createObjectURL(blob); + } + var buffer = 'data:' + contentType + ';base64,'; + for (var i = 0, ii = data.length; i < ii; i += 3) { + var b1 = data[i] & 0xFF; + var b2 = data[i + 1] & 0xFF; + var b3 = data[i + 2] & 0xFF; + var d1 = b1 >> 2, + d2 = (b1 & 3) << 4 | b2 >> 4; + var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64; + var d4 = i + 2 < ii ? b3 & 0x3F : 64; + buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4]; + } + return buffer; + }; +}(); +function resolveCall(fn, args) { + var thisArg = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + if (!fn) { + return Promise.resolve(undefined); + } + return new Promise(function (resolve, reject) { + resolve(fn.apply(thisArg, args)); + }); +} +function wrapReason(reason) { + if ((typeof reason === 'undefined' ? 'undefined' : _typeof(reason)) !== 'object') { + return reason; + } + switch (reason.name) { + case 'AbortException': + return new AbortException(reason.message); + case 'MissingPDFException': + return new MissingPDFException(reason.message); + case 'UnexpectedResponseException': + return new UnexpectedResponseException(reason.message, reason.status); + default: + return new UnknownErrorException(reason.message, reason.details); + } +} +function makeReasonSerializable(reason) { + if (!(reason instanceof Error) || reason instanceof AbortException || reason instanceof MissingPDFException || reason instanceof UnexpectedResponseException || reason instanceof UnknownErrorException) { + return reason; + } + return new UnknownErrorException(reason.message, reason.toString()); +} +function resolveOrReject(capability, success, reason) { + if (success) { + capability.resolve(); + } else { + capability.reject(reason); + } +} +function finalize(promise) { + return Promise.resolve(promise).catch(function () {}); +} +function MessageHandler(sourceName, targetName, comObj) { + var _this = this; + + this.sourceName = sourceName; + this.targetName = targetName; + this.comObj = comObj; + this.callbackId = 1; + this.streamId = 1; + this.postMessageTransfers = true; + this.streamSinks = Object.create(null); + this.streamControllers = Object.create(null); + var callbacksCapabilities = this.callbacksCapabilities = Object.create(null); + var ah = this.actionHandler = Object.create(null); + this._onComObjOnMessage = function (event) { + var data = event.data; + if (data.targetName !== _this.sourceName) { + return; + } + if (data.stream) { + _this._processStreamMessage(data); + } else if (data.isReply) { + var callbackId = data.callbackId; + if (data.callbackId in callbacksCapabilities) { + var callback = callbacksCapabilities[callbackId]; + delete callbacksCapabilities[callbackId]; + if ('error' in data) { + callback.reject(wrapReason(data.error)); + } else { + callback.resolve(data.data); + } + } else { + throw new Error('Cannot resolve callback ' + callbackId); + } + } else if (data.action in ah) { + var action = ah[data.action]; + if (data.callbackId) { + var _sourceName = _this.sourceName; + var _targetName = data.sourceName; + Promise.resolve().then(function () { + return action[0].call(action[1], data.data); + }).then(function (result) { + comObj.postMessage({ + sourceName: _sourceName, + targetName: _targetName, + isReply: true, + callbackId: data.callbackId, + data: result + }); + }, function (reason) { + comObj.postMessage({ + sourceName: _sourceName, + targetName: _targetName, + isReply: true, + callbackId: data.callbackId, + error: makeReasonSerializable(reason) + }); + }); + } else if (data.streamId) { + _this._createStreamSink(data); + } else { + action[0].call(action[1], data.data); + } + } else { + throw new Error('Unknown action from worker: ' + data.action); + } + }; + comObj.addEventListener('message', this._onComObjOnMessage); +} +MessageHandler.prototype = { + on: function on(actionName, handler, scope) { + var ah = this.actionHandler; + if (ah[actionName]) { + throw new Error('There is already an actionName called "' + actionName + '"'); + } + ah[actionName] = [handler, scope]; + }, + send: function send(actionName, data, transfers) { + var message = { + sourceName: this.sourceName, + targetName: this.targetName, + action: actionName, + data: data + }; + this.postMessage(message, transfers); + }, + sendWithPromise: function sendWithPromise(actionName, data, transfers) { + var callbackId = this.callbackId++; + var message = { + sourceName: this.sourceName, + targetName: this.targetName, + action: actionName, + data: data, + callbackId: callbackId + }; + var capability = createPromiseCapability(); + this.callbacksCapabilities[callbackId] = capability; + try { + this.postMessage(message, transfers); + } catch (e) { + capability.reject(e); + } + return capability.promise; + }, + sendWithStream: function sendWithStream(actionName, data, queueingStrategy, transfers) { + var _this2 = this; + + var streamId = this.streamId++; + var sourceName = this.sourceName; + var targetName = this.targetName; + return new _streams_polyfill.ReadableStream({ + start: function start(controller) { + var startCapability = createPromiseCapability(); + _this2.streamControllers[streamId] = { + controller: controller, + startCall: startCapability, + isClosed: false + }; + _this2.postMessage({ + sourceName: sourceName, + targetName: targetName, + action: actionName, + streamId: streamId, + data: data, + desiredSize: controller.desiredSize + }); + return startCapability.promise; + }, + pull: function pull(controller) { + var pullCapability = createPromiseCapability(); + _this2.streamControllers[streamId].pullCall = pullCapability; + _this2.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: 'pull', + streamId: streamId, + desiredSize: controller.desiredSize + }); + return pullCapability.promise; + }, + cancel: function cancel(reason) { + var cancelCapability = createPromiseCapability(); + _this2.streamControllers[streamId].cancelCall = cancelCapability; + _this2.streamControllers[streamId].isClosed = true; + _this2.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: 'cancel', + reason: reason, + streamId: streamId + }); + return cancelCapability.promise; + } + }, queueingStrategy); + }, + _createStreamSink: function _createStreamSink(data) { + var _this3 = this; + + var self = this; + var action = this.actionHandler[data.action]; + var streamId = data.streamId; + var desiredSize = data.desiredSize; + var sourceName = this.sourceName; + var targetName = data.sourceName; + var capability = createPromiseCapability(); + var sendStreamRequest = function sendStreamRequest(_ref2) { + var stream = _ref2.stream, + chunk = _ref2.chunk, + transfers = _ref2.transfers, + success = _ref2.success, + reason = _ref2.reason; + + _this3.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: stream, + streamId: streamId, + chunk: chunk, + success: success, + reason: reason + }, transfers); + }; + var streamSink = { + enqueue: function enqueue(chunk) { + var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var transfers = arguments[2]; + + if (this.isCancelled) { + return; + } + var lastDesiredSize = this.desiredSize; + this.desiredSize -= size; + if (lastDesiredSize > 0 && this.desiredSize <= 0) { + this.sinkCapability = createPromiseCapability(); + this.ready = this.sinkCapability.promise; + } + sendStreamRequest({ + stream: 'enqueue', + chunk: chunk, + transfers: transfers + }); + }, + close: function close() { + if (this.isCancelled) { + return; + } + this.isCancelled = true; + sendStreamRequest({ stream: 'close' }); + delete self.streamSinks[streamId]; + }, + error: function error(reason) { + if (this.isCancelled) { + return; + } + this.isCancelled = true; + sendStreamRequest({ + stream: 'error', + reason: reason + }); + }, + + sinkCapability: capability, + onPull: null, + onCancel: null, + isCancelled: false, + desiredSize: desiredSize, + ready: null + }; + streamSink.sinkCapability.resolve(); + streamSink.ready = streamSink.sinkCapability.promise; + this.streamSinks[streamId] = streamSink; + resolveCall(action[0], [data.data, streamSink], action[1]).then(function () { + sendStreamRequest({ + stream: 'start_complete', + success: true + }); + }, function (reason) { + sendStreamRequest({ + stream: 'start_complete', + success: false, + reason: reason + }); + }); + }, + _processStreamMessage: function _processStreamMessage(data) { + var _this4 = this; + + var sourceName = this.sourceName; + var targetName = data.sourceName; + var streamId = data.streamId; + var sendStreamResponse = function sendStreamResponse(_ref3) { + var stream = _ref3.stream, + success = _ref3.success, + reason = _ref3.reason; + + _this4.comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + stream: stream, + success: success, + streamId: streamId, + reason: reason + }); + }; + var deleteStreamController = function deleteStreamController() { + Promise.all([_this4.streamControllers[data.streamId].startCall, _this4.streamControllers[data.streamId].pullCall, _this4.streamControllers[data.streamId].cancelCall].map(function (capability) { + return capability && finalize(capability.promise); + })).then(function () { + delete _this4.streamControllers[data.streamId]; + }); + }; + switch (data.stream) { + case 'start_complete': + resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason)); + break; + case 'pull_complete': + resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason)); + break; + case 'pull': + if (!this.streamSinks[data.streamId]) { + sendStreamResponse({ + stream: 'pull_complete', + success: true + }); + break; + } + if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) { + this.streamSinks[data.streamId].sinkCapability.resolve(); + } + this.streamSinks[data.streamId].desiredSize = data.desiredSize; + resolveCall(this.streamSinks[data.streamId].onPull).then(function () { + sendStreamResponse({ + stream: 'pull_complete', + success: true + }); + }, function (reason) { + sendStreamResponse({ + stream: 'pull_complete', + success: false, + reason: reason + }); + }); + break; + case 'enqueue': + assert(this.streamControllers[data.streamId], 'enqueue should have stream controller'); + if (!this.streamControllers[data.streamId].isClosed) { + this.streamControllers[data.streamId].controller.enqueue(data.chunk); + } + break; + case 'close': + assert(this.streamControllers[data.streamId], 'close should have stream controller'); + if (this.streamControllers[data.streamId].isClosed) { + break; + } + this.streamControllers[data.streamId].isClosed = true; + this.streamControllers[data.streamId].controller.close(); + deleteStreamController(); + break; + case 'error': + assert(this.streamControllers[data.streamId], 'error should have stream controller'); + this.streamControllers[data.streamId].controller.error(wrapReason(data.reason)); + deleteStreamController(); + break; + case 'cancel_complete': + resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason)); + deleteStreamController(); + break; + case 'cancel': + if (!this.streamSinks[data.streamId]) { + break; + } + resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(function () { + sendStreamResponse({ + stream: 'cancel_complete', + success: true + }); + }, function (reason) { + sendStreamResponse({ + stream: 'cancel_complete', + success: false, + reason: reason + }); + }); + this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason)); + this.streamSinks[data.streamId].isCancelled = true; + delete this.streamSinks[data.streamId]; + break; + default: + throw new Error('Unexpected stream case'); + } + }, + postMessage: function postMessage(message, transfers) { + if (transfers && this.postMessageTransfers) { + this.comObj.postMessage(message, transfers); + } else { + this.comObj.postMessage(message); + } + }, + destroy: function destroy() { + this.comObj.removeEventListener('message', this._onComObjOnMessage); + } +}; +exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX; +exports.IDENTITY_MATRIX = IDENTITY_MATRIX; +exports.OPS = OPS; +exports.VerbosityLevel = VerbosityLevel; +exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES; +exports.AnnotationBorderStyleType = AnnotationBorderStyleType; +exports.AnnotationFieldFlag = AnnotationFieldFlag; +exports.AnnotationFlag = AnnotationFlag; +exports.AnnotationType = AnnotationType; +exports.FontType = FontType; +exports.ImageKind = ImageKind; +exports.CMapCompressionType = CMapCompressionType; +exports.AbortException = AbortException; +exports.InvalidPDFException = InvalidPDFException; +exports.MessageHandler = MessageHandler; +exports.MissingDataException = MissingDataException; +exports.MissingPDFException = MissingPDFException; +exports.NativeImageDecoding = NativeImageDecoding; +exports.NotImplementedException = NotImplementedException; +exports.PageViewport = PageViewport; +exports.PasswordException = PasswordException; +exports.PasswordResponses = PasswordResponses; +exports.StreamType = StreamType; +exports.TextRenderingMode = TextRenderingMode; +exports.UnexpectedResponseException = UnexpectedResponseException; +exports.UnknownErrorException = UnknownErrorException; +exports.Util = Util; +exports.XRefParseException = XRefParseException; +exports.FormatError = FormatError; +exports.arrayByteLength = arrayByteLength; +exports.arraysToBytes = arraysToBytes; +exports.assert = assert; +exports.bytesToString = bytesToString; +exports.createBlob = createBlob; +exports.createPromiseCapability = createPromiseCapability; +exports.createObjectURL = createObjectURL; +exports.deprecated = deprecated; +exports.getInheritableProperty = getInheritableProperty; +exports.getLookupTableFactory = getLookupTableFactory; +exports.getVerbosityLevel = getVerbosityLevel; +exports.info = info; +exports.isArrayBuffer = isArrayBuffer; +exports.isBool = isBool; +exports.isEmptyObj = isEmptyObj; +exports.isNum = isNum; +exports.isString = isString; +exports.isSpace = isSpace; +exports.isSameOrigin = isSameOrigin; +exports.createValidAbsoluteUrl = createValidAbsoluteUrl; +exports.isLittleEndian = isLittleEndian; +exports.isEvalSupported = isEvalSupported; +exports.log2 = log2; +exports.readInt8 = readInt8; +exports.readUint16 = readUint16; +exports.readUint32 = readUint32; +exports.removeNullCharacters = removeNullCharacters; +exports.ReadableStream = _streams_polyfill.ReadableStream; +exports.setVerbosityLevel = setVerbosityLevel; +exports.shadow = shadow; +exports.string32 = string32; +exports.stringToBytes = stringToBytes; +exports.stringToPDFString = stringToPDFString; +exports.stringToUTF8String = stringToUTF8String; +exports.utf8StringToString = utf8StringToString; +exports.warn = warn; +exports.unreachable = unreachable; + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var store = __w_pdfjs_require__(42)('wks'); +var uid = __w_pdfjs_require__(19); +var _Symbol = __w_pdfjs_require__(4).Symbol; +var USE_SYMBOL = typeof _Symbol == 'function'; +var $exports = module.exports = function (name) { + return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : uid)('Symbol.' + name)); +}; +$exports.store = store; + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +module.exports = function (it) { + return (typeof it === 'undefined' ? 'undefined' : _typeof(it)) === 'object' ? it !== null : typeof it === 'function'; +}; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var global = __w_pdfjs_require__(4); +var core = __w_pdfjs_require__(5); +var hide = __w_pdfjs_require__(10); +var redefine = __w_pdfjs_require__(7); +var ctx = __w_pdfjs_require__(9); +var PROTOTYPE = 'prototype'; +var $export = function $export(type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]; + var exports = IS_GLOBAL ? core : core[name] || (core[name] = {}); + var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); + var key, own, out, exp; + if (IS_GLOBAL) source = name; + for (key in source) { + own = !IS_FORCED && target && target[key] !== undefined; + out = (own ? target : source)[key]; + exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + if (target) redefine(target, key, out, type & $export.U); + if (exports[key] != out) hide(exports, key, exp); + if (IS_PROTO && expProto[key] != out) expProto[key] = out; + } +}; +global.core = core; +$export.F = 1; +$export.G = 2; +$export.S = 4; +$export.P = 8; +$export.B = 16; +$export.W = 32; +$export.U = 64; +$export.R = 128; +module.exports = $export; + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); +if (typeof __g == 'number') __g = global; + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var core = module.exports = { version: '2.5.5' }; +if (typeof __e == 'number') __e = core; + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var isObject = __w_pdfjs_require__(2); +module.exports = function (it) { + if (!isObject(it)) throw TypeError(it + ' is not an object!'); + return it; +}; + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var global = __w_pdfjs_require__(4); +var hide = __w_pdfjs_require__(10); +var has = __w_pdfjs_require__(8); +var SRC = __w_pdfjs_require__(19)('src'); +var TO_STRING = 'toString'; +var $toString = Function[TO_STRING]; +var TPL = ('' + $toString).split(TO_STRING); +__w_pdfjs_require__(5).inspectSource = function (it) { + return $toString.call(it); +}; +(module.exports = function (O, key, val, safe) { + var isFunction = typeof val == 'function'; + if (isFunction) has(val, 'name') || hide(val, 'name', key); + if (O[key] === val) return; + if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); + if (O === global) { + O[key] = val; + } else if (!safe) { + delete O[key]; + hide(O, key, val); + } else if (O[key]) { + O[key] = val; + } else { + hide(O, key, val); + } +})(Function.prototype, TO_STRING, function toString() { + return typeof this == 'function' && this[SRC] || $toString.call(this); +}); + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var hasOwnProperty = {}.hasOwnProperty; +module.exports = function (it, key) { + return hasOwnProperty.call(it, key); +}; + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var aFunction = __w_pdfjs_require__(15); +module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 1: + return function (a) { + return fn.call(that, a); + }; + case 2: + return function (a, b) { + return fn.call(that, a, b); + }; + case 3: + return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function () { + return fn.apply(that, arguments); + }; +}; + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var dP = __w_pdfjs_require__(14); +var createDesc = __w_pdfjs_require__(27); +module.exports = __w_pdfjs_require__(11) ? function (object, key, value) { + return dP.f(object, key, createDesc(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = !__w_pdfjs_require__(12)(function () { + return Object.defineProperty({}, 'a', { + get: function get() { + return 7; + } + }).a != 7; +}); + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = function (exec) { + try { + return !!exec(); + } catch (e) { + return true; + } +}; + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var toString = {}.toString; +module.exports = function (it) { + return toString.call(it).slice(8, -1); +}; + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var anObject = __w_pdfjs_require__(6); +var IE8_DOM_DEFINE = __w_pdfjs_require__(40); +var toPrimitive = __w_pdfjs_require__(41); +var dP = Object.defineProperty; +exports.f = __w_pdfjs_require__(11) ? Object.defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return dP(O, P, Attributes); + } catch (e) {} + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = function (it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; +}; + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var IObject = __w_pdfjs_require__(28); +var defined = __w_pdfjs_require__(20); +module.exports = function (it) { + return IObject(defined(it)); +}; + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = {}; + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = typeof window !== 'undefined' && window.Math === Math ? window : typeof global !== 'undefined' && global.Math === Math ? global : typeof self !== 'undefined' && self.Math === Math ? self : {}; + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var id = 0; +var px = Math.random(); +module.exports = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); +}; + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var $keys = __w_pdfjs_require__(83); +var enumBugKeys = __w_pdfjs_require__(48); +module.exports = Object.keys || function keys(O) { + return $keys(O, enumBugKeys); +}; + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var def = __w_pdfjs_require__(14).f; +var has = __w_pdfjs_require__(8); +var TAG = __w_pdfjs_require__(1)('toStringTag'); +module.exports = function (it, tag, stat) { + if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { + configurable: true, + value: tag + }); +}; + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +var ctx = __w_pdfjs_require__(9); +var call = __w_pdfjs_require__(88); +var isArrayIter = __w_pdfjs_require__(89); +var anObject = __w_pdfjs_require__(6); +var toLength = __w_pdfjs_require__(29); +var getIterFn = __w_pdfjs_require__(90); +var BREAK = {}; +var RETURN = {}; +var _exports = module.exports = function (iterable, entries, fn, that, ITERATOR) { + var iterFn = ITERATOR ? function () { + return iterable; + } : getIterFn(iterable); + var f = ctx(fn, that, entries ? 2 : 1); + var index = 0; + var length, step, iterator, result; + if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!'); + if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) { + result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); + if (result === BREAK || result === RETURN) return result; + } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) { + result = call(iterator, f, step.value, entries); + if (result === BREAK || result === RETURN) return result; + } +}; +_exports.BREAK = BREAK; +_exports.RETURN = RETURN; + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __w_pdfjs_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.DummyStatTimer = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.getFilenameFromUrl = exports.addLinkAttributes = exports.RenderingCancelledException = undefined; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _util = __w_pdfjs_require__(0); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var DEFAULT_LINK_REL = 'noopener noreferrer nofollow'; +var SVG_NS = 'http://www.w3.org/2000/svg'; + +var DOMCanvasFactory = function () { + function DOMCanvasFactory() { + _classCallCheck(this, DOMCanvasFactory); + } + + _createClass(DOMCanvasFactory, [{ + key: 'create', + value: function create(width, height) { + if (width <= 0 || height <= 0) { + throw new Error('invalid canvas size'); + } + var canvas = document.createElement('canvas'); + var context = canvas.getContext('2d'); + canvas.width = width; + canvas.height = height; + return { + canvas: canvas, + context: context + }; + } + }, { + key: 'reset', + value: function reset(canvasAndContext, width, height) { + if (!canvasAndContext.canvas) { + throw new Error('canvas is not specified'); + } + if (width <= 0 || height <= 0) { + throw new Error('invalid canvas size'); + } + canvasAndContext.canvas.width = width; + canvasAndContext.canvas.height = height; + } + }, { + key: 'destroy', + value: function destroy(canvasAndContext) { + if (!canvasAndContext.canvas) { + throw new Error('canvas is not specified'); + } + canvasAndContext.canvas.width = 0; + canvasAndContext.canvas.height = 0; + canvasAndContext.canvas = null; + canvasAndContext.context = null; + } + }]); + + return DOMCanvasFactory; +}(); + +var DOMCMapReaderFactory = function () { + function DOMCMapReaderFactory(_ref) { + var _ref$baseUrl = _ref.baseUrl, + baseUrl = _ref$baseUrl === undefined ? null : _ref$baseUrl, + _ref$isCompressed = _ref.isCompressed, + isCompressed = _ref$isCompressed === undefined ? false : _ref$isCompressed; + + _classCallCheck(this, DOMCMapReaderFactory); + + this.baseUrl = baseUrl; + this.isCompressed = isCompressed; + } + + _createClass(DOMCMapReaderFactory, [{ + key: 'fetch', + value: function fetch(_ref2) { + var _this = this; + + var name = _ref2.name; + + if (!this.baseUrl) { + return Promise.reject(new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.')); + } + if (!name) { + return Promise.reject(new Error('CMap name must be specified.')); + } + return new Promise(function (resolve, reject) { + var url = _this.baseUrl + name + (_this.isCompressed ? '.bcmap' : ''); + var request = new XMLHttpRequest(); + request.open('GET', url, true); + if (_this.isCompressed) { + request.responseType = 'arraybuffer'; + } + request.onreadystatechange = function () { + if (request.readyState !== XMLHttpRequest.DONE) { + return; + } + if (request.status === 200 || request.status === 0) { + var data = void 0; + if (_this.isCompressed && request.response) { + data = new Uint8Array(request.response); + } else if (!_this.isCompressed && request.responseText) { + data = (0, _util.stringToBytes)(request.responseText); + } + if (data) { + resolve({ + cMapData: data, + compressionType: _this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE + }); + return; + } + } + reject(new Error('Unable to load ' + (_this.isCompressed ? 'binary ' : '') + 'CMap at: ' + url)); + }; + request.send(null); + }); + } + }]); + + return DOMCMapReaderFactory; +}(); + +var DOMSVGFactory = function () { + function DOMSVGFactory() { + _classCallCheck(this, DOMSVGFactory); + } + + _createClass(DOMSVGFactory, [{ + key: 'create', + value: function create(width, height) { + (0, _util.assert)(width > 0 && height > 0, 'Invalid SVG dimensions'); + var svg = document.createElementNS(SVG_NS, 'svg:svg'); + svg.setAttribute('version', '1.1'); + svg.setAttribute('width', width + 'px'); + svg.setAttribute('height', height + 'px'); + svg.setAttribute('preserveAspectRatio', 'none'); + svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height); + return svg; + } + }, { + key: 'createElement', + value: function createElement(type) { + (0, _util.assert)(typeof type === 'string', 'Invalid SVG element type'); + return document.createElementNS(SVG_NS, type); + } + }]); + + return DOMSVGFactory; +}(); + +var RenderingCancelledException = function RenderingCancelledException() { + function RenderingCancelledException(msg, type) { + this.message = msg; + this.type = type; + } + RenderingCancelledException.prototype = new Error(); + RenderingCancelledException.prototype.name = 'RenderingCancelledException'; + RenderingCancelledException.constructor = RenderingCancelledException; + return RenderingCancelledException; +}(); +var LinkTarget = { + NONE: 0, + SELF: 1, + BLANK: 2, + PARENT: 3, + TOP: 4 +}; +var LinkTargetStringMap = ['', '_self', '_blank'