0% found this document useful (0 votes)

36K views248 pages

Viewer

Uploaded by

PortalCAD

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

36K views248 pages

Viewer

Uploaded by

PortalCAD

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

You are on page 1/ 248

/* 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.
*/

(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.pdfjsDistBuildPdf = factory();
})(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;
/******/
/******/ // identity function for calling harmony imports with the correct
context
/******/ __w_pdfjs_require__.i = function(value) { return value; };
/******/
/******/ // 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 = 15);
/******/ })
/************************************************************************/
/******/ ([
/* 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.loadJpegStream =
exports.isEvalSupported = exports.isLittleEndian = exports.createValidAbsoluteUrl =
exports.isSameOrigin = exports.isNodeJS = exports.isSpace = exports.isString =
exports.isNum = exports.isInt = exports.isEmptyObj = exports.isBool =
exports.isArrayBuffer = exports.isArray = exports.info = exports.globalScope =
exports.getVerbosityLevel = exports.getLookupTableFactory = 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.StatTimer =
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.VERBOSITY_LEVELS = 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__(16);

var _streams_polyfill = __w_pdfjs_require__(17);

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 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) {
if (reason instanceof Error) {
reason = reason + '';
}
comObj.postMessage({
sourceName: _sourceName,
targetName: _targetName,
isReply: true,
callbackId: data.callbackId,
error: 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 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(_ref) {
var stream = _ref.stream,
chunk = _ref.chunk,
transfers = _ref.transfers,
success = _ref.success,
reason = _ref.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;
}
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(_ref2) {
var stream = _ref2.stream,
success = _ref2.success,
reason = _ref2.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);
}
};
function loadJpegStream(id, imageUrl, objs) {
var img = new Image();
img.onload = function loadJpegStream_onloadClosure() {
objs.resolve(id, img);
};
img.onerror = function loadJpegStream_onerrorClosure() {
objs.resolve(id, null);
warn('Error during JPEG image loading');
};
img.src = imageUrl;
}
exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
exports.OPS = OPS;
exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
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.StatTimer = StatTimer;
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.getLookupTableFactory = getLookupTableFactory;
exports.getVerbosityLevel = getVerbosityLevel;
exports.globalScope = globalScope;
exports.info = info;
exports.isArray = isArray;
exports.isArrayBuffer = isArrayBuffer;
exports.isBool = isBool;
exports.isEmptyObj = isEmptyObj;
exports.isInt = isInt;
exports.isNum = isNum;
exports.isString = isString;
exports.isSpace = isSpace;
exports.isNodeJS = isNodeJS;
exports.isSameOrigin = isSameOrigin;
exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
exports.isLittleEndian = isLittleEndian;
exports.isEvalSupported = isEvalSupported;
exports.loadJpegStream = loadJpegStream;
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";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL
= exports.getDefaultSetting = exports.LinkTarget = exports.getFilenameFromUrl =
exports.isValidUrl = exports.isExternalLinkTargetSet = exports.addLinkAttributes =
exports.RenderingCancelledException = exports.CustomStyle = 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 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 (!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 CustomStyle = function CustomStyleClosure() {

/***/ }),
/* 2 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.build = exports.version = exports._UnsupportedManager =
exports.setPDFNetworkStreamClass = exports.PDFPageProxy = exports.PDFDocumentProxy
= exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort =
exports.getDocument = 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);

var _dom_utils = __w_pdfjs_require__(1);

var _font_loader = __w_pdfjs_require__(12);

var _canvas = __w_pdfjs_require__(11);

var _metadata = __w_pdfjs_require__(6);

var _transport_stream = __w_pdfjs_require__(14);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof

Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DEFAULT_RANGE_CHUNK_SIZE = 65536;

this.destroyed = true;
var transportDestroyed = !this._transport ? Promise.resolve() :
this._transport.destroy();
return transportDestroyed.then(function () {
_this._transport = null;
if (_this._worker) {
_this._worker.destroy();
_this._worker = null;
}
});
},

then: function PDFDocumentLoadingTask_then(onFulfilled, onRejected) {

return this.promise.then.apply(this.promise, arguments);
}
};
return PDFDocumentLoadingTask;
}();
var PDFDataRangeTransport = function pdfDataRangeTransportClosure() {
function PDFDataRangeTransport(length, initialData) {
this.length = length;
this.initialData = initialData;
this._rangeListeners = [];
this._progressListeners = [];
this._progressiveReadListeners = [];
this._readyCapability = (0, _util.createPromiseCapability)();
}
PDFDataRangeTransport.prototype = {
addRangeListener: function PDFDataRangeTransport_addRangeListener(listener) {
this._rangeListeners.push(listener);
},
addProgressListener: function
PDFDataRangeTransport_addProgressListener(listener) {
this._progressListeners.push(listener);
},
addProgressiveReadListener: function
PDFDataRangeTransport_addProgressiveReadListener(listener) {
this._progressiveReadListeners.push(listener);
},
onDataRange: function PDFDataRangeTransport_onDataRange(begin, chunk) {
var listeners = this._rangeListeners;
for (var i = 0, n = listeners.length; i < n; ++i) {
listeners[i](begin, chunk);
}
},
onDataProgress: function PDFDataRangeTransport_onDataProgress(loaded) {
var _this2 = this;

this._readyCapability.promise.then(function () {
var listeners = _this2._progressListeners;
for (var i = 0, n = listeners.length; i < n; ++i) {
listeners[i](loaded);
}
});
},
onDataProgressiveRead: function PDFDataRangeTransport_onDataProgress(chunk) {
var _this3 = this;

this._readyCapability.promise.then(function () {
var listeners = _this3._progressiveReadListeners;
for (var i = 0, n = listeners.length; i < n; ++i) {
listeners[i](chunk);
}
});
},
transportReady: function PDFDataRangeTransport_transportReady() {
this._readyCapability.resolve();
},
requestDataRange: function PDFDataRangeTransport_requestDataRange(begin, end) {
throw new Error('Abstract method PDFDataRangeTransport.requestDataRange');
},
abort: function PDFDataRangeTransport_abort() {}
};
return PDFDataRangeTransport;
}();
var PDFDocumentProxy = function PDFDocumentProxyClosure() {
function PDFDocumentProxy(pdfInfo, transport, loadingTask) {
this.pdfInfo = pdfInfo;
this.transport = transport;
this.loadingTask = loadingTask;
}
PDFDocumentProxy.prototype = {
get numPages() {
return this.pdfInfo.numPages;
},
get fingerprint() {
return this.pdfInfo.fingerprint;
},
getPage: function PDFDocumentProxy_getPage(pageNumber) {
return this.transport.getPage(pageNumber);
},
getPageIndex: function PDFDocumentProxy_getPageIndex(ref) {
return this.transport.getPageIndex(ref);
},
getDestinations: function PDFDocumentProxy_getDestinations() {
return this.transport.getDestinations();
},
getDestination: function PDFDocumentProxy_getDestination(id) {
return this.transport.getDestination(id);
},
getPageLabels: function PDFDocumentProxy_getPageLabels() {
return this.transport.getPageLabels();
},
getPageMode: function getPageMode() {
return this.transport.getPageMode();
},

getAttachments: function PDFDocumentProxy_getAttachments() {

return this.transport.getAttachments();
},
getJavaScript: function PDFDocumentProxy_getJavaScript() {
return this.transport.getJavaScript();
},
getOutline: function PDFDocumentProxy_getOutline() {
return this.transport.getOutline();
},
getMetadata: function PDFDocumentProxy_getMetadata() {
return this.transport.getMetadata();
},
getData: function PDFDocumentProxy_getData() {
return this.transport.getData();
},
getDownloadInfo: function PDFDocumentProxy_getDownloadInfo() {
return this.transport.downloadInfoCapability.promise;
},
getStats: function PDFDocumentProxy_getStats() {
return this.transport.getStats();
},
cleanup: function PDFDocumentProxy_cleanup() {
this.transport.startCleanup();
},
destroy: function PDFDocumentProxy_destroy() {
return this.loadingTask.destroy();
}
};
return PDFDocumentProxy;
}();
var PDFPageProxy = function PDFPageProxyClosure() {
function PDFPageProxy(pageIndex, pageInfo, transport) {
this.pageIndex = pageIndex;
this.pageInfo = pageInfo;
this.transport = transport;
this.stats = new _util.StatTimer();
this.stats.enabled = (0, _dom_utils.getDefaultSetting)('enableStats');
this.commonObjs = transport.commonObjs;
this.objs = new PDFObjects();
this.cleanupAfterRender = false;
this.pendingCleanup = false;
this.intentStates = Object.create(null);
this.destroyed = false;
}
PDFPageProxy.prototype = {
get pageNumber() {
return this.pageIndex + 1;
},
get rotate() {
return this.pageInfo.rotate;
},
get ref() {
return this.pageInfo.ref;
},
get userUnit() {
return this.pageInfo.userUnit;
},
get view() {
return this.pageInfo.view;
},
getViewport: function PDFPageProxy_getViewport(scale, rotate) {
if (arguments.length < 2) {
rotate = this.rotate;
}
return new _util.PageViewport(this.view, scale, rotate, 0, 0);
},
getAnnotations: function PDFPageProxy_getAnnotations(params) {
var intent = params && params.intent || null;
if (!this.annotationsPromise || this.annotationsIntent !== intent) {
this.annotationsPromise = this.transport.getAnnotations(this.pageIndex,
intent);
this.annotationsIntent = intent;
}
return this.annotationsPromise;
},
render: function PDFPageProxy_render(params) {
var _this4 = this;

var stats = this.stats;

stats.time('Overall');
this.pendingCleanup = false;
var renderingIntent = params.intent === 'print' ? 'print' : 'display';
var canvasFactory = params.canvasFactory || new
_dom_utils.DOMCanvasFactory();
if (!this.intentStates[renderingIntent]) {
this.intentStates[renderingIntent] = Object.create(null);
}
var intentState = this.intentStates[renderingIntent];
if (!intentState.displayReadyCapability) {
intentState.receivingOperatorList = true;
intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
intentState.operatorList = {
fnArray: [],
argsArray: [],
lastChunk: false
};
this.stats.time('Page Request');
this.transport.messageHandler.send('RenderPageRequest', {
pageIndex: this.pageNumber - 1,
intent: renderingIntent,
renderInteractiveForms: params.renderInteractiveForms === true
});
}
var complete = function complete(error) {
var i = intentState.renderTasks.indexOf(internalRenderTask);
if (i >= 0) {
intentState.renderTasks.splice(i, 1);
}
if (_this4.cleanupAfterRender) {
_this4.pendingCleanup = true;
}
_this4._tryCleanup();
if (error) {
internalRenderTask.capability.reject(error);
} else {
internalRenderTask.capability.resolve();
}
stats.timeEnd('Rendering');
stats.timeEnd('Overall');
};
var internalRenderTask = new InternalRenderTask(complete, params, this.objs,
this.commonObjs, intentState.operatorList, this.pageNumber, canvasFactory);
internalRenderTask.useRequestAnimationFrame = renderingIntent !== 'print';
if (!intentState.renderTasks) {
intentState.renderTasks = [];
}
intentState.renderTasks.push(internalRenderTask);
var renderTask = internalRenderTask.task;
if (params.continueCallback) {
(0, _util.deprecated)('render is used with continueCallback parameter');
renderTask.onContinue = params.continueCallback;
}
intentState.displayReadyCapability.promise.then(function (transparency) {
if (_this4.pendingCleanup) {
complete();
return;
}
stats.time('Rendering');
internalRenderTask.initializeGraphics(transparency);
internalRenderTask.operatorListChanged();
}).catch(complete);
return renderTask;
},
getOperatorList: function PDFPageProxy_getOperatorList() {
function operatorListChanged() {
if (intentState.operatorList.lastChunk) {
intentState.opListReadCapability.resolve(intentState.operatorList);
var i = intentState.renderTasks.indexOf(opListTask);
if (i >= 0) {
intentState.renderTasks.splice(i, 1);
}
}
}
var renderingIntent = 'oplist';
if (!this.intentStates[renderingIntent]) {
this.intentStates[renderingIntent] = Object.create(null);
}
var intentState = this.intentStates[renderingIntent];
var opListTask;
if (!intentState.opListReadCapability) {
opListTask = {};
opListTask.operatorListChanged = operatorListChanged;
intentState.receivingOperatorList = true;
intentState.opListReadCapability = (0, _util.createPromiseCapability)();
intentState.renderTasks = [];
intentState.renderTasks.push(opListTask);
intentState.operatorList = {
fnArray: [],
argsArray: [],
lastChunk: false
};
this.transport.messageHandler.send('RenderPageRequest', {
pageIndex: this.pageIndex,
intent: renderingIntent
});
}
return intentState.opListReadCapability.promise;
},
streamTextContent: function streamTextContent() {
var params = arguments.length > 0 && arguments[0] !== undefined ?
arguments[0] : {};

var TEXT_CONTENT_CHUNK_SIZE = 100;

return this.transport.messageHandler.sendWithStream('GetTextContent', {
pageIndex: this.pageNumber - 1,
normalizeWhitespace: params.normalizeWhitespace === true,
combineTextItems: params.disableCombineTextItems !== true
}, {
highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
size: function size(textContent) {
return textContent.items.length;
}
});
},

getTextContent: function PDFPageProxy_getTextContent(params) {

params = params || {};
var readableStream = this.streamTextContent(params);
return new Promise(function (resolve, reject) {
function pump() {
reader.read().then(function (_ref) {
var value = _ref.value,
done = _ref.done;

if (done) {
resolve(textContent);
return;
}
_util.Util.extendObj(textContent.styles, value.styles);
_util.Util.appendToArray(textContent.items, value.items);
pump();
}, reject);
}
var reader = readableStream.getReader();
var textContent = {
items: [],
styles: Object.create(null)
};
pump();
});
},
_destroy: function PDFPageProxy_destroy() {
this.destroyed = true;
this.transport.pageCache[this.pageIndex] = null;
var waitOn = [];
Object.keys(this.intentStates).forEach(function (intent) {
if (intent === 'oplist') {
return;
}
var intentState = this.intentStates[intent];
intentState.renderTasks.forEach(function (renderTask) {
var renderCompleted = renderTask.capability.promise.catch(function ()
{});
waitOn.push(renderCompleted);
renderTask.cancel();
});
}, this);
this.objs.clear();
this.annotationsPromise = null;
this.pendingCleanup = false;
return Promise.all(waitOn);
},
destroy: function destroy() {
(0, _util.deprecated)('page destroy method, use cleanup() instead');
this.cleanup();
},

cleanup: function PDFPageProxy_cleanup() {

this.pendingCleanup = true;
this._tryCleanup();
},
_tryCleanup: function PDFPageProxy_tryCleanup() {
if (!this.pendingCleanup || Object.keys(this.intentStates).some(function
(intent) {
var intentState = this.intentStates[intent];
return intentState.renderTasks.length !== 0 ||
intentState.receivingOperatorList;
}, this)) {
return;
}
Object.keys(this.intentStates).forEach(function (intent) {
delete this.intentStates[intent];
}, this);
this.objs.clear();
this.annotationsPromise = null;
this.pendingCleanup = false;
},
_startRenderPage: function PDFPageProxy_startRenderPage(transparency, intent) {
var intentState = this.intentStates[intent];
if (intentState.displayReadyCapability) {
intentState.displayReadyCapability.resolve(transparency);
}
},
_renderPageChunk: function PDFPageProxy_renderPageChunk(operatorListChunk,
intent) {
var intentState = this.intentStates[intent];
var i, ii;
for (i = 0, ii = operatorListChunk.length; i < ii; i++) {
intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
}
intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
for (i = 0; i < intentState.renderTasks.length; i++) {
intentState.renderTasks[i].operatorListChanged();
}
if (operatorListChunk.lastChunk) {
intentState.receivingOperatorList = false;
this._tryCleanup();
}
}
};
return PDFPageProxy;
}();
var LoopbackPort = function () {
function LoopbackPort(defer) {
_classCallCheck(this, LoopbackPort);

this._listeners = [];
this._defer = defer;
this._deferred = Promise.resolve(undefined);
}

_createClass(LoopbackPort, [{
key: 'postMessage',
value: function postMessage(obj, transfers) {
var _this5 = this;

return LoopbackPort;
}();

var PDFWorker = function PDFWorkerClosure() {

if (!isWorkerDisabled && !(0, _dom_utils.getDefaultSetting)('disableWorker')

&& typeof Worker !== 'undefined') {
var workerSrc = getWorkerSrc();
try {
if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
}
var worker = new Worker(workerSrc);
var messageHandler = new _util.MessageHandler('main', 'worker', worker);
var terminateEarly = function terminateEarly() {
worker.removeEventListener('error', onWorkerError);
messageHandler.destroy();
worker.terminate();
if (_this6.destroyed) {
_this6._readyCapability.reject(new Error('Worker was destroyed'));
} else {
_this6._setupFakeWorker();
}
};
var onWorkerError = function onWorkerError() {
if (!_this6._webWorker) {
terminateEarly();
}
};
worker.addEventListener('error', onWorkerError);
messageHandler.on('test', function (data) {
worker.removeEventListener('error', onWorkerError);
if (_this6.destroyed) {
terminateEarly();
return;
}
var supportTypedArray = data && data.supportTypedArray;
if (supportTypedArray) {
_this6._messageHandler = messageHandler;
_this6._port = worker;
_this6._webWorker = worker;
if (!data.supportTransfers) {
_this6.postMessageTransfers = false;
isPostMessageTransfersDisabled = true;
}
_this6._readyCapability.resolve();
messageHandler.send('configure', { verbosity: (0,
_util.getVerbosityLevel)() });
} else {
_this6._setupFakeWorker();
messageHandler.destroy();
worker.terminate();
}
});
messageHandler.on('console_log', function (data) {
console.log.apply(console, data);
});
messageHandler.on('console_error', function (data) {
console.error.apply(console, data);
});
messageHandler.on('ready', function (data) {
worker.removeEventListener('error', onWorkerError);
if (_this6.destroyed) {
terminateEarly();
return;
}
try {
sendTest();
} catch (e) {
_this6._setupFakeWorker();
}
});
var sendTest = function sendTest() {
var postMessageTransfers = (0, _dom_utils.getDefaultSetting)
('postMessageTransfers') && !isPostMessageTransfersDisabled;
var testObj = new Uint8Array([postMessageTransfers ? 255 : 0]);
try {
messageHandler.send('test', testObj, [testObj.buffer]);
} catch (ex) {
(0, _util.info)('Cannot use postMessage transfers');
testObj[0] = 0;
messageHandler.send('test', testObj);
}
};
sendTest();
return;
} catch (e) {
(0, _util.info)('The worker has been disabled.');
}
}
this._setupFakeWorker();
},
_setupFakeWorker: function PDFWorker_setupFakeWorker() {
var _this7 = this;

if (!isWorkerDisabled && !(0, _dom_utils.getDefaultSetting)('disableWorker'))

{
(0, _util.warn)('Setting up fake worker.');
isWorkerDisabled = true;
}
setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
if (_this7.destroyed) {
_this7._readyCapability.reject(new Error('Worker was destroyed'));
return;
}
var isTypedArraysPresent = Uint8Array !== Float32Array;
var port = new LoopbackPort(isTypedArraysPresent);
_this7._port = port;
var id = 'fake' + nextFakeWorkerId++;
var workerHandler = new _util.MessageHandler(id + '_worker', id, port);
WorkerMessageHandler.setup(workerHandler, port);
var messageHandler = new _util.MessageHandler(id, id + '_worker', port);
_this7._messageHandler = messageHandler;
_this7._readyCapability.resolve();
});
},
destroy: function PDFWorker_destroy() {
this.destroyed = true;
if (this._webWorker) {
this._webWorker.terminate();
this._webWorker = null;
}
pdfWorkerPorts.delete(this._port);
this._port = null;
if (this._messageHandler) {
this._messageHandler.destroy();
this._messageHandler = null;
}
}
};
PDFWorker.fromPort = function (port) {
if (pdfWorkerPorts.has(port)) {
return pdfWorkerPorts.get(port);
}
return new PDFWorker(null, port);
};
return PDFWorker;
}();
var WorkerTransport = function WorkerTransportClosure() {
function WorkerTransport(messageHandler, loadingTask, networkStream,
CMapReaderFactory) {
this.messageHandler = messageHandler;
this.loadingTask = loadingTask;
this.commonObjs = new PDFObjects();
this.fontLoader = new _font_loader.FontLoader(loadingTask.docId);
this.CMapReaderFactory = new CMapReaderFactory({
baseUrl: (0, _dom_utils.getDefaultSetting)('cMapUrl'),
isCompressed: (0, _dom_utils.getDefaultSetting)('cMapPacked')
});
this.destroyed = false;
this.destroyCapability = null;
this._passwordCapability = null;
this._networkStream = networkStream;
this._fullReader = null;
this._lastProgress = null;
this.pageCache = [];
this.pagePromises = [];
this.downloadInfoCapability = (0, _util.createPromiseCapability)();
this.setupMessageHandler();
}
WorkerTransport.prototype = {
destroy: function WorkerTransport_destroy() {
var _this8 = this;

if (this.destroyCapability) {
return this.destroyCapability.promise;
}
this.destroyed = true;
this.destroyCapability = (0, _util.createPromiseCapability)();
if (this._passwordCapability) {
this._passwordCapability.reject(new Error('Worker was destroyed during
onPassword callback'));
}
var waitOn = [];
this.pageCache.forEach(function (page) {
if (page) {
waitOn.push(page._destroy());
}
});
this.pageCache = [];
this.pagePromises = [];
var terminated = this.messageHandler.sendWithPromise('Terminate', null);
waitOn.push(terminated);
Promise.all(waitOn).then(function () {
_this8.fontLoader.clear();
if (_this8._networkStream) {
_this8._networkStream.cancelAllRequests();
}
if (_this8.messageHandler) {
_this8.messageHandler.destroy();
_this8.messageHandler = null;
}
_this8.destroyCapability.resolve();
}, this.destroyCapability.reject);
return this.destroyCapability.promise;
},
setupMessageHandler: function WorkerTransport_setupMessageHandler() {
var messageHandler = this.messageHandler;
var loadingTask = this.loadingTask;
messageHandler.on('GetReader', function (data, sink) {
var _this9 = this;

(0, _util.assert)(this._networkStream);
this._fullReader = this._networkStream.getFullReader();
this._fullReader.onProgress = function (evt) {
_this9._lastProgress = {
loaded: evt.loaded,
total: evt.total
};
};
sink.onPull = function () {
_this9._fullReader.read().then(function (_ref2) {
var value = _ref2.value,
done = _ref2.done;

var headersCapability = (0, _util.createPromiseCapability)();

if (done) {
sink.close();
return;
}
(0, _util.assert)((0, _util.isArrayBuffer)(value));
sink.enqueue(new Uint8Array(value), 1, [value]);
}).catch(function (reason) {
sink.error(reason);
});
};
sink.onCancel = function (reason) {
_rangeReader.cancel(reason);
};
}, this);
messageHandler.on('GetDoc', function transportDoc(data) {
var pdfInfo = data.pdfInfo;
this.numPages = data.pdfInfo.numPages;
var loadingTask = this.loadingTask;
var pdfDocument = new PDFDocumentProxy(pdfInfo, this, loadingTask);
this.pdfDocument = pdfDocument;
loadingTask._capability.resolve(pdfDocument);
}, this);
messageHandler.on('PasswordRequest', function
transportPasswordRequest(exception) {
var _this11 = this;

this._passwordCapability = (0, _util.createPromiseCapability)();

if (loadingTask.onPassword) {
var updatePassword = function updatePassword(password) {
_this11._passwordCapability.resolve({ password: password });
};
loadingTask.onPassword(updatePassword, exception.code);
} else {
this._passwordCapability.reject(new
_util.PasswordException(exception.message, exception.code));
}
return this._passwordCapability.promise;
}, this);
messageHandler.on('PasswordException', function
transportPasswordException(exception) {
loadingTask._capability.reject(new
_util.PasswordException(exception.message, exception.code));
}, this);
messageHandler.on('InvalidPDF', function transportInvalidPDF(exception) {
this.loadingTask._capability.reject(new
_util.InvalidPDFException(exception.message));
}, this);
messageHandler.on('MissingPDF', function transportMissingPDF(exception) {
this.loadingTask._capability.reject(new
_util.MissingPDFException(exception.message));
}, this);
messageHandler.on('UnexpectedResponse', function
transportUnexpectedResponse(exception) {
this.loadingTask._capability.reject(new
_util.UnexpectedResponseException(exception.message, exception.status));
}, this);
messageHandler.on('UnknownError', function transportUnknownError(exception) {
this.loadingTask._capability.reject(new
_util.UnknownErrorException(exception.message, exception.details));
}, this);
messageHandler.on('DataLoaded', function transportPage(data) {
this.downloadInfoCapability.resolve(data);
}, this);
messageHandler.on('PDFManagerReady', function transportPage(data) {}, this);
messageHandler.on('StartRenderPage', function transportRender(data) {
if (this.destroyed) {
return;
}
var page = this.pageCache[data.pageIndex];
page.stats.timeEnd('Page Request');
page._startRenderPage(data.transparency, data.intent);
}, this);
messageHandler.on('RenderPageChunk', function transportRender(data) {
if (this.destroyed) {
return;
}
var page = this.pageCache[data.pageIndex];
page._renderPageChunk(data.operatorList, data.intent);
}, this);
messageHandler.on('commonobj', function transportObj(data) {
var _this12 = this;

if (this.destroyed) {
return;
}
var id = data[0];
var type = data[1];
if (this.commonObjs.hasData(id)) {
return;
}
switch (type) {
case 'Font':
var exportedData = data[2];
if ('error' in exportedData) {
var exportedError = exportedData.error;
(0, _util.warn)('Error during font loading: ' + exportedError);
this.commonObjs.resolve(id, exportedError);
break;
}
var fontRegistry = null;
if ((0, _dom_utils.getDefaultSetting)('pdfBug') &&
_util.globalScope.FontInspector && _util.globalScope['FontInspector'].enabled) {
fontRegistry = {
registerFont: function registerFont(font, url) {
_util.globalScope['FontInspector'].fontAdded(font, url);
}
};
}
var font = new _font_loader.FontFaceObject(exportedData, {
isEvalSuported: (0, _dom_utils.getDefaultSetting)('isEvalSupported'),
disableFontFace: (0, _dom_utils.getDefaultSetting)
('disableFontFace'),
fontRegistry: fontRegistry
});
var fontReady = function fontReady(fontObjs) {
_this12.commonObjs.resolve(id, font);
};
this.fontLoader.bind([font], fontReady);
break;
case 'FontPath':
this.commonObjs.resolve(id, data[2]);
break;
default:
throw new Error('Got unknown common object type ' + type);
}
}, this);
messageHandler.on('obj', function transportObj(data) {
if (this.destroyed) {
return;
}
var id = data[0];
var pageIndex = data[1];
var type = data[2];
var pageProxy = this.pageCache[pageIndex];
var imageData;
if (pageProxy.objs.hasData(id)) {
return;
}
switch (type) {
case 'JpegStream':
imageData = data[3];
(0, _util.loadJpegStream)(id, imageData, pageProxy.objs);
break;
case 'Image':
imageData = data[3];
pageProxy.objs.resolve(id, imageData);
var MAX_IMAGE_SIZE_TO_STORE = 8000000;
if (imageData && 'data' in imageData && imageData.data.length >
MAX_IMAGE_SIZE_TO_STORE) {
pageProxy.cleanupAfterRender = true;
}
break;
default:
throw new Error('Got unknown object type ' + type);
}
}, this);
messageHandler.on('DocProgress', function transportDocProgress(data) {
if (this.destroyed) {
return;
}
var loadingTask = this.loadingTask;
if (loadingTask.onProgress) {
loadingTask.onProgress({
loaded: data.loaded,
total: data.total
});
}
}, this);
messageHandler.on('PageError', function transportError(data) {
if (this.destroyed) {
return;
}
var page = this.pageCache[data.pageNum - 1];
var intentState = page.intentStates[data.intent];
if (intentState.displayReadyCapability) {
intentState.displayReadyCapability.reject(data.error);
} else {
throw new Error(data.error);
}
if (intentState.operatorList) {
intentState.operatorList.lastChunk = true;
for (var i = 0; i < intentState.renderTasks.length; i++) {
intentState.renderTasks[i].operatorListChanged();
}
}
}, this);
messageHandler.on('UnsupportedFeature', function
transportUnsupportedFeature(data) {
if (this.destroyed) {
return;
}
var featureId = data.featureId;
var loadingTask = this.loadingTask;
if (loadingTask.onUnsupportedFeature) {
loadingTask.onUnsupportedFeature(featureId);
}
_UnsupportedManager.notify(featureId);
}, this);
messageHandler.on('JpegDecode', function (data) {
if (this.destroyed) {
return Promise.reject(new Error('Worker was destroyed'));
}
if (typeof document === 'undefined') {
return Promise.reject(new Error('"document" is not defined.'));
}
var imageUrl = data[0];
var components = data[1];
if (components !== 3 && components !== 1) {
return Promise.reject(new Error('Only 3 components or 1 component can be
returned'));
}
return new Promise(function (resolve, reject) {
var img = new Image();
img.onload = function () {
var width = img.width;
var height = img.height;
var size = width * height;
var rgbaLength = size * 4;
var buf = new Uint8Array(size * components);
var tmpCanvas = document.createElement('canvas');
tmpCanvas.width = width;
tmpCanvas.height = height;
var tmpCtx = tmpCanvas.getContext('2d');
tmpCtx.drawImage(img, 0, 0);
var data = tmpCtx.getImageData(0, 0, width, height).data;
var i, j;
if (components === 3) {
for (i = 0, j = 0; i < rgbaLength; i += 4, j += 3) {
buf[j] = data[i];
buf[j + 1] = data[i + 1];
buf[j + 2] = data[i + 2];
}
} else if (components === 1) {
for (i = 0, j = 0; i < rgbaLength; i += 4, j++) {
buf[j] = data[i];
}
}
resolve({
data: buf,
width: width,
height: height
});
};
img.onerror = function () {
reject(new Error('JpegDecode failed to load image'));
};
img.src = imageUrl;
});
}, this);
messageHandler.on('FetchBuiltInCMap', function (data) {
if (this.destroyed) {
return Promise.reject(new Error('Worker was destroyed'));
}
return this.CMapReaderFactory.fetch({ name: data.name });
}, this);
},
getData: function WorkerTransport_getData() {
return this.messageHandler.sendWithPromise('GetData', null);
},
getPage: function WorkerTransport_getPage(pageNumber, capability) {
var _this13 = this;

if (!(0, _util.isInt)(pageNumber) || pageNumber <= 0 || pageNumber >

this.numPages) {
return Promise.reject(new Error('Invalid page request'));
}
var pageIndex = pageNumber - 1;
if (pageIndex in this.pagePromises) {
return this.pagePromises[pageIndex];
}
var promise = this.messageHandler.sendWithPromise('GetPage', { pageIndex:
pageIndex }).then(function (pageInfo) {
if (_this13.destroyed) {
throw new Error('Transport destroyed');
}
var page = new PDFPageProxy(pageIndex, pageInfo, _this13);
_this13.pageCache[pageIndex] = page;
return page;
});
this.pagePromises[pageIndex] = promise;
return promise;
},
getPageIndex: function WorkerTransport_getPageIndexByRef(ref) {
return this.messageHandler.sendWithPromise('GetPageIndex', { ref:
ref }).catch(function (reason) {
return Promise.reject(new Error(reason));
});
},
getAnnotations: function WorkerTransport_getAnnotations(pageIndex, intent) {
return this.messageHandler.sendWithPromise('GetAnnotations', {
pageIndex: pageIndex,
intent: intent
});
},
getDestinations: function WorkerTransport_getDestinations() {
return this.messageHandler.sendWithPromise('GetDestinations', null);
},
getDestination: function WorkerTransport_getDestination(id) {
return this.messageHandler.sendWithPromise('GetDestination', { id: id });
},
getPageLabels: function WorkerTransport_getPageLabels() {
return this.messageHandler.sendWithPromise('GetPageLabels', null);
},
getPageMode: function getPageMode() {
return this.messageHandler.sendWithPromise('GetPageMode', null);
},

getAttachments: function WorkerTransport_getAttachments() {

return this.messageHandler.sendWithPromise('GetAttachments', null);
},
getJavaScript: function WorkerTransport_getJavaScript() {
return this.messageHandler.sendWithPromise('GetJavaScript', null);
},
getOutline: function WorkerTransport_getOutline() {
return this.messageHandler.sendWithPromise('GetOutline', null);
},
getMetadata: function WorkerTransport_getMetadata() {
return this.messageHandler.sendWithPromise('GetMetadata', null).then(function
transportMetadata(results) {
return {
info: results[0],
metadata: results[1] ? new _metadata.Metadata(results[1]) : null
};
});
},
getStats: function WorkerTransport_getStats() {
return this.messageHandler.sendWithPromise('GetStats', null);
},
startCleanup: function WorkerTransport_startCleanup() {
var _this14 = this;

this.messageHandler.sendWithPromise('Cleanup', null).then(function () {
for (var i = 0, ii = _this14.pageCache.length; i < ii; i++) {
var page = _this14.pageCache[i];
if (page) {
page.cleanup();
}
}
_this14.commonObjs.clear();
_this14.fontLoader.clear();
});
}
};
return WorkerTransport;
}();
var PDFObjects = function PDFObjectsClosure() {
function PDFObjects() {
this.objs = Object.create(null);
}
PDFObjects.prototype = {
ensureObj: function PDFObjects_ensureObj(objId) {
if (this.objs[objId]) {
return this.objs[objId];
}
var obj = {
capability: (0, _util.createPromiseCapability)(),
data: null,
resolved: false
};
this.objs[objId] = obj;
return obj;
},
get: function PDFObjects_get(objId, callback) {
if (callback) {
this.ensureObj(objId).capability.promise.then(callback);
return null;
}
var obj = this.objs[objId];
if (!obj || !obj.resolved) {
throw new Error('Requesting object that isn\'t resolved yet ' + objId);
}
return obj.data;
},
resolve: function PDFObjects_resolve(objId, data) {
var obj = this.ensureObj(objId);
obj.resolved = true;
obj.data = data;
obj.capability.resolve(data);
},
isResolved: function PDFObjects_isResolved(objId) {
var objs = this.objs;
if (!objs[objId]) {
return false;
}
return objs[objId].resolved;
},
hasData: function PDFObjects_hasData(objId) {
return this.isResolved(objId);
},
getData: function PDFObjects_getData(objId) {
var objs = this.objs;
if (!objs[objId] || !objs[objId].resolved) {
return null;
}
return objs[objId].data;
},
clear: function PDFObjects_clear() {
this.objs = Object.create(null);
}
};
return PDFObjects;
}();
var RenderTask = function RenderTaskClosure() {
function RenderTask(internalRenderTask) {
this._internalRenderTask = internalRenderTask;
this.onContinue = null;
}
RenderTask.prototype = {
get promise() {
return this._internalRenderTask.capability.promise;
},
cancel: function RenderTask_cancel() {
this._internalRenderTask.cancel();
},
then: function RenderTask_then(onFulfilled, onRejected) {
return this.promise.then.apply(this.promise, arguments);
}
};
return RenderTask;
}();
var InternalRenderTask = function InternalRenderTaskClosure() {
var canvasInRendering = new WeakMap();
function InternalRenderTask(callback, params, objs, commonObjs, operatorList,
pageNumber, canvasFactory) {
this.callback = callback;
this.params = params;
this.objs = objs;
this.commonObjs = commonObjs;
this.operatorListIdx = null;
this.operatorList = operatorList;
this.pageNumber = pageNumber;
this.canvasFactory = canvasFactory;
this.running = false;
this.graphicsReadyCallback = null;
this.graphicsReady = false;
this.useRequestAnimationFrame = false;
this.cancelled = false;
this.capability = (0, _util.createPromiseCapability)();
this.task = new RenderTask(this);
this._continueBound = this._continue.bind(this);
this._scheduleNextBound = this._scheduleNext.bind(this);
this._nextBound = this._next.bind(this);
this._canvas = params.canvasContext.canvas;
}
InternalRenderTask.prototype = {
initializeGraphics: function
InternalRenderTask_initializeGraphics(transparency) {
if (this._canvas) {
if (canvasInRendering.has(this._canvas)) {
throw new Error('Cannot use the same canvas during multiple render()
operations. ' + 'Use different canvas or ensure previous operations were ' +
'cancelled or completed.');
}
canvasInRendering.set(this._canvas, this);
}
if (this.cancelled) {
return;
}
if ((0, _dom_utils.getDefaultSetting)('pdfBug') &&
_util.globalScope.StepperManager && _util.globalScope.StepperManager.enabled) {
this.stepper = _util.globalScope.StepperManager.create(this.pageNumber -
1);
this.stepper.init(this.operatorList);
this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
}
var params = this.params;
this.gfx = new _canvas.CanvasGraphics(params.canvasContext, this.commonObjs,
this.objs, this.canvasFactory, params.imageLayer);
this.gfx.beginDrawing({
transform: params.transform,
viewport: params.viewport,
transparency: transparency,
background: params.background
});
this.operatorListIdx = 0;
this.graphicsReady = true;
if (this.graphicsReadyCallback) {
this.graphicsReadyCallback();
}
},
cancel: function InternalRenderTask_cancel() {
this.running = false;
this.cancelled = true;
if (this._canvas) {
canvasInRendering.delete(this._canvas);
}
if ((0, _dom_utils.getDefaultSetting)('pdfjsNext')) {
this.callback(new _dom_utils.RenderingCancelledException('Rendering
cancelled, page ' + this.pageNumber, 'canvas'));
} else {
this.callback('cancelled');
}
},
operatorListChanged: function InternalRenderTask_operatorListChanged() {
if (!this.graphicsReady) {
if (!this.graphicsReadyCallback) {
this.graphicsReadyCallback = this._continueBound;
}
return;
}
if (this.stepper) {
this.stepper.updateOperatorList(this.operatorList);
}
if (this.running) {
return;
}
this._continue();
},
_continue: function InternalRenderTask__continue() {
this.running = true;
if (this.cancelled) {
return;
}
if (this.task.onContinue) {
this.task.onContinue(this._scheduleNextBound);
} else {
this._scheduleNext();
}
},
_scheduleNext: function InternalRenderTask__scheduleNext() {
if (this.useRequestAnimationFrame && typeof window !== 'undefined') {
window.requestAnimationFrame(this._nextBound);
} else {
Promise.resolve(undefined).then(this._nextBound);
}
},
_next: function InternalRenderTask__next() {
if (this.cancelled) {
return;
}
this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList,
this.operatorListIdx, this._continueBound, this.stepper);
if (this.operatorListIdx === this.operatorList.argsArray.length) {
this.running = false;
if (this.operatorList.lastChunk) {
this.gfx.endDrawing();
if (this._canvas) {
canvasInRendering.delete(this._canvas);
}
this.callback();
}
}
}
};
return InternalRenderTask;
}();
var _UnsupportedManager = function UnsupportedManagerClosure() {
var listeners = [];
return {
listen: function listen(cb) {
(0, _util.deprecated)('Global UnsupportedManager.listen is used: ' + ' use
PDFDocumentLoadingTask.onUnsupportedFeature instead');
listeners.push(cb);
},
notify: function notify(featureId) {
for (var i = 0, ii = listeners.length; i < ii; i++) {
listeners[i](featureId);
}
}
};
}();
var version, build;
{
exports.version = version = '1.9.426';
exports.build = build = '2558a58d';
}
exports.getDocument = getDocument;
exports.LoopbackPort = LoopbackPort;
exports.PDFDataRangeTransport = PDFDataRangeTransport;
exports.PDFWorker = PDFWorker;
exports.PDFDocumentProxy = PDFDocumentProxy;
exports.PDFPageProxy = PDFPageProxy;
exports.setPDFNetworkStreamClass = setPDFNetworkStreamClass;
exports._UnsupportedManager = _UnsupportedManager;
exports.version = version;
exports.build = build;

/***/ }),
/* 3 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AnnotationLayer = undefined;

var _dom_utils = __w_pdfjs_require__(1);

var _util = __w_pdfjs_require__(0);

link.href = this.linkService.getDestinationHash(destination);
link.onclick = function () {
if (destination) {
_this.linkService.navigateTo(destination);
}
return false;
};
if (destination) {
link.className = 'internalLink';
}
},
_bindNamedAction: function _bindNamedAction(link, action) {
var _this2 = this;

link.href = this.linkService.getAnchorUrl('');
link.onclick = function () {
_this2.linkService.executeNamedAction(action);
return false;
};
link.className = 'internalLink';
}
});
return LinkAnnotationElement;
}();
var TextAnnotationElement = function TextAnnotationElementClosure() {
function TextAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable);
}
_util.Util.inherit(TextAnnotationElement, AnnotationElement, {
render: function TextAnnotationElement_render() {
this.container.className = 'textAnnotation';
var image = document.createElement('img');
image.style.height = this.container.style.height;
image.style.width = this.container.style.width;
image.src = this.imageResourcesPath + 'annotation-' +
this.data.name.toLowerCase() + '.svg';
image.alt = '[{{type}} Annotation]';
image.dataset.l10nId = 'text_annotation_type';
image.dataset.l10nArgs = JSON.stringify({ type: this.data.name });
if (!this.data.hasPopup) {
this._createPopup(this.container, image, this.data);
}
this.container.appendChild(image);
return this.container;
}
});
return TextAnnotationElement;
}();
var WidgetAnnotationElement = function WidgetAnnotationElementClosure() {
function WidgetAnnotationElement(parameters, isRenderable) {
AnnotationElement.call(this, parameters, isRenderable);
}
_util.Util.inherit(WidgetAnnotationElement, AnnotationElement, {
render: function WidgetAnnotationElement_render() {
return this.container;
}
});
return WidgetAnnotationElement;
}();
var TextWidgetAnnotationElement = function TextWidgetAnnotationElementClosure() {
var TEXT_ALIGNMENT = ['left', 'center', 'right'];
function TextWidgetAnnotationElement(parameters) {
var isRenderable = parameters.renderInteractiveForms || !
parameters.data.hasAppearance && !!parameters.data.fieldValue;
WidgetAnnotationElement.call(this, parameters, isRenderable);
}
_util.Util.inherit(TextWidgetAnnotationElement, WidgetAnnotationElement, {
render: function TextWidgetAnnotationElement_render() {
this.container.className = 'textWidgetAnnotation';
var element = null;
if (this.renderInteractiveForms) {
if (this.data.multiLine) {
element = document.createElement('textarea');
element.textContent = this.data.fieldValue;
} else {
element = document.createElement('input');
element.type = 'text';
element.setAttribute('value', this.data.fieldValue);
}
element.disabled = this.data.readOnly;
if (this.data.maxLen !== null) {
element.maxLength = this.data.maxLen;
}
if (this.data.comb) {
var fieldWidth = this.data.rect[2] - this.data.rect[0];
var combWidth = fieldWidth / this.data.maxLen;
element.classList.add('comb');
element.style.letterSpacing = 'calc(' + combWidth + 'px - 1ch)';
}
} else {
element = document.createElement('div');
element.textContent = this.data.fieldValue;
element.style.verticalAlign = 'middle';
element.style.display = 'table-cell';
var font = null;
if (this.data.fontRefName) {
font = this.page.commonObjs.getData(this.data.fontRefName);
}
this._setTextStyle(element, font);
}
if (this.data.textAlignment !== null) {
element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
}
this.container.appendChild(element);
return this.container;
},
_setTextStyle: function TextWidgetAnnotationElement_setTextStyle(element, font)
{
var style = element.style;
style.fontSize = this.data.fontSize + 'px';
style.direction = this.data.fontDirection < 0 ? 'rtl' : 'ltr';
if (!font) {
return;
}
style.fontWeight = font.black ? font.bold ? '900' : 'bold' : font.bold ?
'bold' : 'normal';
style.fontStyle = font.italic ? 'italic' : 'normal';
var fontFamily = font.loadedName ? '"' + font.loadedName + '", ' : '';
var fallbackName = font.fallbackName || 'Helvetica, sans-serif';
style.fontFamily = fontFamily + fallbackName;
}
});
return TextWidgetAnnotationElement;
}();
var CheckboxWidgetAnnotationElement = function
CheckboxWidgetAnnotationElementClosure() {
function CheckboxWidgetAnnotationElement(parameters) {
WidgetAnnotationElement.call(this, parameters,
parameters.renderInteractiveForms);
}
_util.Util.inherit(CheckboxWidgetAnnotationElement, WidgetAnnotationElement, {
render: function CheckboxWidgetAnnotationElement_render() {
this.container.className = 'buttonWidgetAnnotation checkBox';
var element = document.createElement('input');
element.disabled = this.data.readOnly;
element.type = 'checkbox';
if (this.data.fieldValue && this.data.fieldValue !== 'Off') {
element.setAttribute('checked', true);
}
this.container.appendChild(element);
return this.container;
}
});
return CheckboxWidgetAnnotationElement;
}();
var RadioButtonWidgetAnnotationElement = function
RadioButtonWidgetAnnotationElementClosure() {
function RadioButtonWidgetAnnotationElement(parameters) {
WidgetAnnotationElement.call(this, parameters,
parameters.renderInteractiveForms);
}
_util.Util.inherit(RadioButtonWidgetAnnotationElement, WidgetAnnotationElement, {
render: function RadioButtonWidgetAnnotationElement_render() {
this.container.className = 'buttonWidgetAnnotation radioButton';
var element = document.createElement('input');
element.disabled = this.data.readOnly;
element.type = 'radio';
element.name = this.data.fieldName;
if (this.data.fieldValue === this.data.buttonValue) {
element.setAttribute('checked', true);
}
this.container.appendChild(element);
return this.container;
}
});
return RadioButtonWidgetAnnotationElement;
}();
var ChoiceWidgetAnnotationElement = function ChoiceWidgetAnnotationElementClosure()
{
function ChoiceWidgetAnnotationElement(parameters) {
WidgetAnnotationElement.call(this, parameters,
parameters.renderInteractiveForms);
}
_util.Util.inherit(ChoiceWidgetAnnotationElement, WidgetAnnotationElement, {
render: function ChoiceWidgetAnnotationElement_render() {
this.container.className = 'choiceWidgetAnnotation';
var selectElement = document.createElement('select');
selectElement.disabled = this.data.readOnly;
if (!this.data.combo) {
selectElement.size = this.data.options.length;
if (this.data.multiSelect) {
selectElement.multiple = true;
}
}
for (var i = 0, ii = this.data.options.length; i < ii; i++) {
var option = this.data.options[i];
var optionElement = document.createElement('option');
optionElement.textContent = option.displayValue;
optionElement.value = option.exportValue;
if (this.data.fieldValue.indexOf(option.displayValue) >= 0) {
optionElement.setAttribute('selected', true);
}
selectElement.appendChild(optionElement);
}
this.container.appendChild(selectElement);
return this.container;
}
});
return ChoiceWidgetAnnotationElement;
}();
var PopupAnnotationElement = function PopupAnnotationElementClosure() {
var IGNORE_TYPES = ['Line'];
function PopupAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.title || parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable);
}
_util.Util.inherit(PopupAnnotationElement, AnnotationElement, {
render: function PopupAnnotationElement_render() {
this.container.className = 'popupAnnotation';
if (IGNORE_TYPES.indexOf(this.data.parentType) >= 0) {
return this.container;
}
var selector = '[data-annotation-id="' + this.data.parentId + '"]';
var parentElement = this.layer.querySelector(selector);
if (!parentElement) {
return this.container;
}
var popup = new PopupElement({
container: this.container,
trigger: parentElement,
color: this.data.color,
title: this.data.title,
contents: this.data.contents
});
var parentLeft = parseFloat(parentElement.style.left);
var parentWidth = parseFloat(parentElement.style.width);
_dom_utils.CustomStyle.setProp('transformOrigin', this.container, -
(parentLeft + parentWidth) + 'px -' + parentElement.style.top);
this.container.style.left = parentLeft + parentWidth + 'px';
this.container.appendChild(popup.render());
return this.container;
}
});
return PopupAnnotationElement;
}();
var PopupElement = function PopupElementClosure() {
var BACKGROUND_ENLIGHT = 0.7;
function PopupElement(parameters) {
this.container = parameters.container;
this.trigger = parameters.trigger;
this.color = parameters.color;
this.title = parameters.title;
this.contents = parameters.contents;
this.hideWrapper = parameters.hideWrapper || false;
this.pinned = false;
}
PopupElement.prototype = {
render: function PopupElement_render() {
var wrapper = document.createElement('div');
wrapper.className = 'popupWrapper';
this.hideElement = this.hideWrapper ? wrapper : this.container;
this.hideElement.setAttribute('hidden', true);
var popup = document.createElement('div');
popup.className = 'popup';
var color = this.color;
if (color) {
var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0);
}
var contents = this._formatContents(this.contents);
var title = document.createElement('h1');
title.textContent = this.title;
this.trigger.addEventListener('click', this._toggle.bind(this));
this.trigger.addEventListener('mouseover', this._show.bind(this, false));
this.trigger.addEventListener('mouseout', this._hide.bind(this, false));
popup.addEventListener('click', this._hide.bind(this, true));
popup.appendChild(title);
popup.appendChild(contents);
wrapper.appendChild(popup);
return wrapper;
},
_formatContents: function PopupElement_formatContents(contents) {
var p = document.createElement('p');
var lines = contents.split(/(?:\r\n?|\n)/);
for (var i = 0, ii = lines.length; i < ii; ++i) {
var line = lines[i];
p.appendChild(document.createTextNode(line));
if (i < ii - 1) {
p.appendChild(document.createElement('br'));
}
}
return p;
},
_toggle: function PopupElement_toggle() {
if (this.pinned) {
this._hide(true);
} else {
this._show(true);
}
},
_show: function PopupElement_show(pin) {
if (pin) {
this.pinned = true;
}
if (this.hideElement.hasAttribute('hidden')) {
this.hideElement.removeAttribute('hidden');
this.container.style.zIndex += 1;
}
},
_hide: function PopupElement_hide(unpin) {
if (unpin) {
this.pinned = false;
}
if (!this.hideElement.hasAttribute('hidden') && !this.pinned) {
this.hideElement.setAttribute('hidden', true);
this.container.style.zIndex -= 1;
}
}
};
return PopupElement;
}();
var LineAnnotationElement = function LineAnnotationElementClosure() {
var SVG_NS = 'http://www.w3.org/2000/svg';
function LineAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable, true);
}
_util.Util.inherit(LineAnnotationElement, AnnotationElement, {
render: function LineAnnotationElement_render() {
this.container.className = 'lineAnnotation';
var data = this.data;
var width = data.rect[2] - data.rect[0];
var height = data.rect[3] - data.rect[1];
var svg = document.createElementNS(SVG_NS, 'svg:svg');
svg.setAttributeNS(null, 'version', '1.1');
svg.setAttributeNS(null, 'width', width + 'px');
svg.setAttributeNS(null, 'height', height + 'px');
svg.setAttributeNS(null, 'preserveAspectRatio', 'none');
svg.setAttributeNS(null, 'viewBox', '0 0 ' + width + ' ' + height);
var line = document.createElementNS(SVG_NS, 'svg:line');
line.setAttributeNS(null, 'x1', data.rect[2] - data.lineCoordinates[0]);
line.setAttributeNS(null, 'y1', data.rect[3] - data.lineCoordinates[1]);
line.setAttributeNS(null, 'x2', data.rect[2] - data.lineCoordinates[2]);
line.setAttributeNS(null, 'y2', data.rect[3] - data.lineCoordinates[3]);
line.setAttributeNS(null, 'stroke-width', data.borderStyle.width);
line.setAttributeNS(null, 'stroke', 'transparent');
svg.appendChild(line);
this.container.append(svg);
this._createPopup(this.container, line, this.data);
return this.container;
}
});
return LineAnnotationElement;
}();
var HighlightAnnotationElement = function HighlightAnnotationElementClosure() {
function HighlightAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable, true);
}
_util.Util.inherit(HighlightAnnotationElement, AnnotationElement, {
render: function HighlightAnnotationElement_render() {
this.container.className = 'highlightAnnotation';
if (!this.data.hasPopup) {
this._createPopup(this.container, null, this.data);
}
return this.container;
}
});
return HighlightAnnotationElement;
}();
var UnderlineAnnotationElement = function UnderlineAnnotationElementClosure() {
function UnderlineAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable, true);
}
_util.Util.inherit(UnderlineAnnotationElement, AnnotationElement, {
render: function UnderlineAnnotationElement_render() {
this.container.className = 'underlineAnnotation';
if (!this.data.hasPopup) {
this._createPopup(this.container, null, this.data);
}
return this.container;
}
});
return UnderlineAnnotationElement;
}();
var SquigglyAnnotationElement = function SquigglyAnnotationElementClosure() {
function SquigglyAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable, true);
}
_util.Util.inherit(SquigglyAnnotationElement, AnnotationElement, {
render: function SquigglyAnnotationElement_render() {
this.container.className = 'squigglyAnnotation';
if (!this.data.hasPopup) {
this._createPopup(this.container, null, this.data);
}
return this.container;
}
});
return SquigglyAnnotationElement;
}();
var StrikeOutAnnotationElement = function StrikeOutAnnotationElementClosure() {
function StrikeOutAnnotationElement(parameters) {
var isRenderable = !!(parameters.data.hasPopup || parameters.data.title ||
parameters.data.contents);
AnnotationElement.call(this, parameters, isRenderable, true);
}
_util.Util.inherit(StrikeOutAnnotationElement, AnnotationElement, {
render: function StrikeOutAnnotationElement_render() {
this.container.className = 'strikeoutAnnotation';
if (!this.data.hasPopup) {
this._createPopup(this.container, null, this.data);
}
return this.container;
}
});
return StrikeOutAnnotationElement;
}();
var FileAttachmentAnnotationElement = function
FileAttachmentAnnotationElementClosure() {
function FileAttachmentAnnotationElement(parameters) {
AnnotationElement.call(this, parameters, true);
var file = this.data.file;
this.filename = (0, _dom_utils.getFilenameFromUrl)(file.filename);
this.content = file.content;
this.linkService.onFileAttachmentAnnotation({
id: (0, _util.stringToPDFString)(file.filename),
filename: file.filename,
content: file.content
});
}
_util.Util.inherit(FileAttachmentAnnotationElement, AnnotationElement, {
render: function FileAttachmentAnnotationElement_render() {
this.container.className = 'fileAttachmentAnnotation';
var trigger = document.createElement('div');
trigger.style.height = this.container.style.height;
trigger.style.width = this.container.style.width;
trigger.addEventListener('dblclick', this._download.bind(this));
if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
this._createPopup(this.container, trigger, this.data);
}
this.container.appendChild(trigger);
return this.container;
},
_download: function FileAttachmentAnnotationElement_download() {
if (!this.downloadManager) {
(0, _util.warn)('Download cannot be started due to unavailable download
manager');
return;
}
this.downloadManager.downloadData(this.content, this.filename, '');
}
});
return FileAttachmentAnnotationElement;
}();
var AnnotationLayer = function AnnotationLayerClosure() {
return {
render: function AnnotationLayer_render(parameters) {
var annotationElementFactory = new AnnotationElementFactory();
for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
var data = parameters.annotations[i];
if (!data) {
continue;
}
var element = annotationElementFactory.create({
data: data,
layer: parameters.div,
page: parameters.page,
viewport: parameters.viewport,
linkService: parameters.linkService,
downloadManager: parameters.downloadManager,
imageResourcesPath: parameters.imageResourcesPath || (0,
_dom_utils.getDefaultSetting)('imageResourcesPath'),
renderInteractiveForms: parameters.renderInteractiveForms || false
});
if (element.isRenderable) {
parameters.div.appendChild(element.render());
}
}
},
update: function AnnotationLayer_update(parameters) {
for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
var data = parameters.annotations[i];
var element = parameters.div.querySelector('[data-annotation-id="' +
data.id + '"]');
if (element) {
_dom_utils.CustomStyle.setProp('transform', element, 'matrix(' +
parameters.viewport.transform.join(',') + ')');
}
}
parameters.div.removeAttribute('hidden');
}
};
}();
exports.AnnotationLayer = AnnotationLayer;

/***/ }),
/* 4 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SVGGraphics = undefined;

var _util = __w_pdfjs_require__(0);

var SVGGraphics = function SVGGraphics() {

throw new Error('Not implemented: SVGGraphics');
};
{
var SVG_DEFAULTS = {
fontStyle: 'normal',
fontWeight: 'normal',
fillColor: '#000000'
};
var convertImgDataToPng = function convertImgDataToPngClosure() {
var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a,
0x0a]);
var CHUNK_WRAPPER_SIZE = 12;
var crcTable = new Int32Array(256);
for (var i = 0; i < 256; i++) {
var c = i;
for (var h = 0; h < 8; h++) {
if (c & 1) {
c = 0xedB88320 ^ c >> 1 & 0x7fffffff;
} else {
c = c >> 1 & 0x7fffffff;
}
}
crcTable[i] = c;
}
function crc32(data, start, end) {
var crc = -1;
for (var i = start; i < end; i++) {
var a = (crc ^ data[i]) & 0xff;
var b = crcTable[a];
crc = crc >>> 8 ^ b;
}
return crc ^ -1;
}
function writePngChunk(type, body, data, offset) {
var p = offset;
var len = body.length;
data[p] = len >> 24 & 0xff;
data[p + 1] = len >> 16 & 0xff;
data[p + 2] = len >> 8 & 0xff;
data[p + 3] = len & 0xff;
p += 4;
data[p] = type.charCodeAt(0) & 0xff;
data[p + 1] = type.charCodeAt(1) & 0xff;
data[p + 2] = type.charCodeAt(2) & 0xff;
data[p + 3] = type.charCodeAt(3) & 0xff;
p += 4;
data.set(body, p);
p += body.length;
var crc = crc32(data, offset + 4, p);
data[p] = crc >> 24 & 0xff;
data[p + 1] = crc >> 16 & 0xff;
data[p + 2] = crc >> 8 & 0xff;
data[p + 3] = crc & 0xff;
}
function adler32(data, start, end) {
var a = 1;
var b = 0;
for (var i = start; i < end; ++i) {
a = (a + (data[i] & 0xff)) % 65521;
b = (b + a) % 65521;
}
return b << 16 | a;
}
function deflateSync(literals) {
if (!(0, _util.isNodeJS)()) {
return deflateSyncUncompressed(literals);
}
try {
var input;
if (parseInt(process.versions.node) >= 8) {
input = literals;
} else {
input = new Buffer(literals);
}
var output = require('zlib').deflateSync(input, { level: 9 });
return output instanceof Uint8Array ? output : new Uint8Array(output);
} catch (e) {
(0, _util.warn)('Not compressing PNG because zlib.deflateSync is
unavailable: ' + e);
}
return deflateSyncUncompressed(literals);
}
function deflateSyncUncompressed(literals) {
var len = literals.length;
var maxBlockLength = 0xFFFF;
var deflateBlocks = Math.ceil(len / maxBlockLength);
var idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);
var pi = 0;
idat[pi++] = 0x78;
idat[pi++] = 0x9c;
var pos = 0;
while (len > maxBlockLength) {
idat[pi++] = 0x00;
idat[pi++] = 0xff;
idat[pi++] = 0xff;
idat[pi++] = 0x00;
idat[pi++] = 0x00;
idat.set(literals.subarray(pos, pos + maxBlockLength), pi);
pi += maxBlockLength;
pos += maxBlockLength;
len -= maxBlockLength;
}
idat[pi++] = 0x01;
idat[pi++] = len & 0xff;
idat[pi++] = len >> 8 & 0xff;
idat[pi++] = ~len & 0xffff & 0xff;
idat[pi++] = (~len & 0xffff) >> 8 & 0xff;
idat.set(literals.subarray(pos), pi);
pi += literals.length - pos;
var adler = adler32(literals, 0, literals.length);
idat[pi++] = adler >> 24 & 0xff;
idat[pi++] = adler >> 16 & 0xff;
idat[pi++] = adler >> 8 & 0xff;
idat[pi++] = adler & 0xff;
return idat;
}
function encode(imgData, kind, forceDataSchema) {
var width = imgData.width;
var height = imgData.height;
var bitDepth, colorType, lineSize;
var bytes = imgData.data;
switch (kind) {
case _util.ImageKind.GRAYSCALE_1BPP:
colorType = 0;
bitDepth = 1;
lineSize = width + 7 >> 3;
break;
case _util.ImageKind.RGB_24BPP:
colorType = 2;
bitDepth = 8;
lineSize = width * 3;
break;
case _util.ImageKind.RGBA_32BPP:
colorType = 6;
bitDepth = 8;
lineSize = width * 4;
break;
default:
throw new Error('invalid format');
}
var literals = new Uint8Array((1 + lineSize) * height);
var offsetLiterals = 0,
offsetBytes = 0;
var y, i;
for (y = 0; y < height; ++y) {
literals[offsetLiterals++] = 0;
literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize),
offsetLiterals);
offsetBytes += lineSize;
offsetLiterals += lineSize;
}
if (kind === _util.ImageKind.GRAYSCALE_1BPP) {
offsetLiterals = 0;
for (y = 0; y < height; y++) {
offsetLiterals++;
for (i = 0; i < lineSize; i++) {
literals[offsetLiterals++] ^= 0xFF;
}
}
}
var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8
& 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff,
height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
var idat = deflateSync(literals);
var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length +
idat.length;
var data = new Uint8Array(pngLength);
var offset = 0;
data.set(PNG_HEADER, offset);
offset += PNG_HEADER.length;
writePngChunk('IHDR', ihdr, data, offset);
offset += CHUNK_WRAPPER_SIZE + ihdr.length;
writePngChunk('IDATA', idat, data, offset);
offset += CHUNK_WRAPPER_SIZE + idat.length;
writePngChunk('IEND', new Uint8Array(0), data, offset);
return (0, _util.createObjectURL)(data, 'image/png', forceDataSchema);
}
return function convertImgDataToPng(imgData, forceDataSchema) {
var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP :
imgData.kind;
return encode(imgData, kind, forceDataSchema);
};
}();
var SVGExtraState = function SVGExtraStateClosure() {
function SVGExtraState() {
this.fontSizeScale = 1;
this.fontWeight = SVG_DEFAULTS.fontWeight;
this.fontSize = 0;
this.textMatrix = _util.IDENTITY_MATRIX;
this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
this.leading = 0;
this.x = 0;
this.y = 0;
this.lineX = 0;
this.lineY = 0;
this.charSpacing = 0;
this.wordSpacing = 0;
this.textHScale = 1;
this.textRise = 0;
this.fillColor = SVG_DEFAULTS.fillColor;
this.strokeColor = '#000000';
this.fillAlpha = 1;
this.strokeAlpha = 1;
this.lineWidth = 1;
this.lineJoin = '';
this.lineCap = '';
this.miterLimit = 0;
this.dashArray = [];
this.dashPhase = 0;
this.dependencies = [];
this.activeClipUrl = null;
this.clipGroup = null;
this.maskId = '';
}
SVGExtraState.prototype = {
clone: function SVGExtraState_clone() {
return Object.create(this);
},
setCurrentPoint: function SVGExtraState_setCurrentPoint(x, y) {
this.x = x;
this.y = y;
}
};
return SVGExtraState;
}();
exports.SVGGraphics = SVGGraphics = function SVGGraphicsClosure() {
function opListToTree(opList) {
var opTree = [];
var tmp = [];
var opListLen = opList.length;
for (var x = 0; x < opListLen; x++) {
if (opList[x].fn === 'save') {
opTree.push({
'fnId': 92,
'fn': 'group',
'items': []
});
tmp.push(opTree);
opTree = opTree[opTree.length - 1].items;
continue;
}
if (opList[x].fn === 'restore') {
opTree = tmp.pop();
} else {
opTree.push(opList[x]);
}
}
return opTree;
}
function pf(value) {
if (value === (value | 0)) {
return value.toString();
}
var s = value.toFixed(10);
var i = s.length - 1;
if (s[i] !== '0') {
return s;
}
do {
i--;
} while (s[i] === '0');
return s.substr(0, s[i] === '.' ? i : i + 1);
}
function pm(m) {
if (m[4] === 0 && m[5] === 0) {
if (m[1] === 0 && m[2] === 0) {
if (m[0] === 1 && m[3] === 1) {
return '';
}
return 'scale(' + pf(m[0]) + ' ' + pf(m[3]) + ')';
}
if (m[0] === m[3] && m[1] === -m[2]) {
var a = Math.acos(m[0]) * 180 / Math.PI;
return 'rotate(' + pf(a) + ')';
}
} else {
if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {
return 'translate(' + pf(m[4]) + ' ' + pf(m[5]) + ')';
}
}
return 'matrix(' + pf(m[0]) + ' ' + pf(m[1]) + ' ' + pf(m[2]) + ' ' +
pf(m[3]) + ' ' + pf(m[4]) + ' ' + pf(m[5]) + ')';
}
function SVGGraphics(commonObjs, objs, forceDataSchema) {
this.current = new SVGExtraState();
this.transformMatrix = _util.IDENTITY_MATRIX;
this.transformStack = [];
this.extraStack = [];
this.commonObjs = commonObjs;
this.objs = objs;
this.pendingClip = null;
this.pendingEOFill = false;
this.embedFonts = false;
this.embeddedFonts = Object.create(null);
this.cssStyle = null;
this.forceDataSchema = !!forceDataSchema;
}
var NS = 'http://www.w3.org/2000/svg';
var XML_NS = 'http://www.w3.org/XML/1998/namespace';
var XLINK_NS = 'http://www.w3.org/1999/xlink';
var LINE_CAP_STYLES = ['butt', 'round', 'square'];
var LINE_JOIN_STYLES = ['miter', 'round', 'bevel'];
var clipCount = 0;
var maskCount = 0;
SVGGraphics.prototype = {
save: function SVGGraphics_save() {
this.transformStack.push(this.transformMatrix);
var old = this.current;
this.extraStack.push(old);
this.current = old.clone();
},
restore: function SVGGraphics_restore() {
this.transformMatrix = this.transformStack.pop();
this.current = this.extraStack.pop();
this.pendingClip = null;
this.tgrp = null;
},
group: function SVGGraphics_group(items) {
this.save();
this.executeOpTree(items);
this.restore();
},
loadDependencies: function SVGGraphics_loadDependencies(operatorList) {
var _this = this;

var fnArray = operatorList.fnArray;

this.viewport = viewport;
var svgElement = this._initialize(viewport);
return this.loadDependencies(operatorList).then(function () {
_this2.transformMatrix = _util.IDENTITY_MATRIX;
var opTree = _this2.convertOpList(operatorList);
_this2.executeOpTree(opTree);
return svgElement;
});
},
convertOpList: function SVGGraphics_convertOpList(operatorList) {
var argsArray = operatorList.argsArray;
var fnArray = operatorList.fnArray;
var fnArrayLen = fnArray.length;
var REVOPS = [];
var opList = [];
for (var op in _util.OPS) {
REVOPS[_util.OPS[op]] = op;
}
for (var x = 0; x < fnArrayLen; x++) {
var fnId = fnArray[x];
opList.push({
'fnId': fnId,
'fn': REVOPS[fnId],
'args': argsArray[x]
});
}
return opListToTree(opList);
},
executeOpTree: function SVGGraphics_executeOpTree(opTree) {
var opTreeLen = opTree.length;
for (var x = 0; x < opTreeLen; x++) {
var fn = opTree[x].fn;
var fnId = opTree[x].fnId;
var args = opTree[x].args;
switch (fnId | 0) {
case _util.OPS.beginText:
this.beginText();
break;
case _util.OPS.setLeading:
this.setLeading(args);
break;
case _util.OPS.setLeadingMoveText:
this.setLeadingMoveText(args[0], args[1]);
break;
case _util.OPS.setFont:
this.setFont(args);
break;
case _util.OPS.showText:
this.showText(args[0]);
break;
case _util.OPS.showSpacedText:
this.showText(args[0]);
break;
case _util.OPS.endText:
this.endText();
break;
case _util.OPS.moveText:
this.moveText(args[0], args[1]);
break;
case _util.OPS.setCharSpacing:
this.setCharSpacing(args[0]);
break;
case _util.OPS.setWordSpacing:
this.setWordSpacing(args[0]);
break;
case _util.OPS.setHScale:
this.setHScale(args[0]);
break;
case _util.OPS.setTextMatrix:
this.setTextMatrix(args[0], args[1], args[2], args[3], args[4],
args[5]);
break;
case _util.OPS.setLineWidth:
this.setLineWidth(args[0]);
break;
case _util.OPS.setLineJoin:
this.setLineJoin(args[0]);
break;
case _util.OPS.setLineCap:
this.setLineCap(args[0]);
break;
case _util.OPS.setMiterLimit:
this.setMiterLimit(args[0]);
break;
case _util.OPS.setFillRGBColor:
this.setFillRGBColor(args[0], args[1], args[2]);
break;
case _util.OPS.setStrokeRGBColor:
this.setStrokeRGBColor(args[0], args[1], args[2]);
break;
case _util.OPS.setDash:
this.setDash(args[0], args[1]);
break;
case _util.OPS.setGState:
this.setGState(args[0]);
break;
case _util.OPS.fill:
this.fill();
break;
case _util.OPS.eoFill:
this.eoFill();
break;
case _util.OPS.stroke:
this.stroke();
break;
case _util.OPS.fillStroke:
this.fillStroke();
break;
case _util.OPS.eoFillStroke:
this.eoFillStroke();
break;
case _util.OPS.clip:
this.clip('nonzero');
break;
case _util.OPS.eoClip:
this.clip('evenodd');
break;
case _util.OPS.paintSolidColorImageMask:
this.paintSolidColorImageMask();
break;
case _util.OPS.paintJpegXObject:
this.paintJpegXObject(args[0], args[1], args[2]);
break;
case _util.OPS.paintImageXObject:
this.paintImageXObject(args[0]);
break;
case _util.OPS.paintInlineImageXObject:
this.paintInlineImageXObject(args[0]);
break;
case _util.OPS.paintImageMaskXObject:
this.paintImageMaskXObject(args[0]);
break;
case _util.OPS.paintFormXObjectBegin:
this.paintFormXObjectBegin(args[0], args[1]);
break;
case _util.OPS.paintFormXObjectEnd:
this.paintFormXObjectEnd();
break;
case _util.OPS.closePath:
this.closePath();
break;
case _util.OPS.closeStroke:
this.closeStroke();
break;
case _util.OPS.closeFillStroke:
this.closeFillStroke();
break;
case _util.OPS.nextLine:
this.nextLine();
break;
case _util.OPS.transform:
this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
break;
case _util.OPS.constructPath:
this.constructPath(args[0], args[1]);
break;
case _util.OPS.endPath:
this.endPath();
break;
case 92:
this.group(opTree[x].items);
break;
default:
(0, _util.warn)('Unimplemented operator ' + fn);
break;
}
}
},
setWordSpacing: function SVGGraphics_setWordSpacing(wordSpacing) {
this.current.wordSpacing = wordSpacing;
},
setCharSpacing: function SVGGraphics_setCharSpacing(charSpacing) {
this.current.charSpacing = charSpacing;
},
nextLine: function SVGGraphics_nextLine() {
this.moveText(0, this.current.leading);
},
setTextMatrix: function SVGGraphics_setTextMatrix(a, b, c, d, e, f) {
var current = this.current;
this.current.textMatrix = this.current.lineMatrix = [a, b, c, d, e, f];
this.current.x = this.current.lineX = 0;
this.current.y = this.current.lineY = 0;
current.xcoords = [];
current.tspan = document.createElementNS(NS, 'svg:tspan');
current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
current.tspan.setAttributeNS(null, 'font-size', pf(current.fontSize) +
'px');
current.tspan.setAttributeNS(null, 'y', pf(-current.y));
current.txtElement = document.createElementNS(NS, 'svg:text');
current.txtElement.appendChild(current.tspan);
},
beginText: function SVGGraphics_beginText() {
this.current.x = this.current.lineX = 0;
this.current.y = this.current.lineY = 0;
this.current.textMatrix = _util.IDENTITY_MATRIX;
this.current.lineMatrix = _util.IDENTITY_MATRIX;
this.current.tspan = document.createElementNS(NS, 'svg:tspan');
this.current.txtElement = document.createElementNS(NS, 'svg:text');
this.current.txtgrp = document.createElementNS(NS, 'svg:g');
this.current.xcoords = [];
},
moveText: function SVGGraphics_moveText(x, y) {
var current = this.current;
this.current.x = this.current.lineX += x;
this.current.y = this.current.lineY += y;
current.xcoords = [];
current.tspan = document.createElementNS(NS, 'svg:tspan');
current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
current.tspan.setAttributeNS(null, 'font-size', pf(current.fontSize) +
'px');
current.tspan.setAttributeNS(null, 'y', pf(-current.y));
},
showText: function SVGGraphics_showText(glyphs) {
var current = this.current;
var font = current.font;
var fontSize = current.fontSize;
if (fontSize === 0) {
return;
}
var charSpacing = current.charSpacing;
var wordSpacing = current.wordSpacing;
var fontDirection = current.fontDirection;
var textHScale = current.textHScale * fontDirection;
var glyphsLength = glyphs.length;
var vertical = font.vertical;
var widthAdvanceScale = fontSize * current.fontMatrix[0];
var x = 0,
i;
for (i = 0; i < glyphsLength; ++i) {
var glyph = glyphs[i];
if (glyph === null) {
x += fontDirection * wordSpacing;
continue;
} else if ((0, _util.isNum)(glyph)) {
x += -glyph * fontSize * 0.001;
continue;
}
current.xcoords.push(current.x + x * textHScale);
var width = glyph.width;
var character = glyph.fontChar;
var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
var charWidth = width * widthAdvanceScale + spacing * fontDirection;
x += charWidth;
current.tspan.textContent += character;
}
if (vertical) {
current.y -= x * textHScale;
} else {
current.x += x * textHScale;
}
current.tspan.setAttributeNS(null, 'x', current.xcoords.map(pf).join(' '));
current.tspan.setAttributeNS(null, 'y', pf(-current.y));
current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
current.tspan.setAttributeNS(null, 'font-size', pf(current.fontSize) +
'px');
if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
current.tspan.setAttributeNS(null, 'font-style', current.fontStyle);
}
if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
current.tspan.setAttributeNS(null, 'font-weight', current.fontWeight);
}
if (current.fillColor !== SVG_DEFAULTS.fillColor) {
current.tspan.setAttributeNS(null, 'fill', current.fillColor);
}
current.txtElement.setAttributeNS(null, 'transform', pm(current.textMatrix)
+ ' scale(1, -1)');
current.txtElement.setAttributeNS(XML_NS, 'xml:space', 'preserve');
current.txtElement.appendChild(current.tspan);
current.txtgrp.appendChild(current.txtElement);
this._ensureTransformGroup().appendChild(current.txtElement);
},
setLeadingMoveText: function SVGGraphics_setLeadingMoveText(x, y) {
this.setLeading(-y);
this.moveText(x, y);
},
addFontStyle: function SVGGraphics_addFontStyle(fontObj) {
if (!this.cssStyle) {
this.cssStyle = document.createElementNS(NS, 'svg:style');
this.cssStyle.setAttributeNS(null, 'type', 'text/css');
this.defs.appendChild(this.cssStyle);
}
var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype,
this.forceDataSchema);
this.cssStyle.textContent += '@font-face { font-family: "' +
fontObj.loadedName + '";' + ' src: url(' + url + '); }\n';
},
setFont: function SVGGraphics_setFont(details) {
var current = this.current;
var fontObj = this.commonObjs.get(details[0]);
var size = details[1];
this.current.font = fontObj;
if (this.embedFonts && fontObj.data && !
this.embeddedFonts[fontObj.loadedName]) {
this.addFontStyle(fontObj);
this.embeddedFonts[fontObj.loadedName] = fontObj;
}
current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix :
_util.FONT_IDENTITY_MATRIX;
var bold = fontObj.black ? fontObj.bold ? 'bolder' : 'bold' :
fontObj.bold ? 'bold' : 'normal';
var italic = fontObj.italic ? 'italic' : 'normal';
if (size < 0) {
size = -size;
current.fontDirection = -1;
} else {
current.fontDirection = 1;
}
current.fontSize = size;
current.fontFamily = fontObj.loadedName;
current.fontWeight = bold;
current.fontStyle = italic;
current.tspan = document.createElementNS(NS, 'svg:tspan');
current.tspan.setAttributeNS(null, 'y', pf(-current.y));
current.xcoords = [];
},
endText: function SVGGraphics_endText() {},
setLineWidth: function SVGGraphics_setLineWidth(width) {
this.current.lineWidth = width;
},
setLineCap: function SVGGraphics_setLineCap(style) {
this.current.lineCap = LINE_CAP_STYLES[style];
},
setLineJoin: function SVGGraphics_setLineJoin(style) {
this.current.lineJoin = LINE_JOIN_STYLES[style];
},
setMiterLimit: function SVGGraphics_setMiterLimit(limit) {
this.current.miterLimit = limit;
},
setStrokeAlpha: function SVGGraphics_setStrokeAlpha(strokeAlpha) {
this.current.strokeAlpha = strokeAlpha;
},
setStrokeRGBColor: function SVGGraphics_setStrokeRGBColor(r, g, b) {
var color = _util.Util.makeCssRgb(r, g, b);
this.current.strokeColor = color;
},
setFillAlpha: function SVGGraphics_setFillAlpha(fillAlpha) {
this.current.fillAlpha = fillAlpha;
},
setFillRGBColor: function SVGGraphics_setFillRGBColor(r, g, b) {
var color = _util.Util.makeCssRgb(r, g, b);
this.current.fillColor = color;
this.current.tspan = document.createElementNS(NS, 'svg:tspan');
this.current.xcoords = [];
},
setDash: function SVGGraphics_setDash(dashArray, dashPhase) {
this.current.dashArray = dashArray;
this.current.dashPhase = dashPhase;
},
constructPath: function SVGGraphics_constructPath(ops, args) {
var current = this.current;
var x = current.x,
y = current.y;
current.path = document.createElementNS(NS, 'svg:path');
var d = [];
var opLength = ops.length;
for (var i = 0, j = 0; i < opLength; i++) {
switch (ops[i] | 0) {
case _util.OPS.rectangle:
x = args[j++];
y = args[j++];
var width = args[j++];
var height = args[j++];
var xw = x + width;
var yh = y + height;
d.push('M', pf(x), pf(y), 'L', pf(xw), pf(y), 'L', pf(xw), pf(yh),
'L', pf(x), pf(yh), 'Z');
break;
case _util.OPS.moveTo:
x = args[j++];
y = args[j++];
d.push('M', pf(x), pf(y));
break;
case _util.OPS.lineTo:
x = args[j++];
y = args[j++];
d.push('L', pf(x), pf(y));
break;
case _util.OPS.curveTo:
x = args[j + 4];
y = args[j + 5];
d.push('C', pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j
+ 3]), pf(x), pf(y));
j += 6;
break;
case _util.OPS.curveTo2:
x = args[j + 2];
y = args[j + 3];
d.push('C', pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j +
2]), pf(args[j + 3]));
j += 4;
break;
case _util.OPS.curveTo3:
x = args[j + 2];
y = args[j + 3];
d.push('C', pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x),
pf(y));
j += 4;
break;
case _util.OPS.closePath:
d.push('Z');
break;
}
}
current.path.setAttributeNS(null, 'd', d.join(' '));
current.path.setAttributeNS(null, 'fill', 'none');
this._ensureTransformGroup().appendChild(current.path);
current.element = current.path;
current.setCurrentPoint(x, y);
},
endPath: function SVGGraphics_endPath() {
if (!this.pendingClip) {
return;
}
var current = this.current;
var clipId = 'clippath' + clipCount;
clipCount++;
var clipPath = document.createElementNS(NS, 'svg:clipPath');
clipPath.setAttributeNS(null, 'id', clipId);
clipPath.setAttributeNS(null, 'transform', pm(this.transformMatrix));
var clipElement = current.element.cloneNode();
if (this.pendingClip === 'evenodd') {
clipElement.setAttributeNS(null, 'clip-rule', 'evenodd');
} else {
clipElement.setAttributeNS(null, 'clip-rule', 'nonzero');
}
this.pendingClip = null;
clipPath.appendChild(clipElement);
this.defs.appendChild(clipPath);
if (current.activeClipUrl) {
current.clipGroup = null;
this.extraStack.forEach(function (prev) {
prev.clipGroup = null;
});
}
current.activeClipUrl = 'url(#' + clipId + ')';
this.tgrp = null;
},
clip: function SVGGraphics_clip(type) {
this.pendingClip = type;
},
closePath: function SVGGraphics_closePath() {
var current = this.current;
var d = current.path.getAttributeNS(null, 'd');
d += 'Z';
current.path.setAttributeNS(null, 'd', d);
},
setLeading: function SVGGraphics_setLeading(leading) {
this.current.leading = -leading;
},
setTextRise: function SVGGraphics_setTextRise(textRise) {
this.current.textRise = textRise;
},
setHScale: function SVGGraphics_setHScale(scale) {
this.current.textHScale = scale / 100;
},
setGState: function SVGGraphics_setGState(states) {
for (var i = 0, ii = states.length; i < ii; i++) {
var state = states[i];
var key = state[0];
var value = state[1];
switch (key) {
case 'LW':
this.setLineWidth(value);
break;
case 'LC':
this.setLineCap(value);
break;
case 'LJ':
this.setLineJoin(value);
break;
case 'ML':
this.setMiterLimit(value);
break;
case 'D':
this.setDash(value[0], value[1]);
break;
case 'Font':
this.setFont(value);
break;
case 'CA':
this.setStrokeAlpha(value);
break;
case 'ca':
this.setFillAlpha(value);
break;
default:
(0, _util.warn)('Unimplemented graphic state ' + key);
break;
}
}
},
fill: function SVGGraphics_fill() {
var current = this.current;
current.element.setAttributeNS(null, 'fill', current.fillColor);
current.element.setAttributeNS(null, 'fill-opacity', current.fillAlpha);
},
stroke: function SVGGraphics_stroke() {
var current = this.current;
current.element.setAttributeNS(null, 'stroke', current.strokeColor);
current.element.setAttributeNS(null, 'stroke-opacity',
current.strokeAlpha);
current.element.setAttributeNS(null, 'stroke-miterlimit',
pf(current.miterLimit));
current.element.setAttributeNS(null, 'stroke-linecap', current.lineCap);
current.element.setAttributeNS(null, 'stroke-linejoin', current.lineJoin);
current.element.setAttributeNS(null, 'stroke-width', pf(current.lineWidth)
+ 'px');
current.element.setAttributeNS(null, 'stroke-dasharray',
current.dashArray.map(pf).join(' '));
current.element.setAttributeNS(null, 'stroke-dashoffset',
pf(current.dashPhase) + 'px');
current.element.setAttributeNS(null, 'fill', 'none');
},
eoFill: function SVGGraphics_eoFill() {
this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
this.fill();
},
fillStroke: function SVGGraphics_fillStroke() {
this.stroke();
this.fill();
},
eoFillStroke: function SVGGraphics_eoFillStroke() {
this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
this.fillStroke();
},
closeStroke: function SVGGraphics_closeStroke() {
this.closePath();
this.stroke();
},
closeFillStroke: function SVGGraphics_closeFillStroke() {
this.closePath();
this.fillStroke();
},
paintSolidColorImageMask: function SVGGraphics_paintSolidColorImageMask() {
var current = this.current;
var rect = document.createElementNS(NS, 'svg:rect');
rect.setAttributeNS(null, 'x', '0');
rect.setAttributeNS(null, 'y', '0');
rect.setAttributeNS(null, 'width', '1px');
rect.setAttributeNS(null, 'height', '1px');
rect.setAttributeNS(null, 'fill', current.fillColor);
this._ensureTransformGroup().appendChild(rect);
},
paintJpegXObject: function SVGGraphics_paintJpegXObject(objId, w, h) {
var imgObj = this.objs.get(objId);
var imgEl = document.createElementNS(NS, 'svg:image');
imgEl.setAttributeNS(XLINK_NS, 'xlink:href', imgObj.src);
imgEl.setAttributeNS(null, 'width', pf(w));
imgEl.setAttributeNS(null, 'height', pf(h));
imgEl.setAttributeNS(null, 'x', '0');
imgEl.setAttributeNS(null, 'y', pf(-h));
imgEl.setAttributeNS(null, 'transform', 'scale(' + pf(1 / w) + ' ' + pf(-
1 / h) + ')');
this._ensureTransformGroup().appendChild(imgEl);
},
paintImageXObject: function SVGGraphics_paintImageXObject(objId) {
var imgData = this.objs.get(objId);
if (!imgData) {
(0, _util.warn)('Dependent image isn\'t ready yet');
return;
}
this.paintInlineImageXObject(imgData);
},
paintInlineImageXObject: function
SVGGraphics_paintInlineImageXObject(imgData, mask) {
var width = imgData.width;
var height = imgData.height;
var imgSrc = convertImgDataToPng(imgData, this.forceDataSchema);
var cliprect = document.createElementNS(NS, 'svg:rect');
cliprect.setAttributeNS(null, 'x', '0');
cliprect.setAttributeNS(null, 'y', '0');
cliprect.setAttributeNS(null, 'width', pf(width));
cliprect.setAttributeNS(null, 'height', pf(height));
this.current.element = cliprect;
this.clip('nonzero');
var imgEl = document.createElementNS(NS, 'svg:image');
imgEl.setAttributeNS(XLINK_NS, 'xlink:href', imgSrc);
imgEl.setAttributeNS(null, 'x', '0');
imgEl.setAttributeNS(null, 'y', pf(-height));
imgEl.setAttributeNS(null, 'width', pf(width) + 'px');
imgEl.setAttributeNS(null, 'height', pf(height) + 'px');
imgEl.setAttributeNS(null, 'transform', 'scale(' + pf(1 / width) + ' ' +
pf(-1 / height) + ')');
if (mask) {
mask.appendChild(imgEl);
} else {
this._ensureTransformGroup().appendChild(imgEl);
}
},
paintImageMaskXObject: function SVGGraphics_paintImageMaskXObject(imgData) {
var current = this.current;
var width = imgData.width;
var height = imgData.height;
var fillColor = current.fillColor;
current.maskId = 'mask' + maskCount++;
var mask = document.createElementNS(NS, 'svg:mask');
mask.setAttributeNS(null, 'id', current.maskId);
var rect = document.createElementNS(NS, 'svg:rect');
rect.setAttributeNS(null, 'x', '0');
rect.setAttributeNS(null, 'y', '0');
rect.setAttributeNS(null, 'width', pf(width));
rect.setAttributeNS(null, 'height', pf(height));
rect.setAttributeNS(null, 'fill', fillColor);
rect.setAttributeNS(null, 'mask', 'url(#' + current.maskId + ')');
this.defs.appendChild(mask);
this._ensureTransformGroup().appendChild(rect);
this.paintInlineImageXObject(imgData, mask);
},
paintFormXObjectBegin: function SVGGraphics_paintFormXObjectBegin(matrix,
bbox) {
if ((0, _util.isArray)(matrix) && matrix.length === 6) {
this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4],
matrix[5]);
}
if ((0, _util.isArray)(bbox) && bbox.length === 4) {
var width = bbox[2] - bbox[0];
var height = bbox[3] - bbox[1];
var cliprect = document.createElementNS(NS, 'svg:rect');
cliprect.setAttributeNS(null, 'x', bbox[0]);
cliprect.setAttributeNS(null, 'y', bbox[1]);
cliprect.setAttributeNS(null, 'width', pf(width));
cliprect.setAttributeNS(null, 'height', pf(height));
this.current.element = cliprect;
this.clip('nonzero');
this.endPath();
}
},
paintFormXObjectEnd: function SVGGraphics_paintFormXObjectEnd() {},
_initialize: function SVGGraphics_initialize(viewport) {
var svg = document.createElementNS(NS, 'svg:svg');
svg.setAttributeNS(null, 'version', '1.1');
svg.setAttributeNS(null, 'width', viewport.width + 'px');
svg.setAttributeNS(null, 'height', viewport.height + 'px');
svg.setAttributeNS(null, 'preserveAspectRatio', 'none');
svg.setAttributeNS(null, 'viewBox', '0 0 ' + viewport.width + ' ' +
viewport.height);
var definitions = document.createElementNS(NS, 'svg:defs');
svg.appendChild(definitions);
this.defs = definitions;
var rootGroup = document.createElementNS(NS, 'svg:g');
rootGroup.setAttributeNS(null, 'transform', pm(viewport.transform));
svg.appendChild(rootGroup);
this.svg = rootGroup;
return svg;
},
_ensureClipGroup: function SVGGraphics_ensureClipGroup() {
if (!this.current.clipGroup) {
var clipGroup = document.createElementNS(NS, 'svg:g');
clipGroup.setAttributeNS(null, 'clip-path', this.current.activeClipUrl);
this.svg.appendChild(clipGroup);
this.current.clipGroup = clipGroup;
}
return this.current.clipGroup;
},
_ensureTransformGroup: function SVGGraphics_ensureTransformGroup() {
if (!this.tgrp) {
this.tgrp = document.createElementNS(NS, 'svg:g');
this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix));
if (this.current.activeClipUrl) {
this._ensureClipGroup().appendChild(this.tgrp);
} else {
this.svg.appendChild(this.tgrp);
}
}
return this.tgrp;
}
};
return SVGGraphics;
}();
}
exports.SVGGraphics = SVGGraphics;

/***/ }),
/* 5 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.renderTextLayer = undefined;

var _util = __w_pdfjs_require__(0);

var _dom_utils = __w_pdfjs_require__(1);

var renderTextLayer = function renderTextLayerClosure() {

this._textContent = textContent;
this._textContentStream = textContentStream;
this._container = container;
this._viewport = viewport;
this._textDivs = textDivs || [];
this._textContentItemsStr = textContentItemsStr || [];
this._enhanceTextSelection = !!enhanceTextSelection;
this._reader = null;
this._layoutTextLastFontSize = null;
this._layoutTextLastFontFamily = null;
this._layoutTextCtx = null;
this._textDivProperties = new WeakMap();
this._renderingDone = false;
this._canceled = false;
this._capability = (0, _util.createPromiseCapability)();
this._renderTimer = null;
this._bounds = [];
}
TextLayerRenderTask.prototype = {
get promise() {
return this._capability.promise;
},
cancel: function TextLayer_cancel() {
if (this._reader) {
this._reader.cancel(new _util.AbortException('text layer task cancelled'));
this._reader = null;
}
this._canceled = true;
if (this._renderTimer !== null) {
clearTimeout(this._renderTimer);
this._renderTimer = null;
}
this._capability.reject('canceled');
},
_processItems: function _processItems(items, styleCache) {
for (var i = 0, len = items.length; i < len; i++) {
this._textContentItemsStr.push(items[i].str);
appendText(this, items[i], styleCache);
}
},
_layoutText: function _layoutText(textDiv) {
var textLayerFrag = this._container;
var textDivProperties = this._textDivProperties.get(textDiv);
if (textDivProperties.isWhitespace) {
return;
}
var fontSize = textDiv.style.fontSize;
var fontFamily = textDiv.style.fontFamily;
if (fontSize !== this._layoutTextLastFontSize || fontFamily !==
this._layoutTextLastFontFamily) {
this._layoutTextCtx.font = fontSize + ' ' + fontFamily;
this._lastFontSize = fontSize;
this._lastFontFamily = fontFamily;
}
var width = this._layoutTextCtx.measureText(textDiv.textContent).width;
var transform = '';
if (textDivProperties.canvasWidth !== 0 && width > 0) {
textDivProperties.scale = textDivProperties.canvasWidth / width;
transform = 'scaleX(' + textDivProperties.scale + ')';
}
if (textDivProperties.angle !== 0) {
transform = 'rotate(' + textDivProperties.angle + 'deg) ' + transform;
}
if (transform !== '') {
textDivProperties.originalTransform = transform;
_dom_utils.CustomStyle.setProp('transform', textDiv, transform);
}
this._textDivProperties.set(textDiv, textDivProperties);
textLayerFrag.appendChild(textDiv);
},

_render: function TextLayer_render(timeout) {

var _this = this;

var capability = (0, _util.createPromiseCapability)();

var styleCache = Object.create(null);
var canvas = document.createElement('canvas');
canvas.mozOpaque = true;
this._layoutTextCtx = canvas.getContext('2d', { alpha: false });
if (this._textContent) {
var textItems = this._textContent.items;
var textStyles = this._textContent.styles;
this._processItems(textItems, textStyles);
capability.resolve();
} else if (this._textContentStream) {
var pump = function pump() {
_this._reader.read().then(function (_ref2) {
var value = _ref2.value,
done = _ref2.done;

if (done) {
capability.resolve();
return;
}
_util.Util.extendObj(styleCache, value.styles);
_this._processItems(value.items, styleCache);
pump();
}, capability.reject);
};
this._reader = this._textContentStream.getReader();
pump();
} else {
throw new Error('Neither "textContent" nor "textContentStream"' + '
parameters specified.');
}
capability.promise.then(function () {
styleCache = null;
if (!timeout) {
render(_this);
} else {
_this._renderTimer = setTimeout(function () {
render(_this);
_this._renderTimer = null;
}, timeout);
}
}, this._capability.reject);
},
expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
if (!this._enhanceTextSelection || !this._renderingDone) {
return;
}
if (this._bounds !== null) {
expand(this);
this._bounds = null;
}
for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
var div = this._textDivs[i];
var divProperties = this._textDivProperties.get(div);
if (divProperties.isWhitespace) {
continue;
}
if (expandDivs) {
var transform = '',
padding = '';
if (divProperties.scale !== 1) {
transform = 'scaleX(' + divProperties.scale + ')';
}
if (divProperties.angle !== 0) {
transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
}
if (divProperties.paddingLeft !== 0) {
padding += ' padding-left: ' + divProperties.paddingLeft /
divProperties.scale + 'px;';
transform += ' translateX(' + -divProperties.paddingLeft /
divProperties.scale + 'px)';
}
if (divProperties.paddingTop !== 0) {
padding += ' padding-top: ' + divProperties.paddingTop + 'px;';
transform += ' translateY(' + -divProperties.paddingTop + 'px)';
}
if (divProperties.paddingRight !== 0) {
padding += ' padding-right: ' + divProperties.paddingRight /
divProperties.scale + 'px;';
}
if (divProperties.paddingBottom !== 0) {
padding += ' padding-bottom: ' + divProperties.paddingBottom + 'px;';
}
if (padding !== '') {
div.setAttribute('style', divProperties.style + padding);
}
if (transform !== '') {
_dom_utils.CustomStyle.setProp('transform', div, transform);
}
} else {
div.style.padding = 0;
_dom_utils.CustomStyle.setProp('transform', div,
divProperties.originalTransform || '');
}
}
}
};
function renderTextLayer(renderParameters) {
var task = new TextLayerRenderTask({
textContent: renderParameters.textContent,
textContentStream: renderParameters.textContentStream,
container: renderParameters.container,
viewport: renderParameters.viewport,
textDivs: renderParameters.textDivs,
textContentItemsStr: renderParameters.textContentItemsStr,
enhanceTextSelection: renderParameters.enhanceTextSelection
});
task._render(renderParameters.timeout);
return task;
}
return renderTextLayer;
}();
exports.renderTextLayer = renderTextLayer;

/***/ }),
/* 6 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
function fixMetadata(meta) {
return meta.replace(/>\\376\\377([^<]+)/g, function (all, codes) {
var bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2,
d3) {
return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
});
var chars = '';
for (var i = 0; i < bytes.length; i += 2) {
var code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
chars += code >= 32 && code < 127 && code !== 60 && code !== 62 && code !==
38 ? String.fromCharCode(code) : '&#x' + (0x10000 + code).toString(16).substring(1)
+ ';';
}
return '>' + chars;
});
}
function Metadata(meta) {
if (typeof meta === 'string') {
meta = fixMetadata(meta);
var parser = new DOMParser();
meta = parser.parseFromString(meta, 'application/xml');
} else if (!(meta instanceof Document)) {
throw new Error('Metadata: Invalid metadata object');
}
this.metaDocument = meta;
this.metadata = Object.create(null);
this.parse();
}
Metadata.prototype = {
parse: function Metadata_parse() {
var doc = this.metaDocument;
var rdf = doc.documentElement;
if (rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
rdf = rdf.firstChild;
while (rdf && rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
rdf = rdf.nextSibling;
}
}
var nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
if (!rdf || nodeName !== 'rdf:rdf' || !rdf.hasChildNodes()) {
return;
}
var children = rdf.childNodes,
desc,
entry,
name,
i,
ii,
length,
iLength;
for (i = 0, length = children.length; i < length; i++) {
desc = children[i];
if (desc.nodeName.toLowerCase() !== 'rdf:description') {
continue;
}
for (ii = 0, iLength = desc.childNodes.length; ii < iLength; ii++) {
if (desc.childNodes[ii].nodeName.toLowerCase() !== '#text') {
entry = desc.childNodes[ii];
name = entry.nodeName.toLowerCase();
this.metadata[name] = entry.textContent.trim();
}
}
}
},
get: function Metadata_get(name) {
return this.metadata[name] || null;
},
has: function Metadata_has(name) {
return typeof this.metadata[name] !== 'undefined';
}
};
exports.Metadata = Metadata;

/***/ }),
/* 7 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.WebGLUtils = undefined;

var _dom_utils = __w_pdfjs_require__(1);

var _util = __w_pdfjs_require__(0);

var WebGLUtils = function WebGLUtilsClosure() {

/***/ }),
/* 8 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PDFJS = exports.isWorker = exports.globalScope = undefined;

var _api = __w_pdfjs_require__(2);

var _dom_utils = __w_pdfjs_require__(1);

var _util = __w_pdfjs_require__(0);

var _annotation_layer = __w_pdfjs_require__(3);

var _metadata = __w_pdfjs_require__(6);

var _text_layer = __w_pdfjs_require__(5);

var _svg = __w_pdfjs_require__(4);

var isWorker = typeof window === 'undefined';

if (!_util.globalScope.PDFJS) {
_util.globalScope.PDFJS = {};
}
var PDFJS = _util.globalScope.PDFJS;
{
PDFJS.version = '1.9.426';
PDFJS.build = '2558a58d';
}
PDFJS.pdfBug = false;
if (PDFJS.verbosity !== undefined) {
(0, _util.setVerbosityLevel)(PDFJS.verbosity);
}
delete PDFJS.verbosity;
Object.defineProperty(PDFJS, 'verbosity', {
get: function get() {
return (0, _util.getVerbosityLevel)();
},
set: function set(level) {
(0, _util.setVerbosityLevel)(level);
},

enumerable: true,
configurable: true
});
PDFJS.VERBOSITY_LEVELS = _util.VERBOSITY_LEVELS;
PDFJS.OPS = _util.OPS;
PDFJS.UNSUPPORTED_FEATURES = _util.UNSUPPORTED_FEATURES;
PDFJS.isValidUrl = _dom_utils.isValidUrl;
PDFJS.shadow = _util.shadow;
PDFJS.createBlob = _util.createBlob;
PDFJS.createObjectURL = function PDFJS_createObjectURL(data, contentType) {
return (0, _util.createObjectURL)(data, contentType,
PDFJS.disableCreateObjectURL);
};
Object.defineProperty(PDFJS, 'isLittleEndian', {
configurable: true,
get: function PDFJS_isLittleEndian() {
return (0, _util.shadow)(PDFJS, 'isLittleEndian', (0, _util.isLittleEndian)());
}
});
PDFJS.removeNullCharacters = _util.removeNullCharacters;
PDFJS.PasswordResponses = _util.PasswordResponses;
PDFJS.PasswordException = _util.PasswordException;
PDFJS.UnknownErrorException = _util.UnknownErrorException;
PDFJS.InvalidPDFException = _util.InvalidPDFException;
PDFJS.MissingPDFException = _util.MissingPDFException;
PDFJS.UnexpectedResponseException = _util.UnexpectedResponseException;
PDFJS.Util = _util.Util;
PDFJS.PageViewport = _util.PageViewport;
PDFJS.createPromiseCapability = _util.createPromiseCapability;
PDFJS.maxImageSize = PDFJS.maxImageSize === undefined ? -1 : PDFJS.maxImageSize;
PDFJS.cMapUrl = PDFJS.cMapUrl === undefined ? null : PDFJS.cMapUrl;
PDFJS.cMapPacked = PDFJS.cMapPacked === undefined ? false : PDFJS.cMapPacked;
PDFJS.disableFontFace = PDFJS.disableFontFace === undefined ? false :
PDFJS.disableFontFace;
PDFJS.imageResourcesPath = PDFJS.imageResourcesPath === undefined ? '' :
PDFJS.imageResourcesPath;
PDFJS.disableWorker = PDFJS.disableWorker === undefined ? false :
PDFJS.disableWorker;
PDFJS.workerSrc = PDFJS.workerSrc === undefined ? null : PDFJS.workerSrc;
PDFJS.workerPort = PDFJS.workerPort === undefined ? null : PDFJS.workerPort;
PDFJS.disableRange = PDFJS.disableRange === undefined ? false : PDFJS.disableRange;
PDFJS.disableStream = PDFJS.disableStream === undefined ? false :
PDFJS.disableStream;
PDFJS.disableAutoFetch = PDFJS.disableAutoFetch === undefined ? false :
PDFJS.disableAutoFetch;
PDFJS.pdfBug = PDFJS.pdfBug === undefined ? false : PDFJS.pdfBug;
PDFJS.postMessageTransfers = PDFJS.postMessageTransfers === undefined ? true :
PDFJS.postMessageTransfers;
PDFJS.disableCreateObjectURL = PDFJS.disableCreateObjectURL === undefined ? false :
PDFJS.disableCreateObjectURL;
PDFJS.disableWebGL = PDFJS.disableWebGL === undefined ? true : PDFJS.disableWebGL;
PDFJS.externalLinkTarget = PDFJS.externalLinkTarget === undefined ?
_dom_utils.LinkTarget.NONE : PDFJS.externalLinkTarget;
PDFJS.externalLinkRel = PDFJS.externalLinkRel === undefined ?
_dom_utils.DEFAULT_LINK_REL : PDFJS.externalLinkRel;
PDFJS.isEvalSupported = PDFJS.isEvalSupported === undefined ? true :
PDFJS.isEvalSupported;
PDFJS.pdfjsNext = PDFJS.pdfjsNext === undefined ? false : PDFJS.pdfjsNext;
{
var savedOpenExternalLinksInNewWindow = PDFJS.openExternalLinksInNewWindow;
delete PDFJS.openExternalLinksInNewWindow;
Object.defineProperty(PDFJS, 'openExternalLinksInNewWindow', {
get: function get() {
return PDFJS.externalLinkTarget === _dom_utils.LinkTarget.BLANK;
},
set: function set(value) {
if (value) {
(0, _util.deprecated)('PDFJS.openExternalLinksInNewWindow, please use ' +
'"PDFJS.externalLinkTarget = PDFJS.LinkTarget.BLANK" instead.');
}
if (PDFJS.externalLinkTarget !== _dom_utils.LinkTarget.NONE) {
(0, _util.warn)('PDFJS.externalLinkTarget is already initialized');
return;
}
PDFJS.externalLinkTarget = value ? _dom_utils.LinkTarget.BLANK :
_dom_utils.LinkTarget.NONE;
},

enumerable: true,
configurable: true
});
if (savedOpenExternalLinksInNewWindow) {
PDFJS.openExternalLinksInNewWindow = savedOpenExternalLinksInNewWindow;
}
}
PDFJS.getDocument = _api.getDocument;
PDFJS.LoopbackPort = _api.LoopbackPort;
PDFJS.PDFDataRangeTransport = _api.PDFDataRangeTransport;
PDFJS.PDFWorker = _api.PDFWorker;
PDFJS.hasCanvasTypedArrays = true;
PDFJS.CustomStyle = _dom_utils.CustomStyle;
PDFJS.LinkTarget = _dom_utils.LinkTarget;
PDFJS.addLinkAttributes = _dom_utils.addLinkAttributes;
PDFJS.getFilenameFromUrl = _dom_utils.getFilenameFromUrl;
PDFJS.isExternalLinkTargetSet = _dom_utils.isExternalLinkTargetSet;
PDFJS.AnnotationLayer = _annotation_layer.AnnotationLayer;
PDFJS.renderTextLayer = _text_layer.renderTextLayer;
PDFJS.Metadata = _metadata.Metadata;
PDFJS.SVGGraphics = _svg.SVGGraphics;
PDFJS.UnsupportedManager = _api._UnsupportedManager;
exports.globalScope = _util.globalScope;
exports.isWorker = isWorker;
exports.PDFJS = PDFJS;

/***/ }),
/* 9 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.NetworkManager = exports.PDFNetworkStream = undefined;

var _util = __w_pdfjs_require__(0);

var _api = __w_pdfjs_require__(2);

;
var OK_RESPONSE = 200;
var PARTIAL_CONTENT_RESPONSE = 206;
function NetworkManager(url, args) {
this.url = url;
args = args || {};
this.isHttp = /^https?:/i.test(url);
this.httpHeaders = this.isHttp && args.httpHeaders || {};
this.withCredentials = args.withCredentials || false;
this.getXhr = args.getXhr || function NetworkManager_getXhr() {
return new XMLHttpRequest();
};
this.currXhrId = 0;
this.pendingRequests = Object.create(null);
this.loadedRequests = Object.create(null);
}
function getArrayBuffer(xhr) {
var data = xhr.response;
if (typeof data !== 'string') {
return data;
}
var length = data.length;
var array = new Uint8Array(length);
for (var i = 0; i < length; i++) {
array[i] = data.charCodeAt(i) & 0xFF;
}
return array.buffer;
}
var supportsMozChunked = function supportsMozChunkedClosure() {
try {
var x = new XMLHttpRequest();
x.open('GET', _util.globalScope.location.href);
x.responseType = 'moz-chunked-arraybuffer';
return x.responseType === 'moz-chunked-arraybuffer';
} catch (e) {
return false;
}
}();
NetworkManager.prototype = {
requestRange: function NetworkManager_requestRange(begin, end, listeners) {
var args = {
begin: begin,
end: end
};
for (var prop in listeners) {
args[prop] = listeners[prop];
}
return this.request(args);
},
requestFull: function NetworkManager_requestFull(listeners) {
return this.request(listeners);
},
request: function NetworkManager_request(args) {
var xhr = this.getXhr();
var xhrId = this.currXhrId++;
var pendingRequest = this.pendingRequests[xhrId] = { xhr: xhr };
xhr.open('GET', this.url);
xhr.withCredentials = this.withCredentials;
for (var property in this.httpHeaders) {
var value = this.httpHeaders[property];
if (typeof value === 'undefined') {
continue;
}
xhr.setRequestHeader(property, value);
}
if (this.isHttp && 'begin' in args && 'end' in args) {
var rangeStr = args.begin + '-' + (args.end - 1);
xhr.setRequestHeader('Range', 'bytes=' + rangeStr);
pendingRequest.expectedStatus = 206;
} else {
pendingRequest.expectedStatus = 200;
}
var useMozChunkedLoading = supportsMozChunked && !!args.onProgressiveData;
if (useMozChunkedLoading) {
xhr.responseType = 'moz-chunked-arraybuffer';
pendingRequest.onProgressiveData = args.onProgressiveData;
pendingRequest.mozChunked = true;
} else {
xhr.responseType = 'arraybuffer';
}
if (args.onError) {
xhr.onerror = function (evt) {
args.onError(xhr.status);
};
}
xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
xhr.onprogress = this.onProgress.bind(this, xhrId);
pendingRequest.onHeadersReceived = args.onHeadersReceived;
pendingRequest.onDone = args.onDone;
pendingRequest.onError = args.onError;
pendingRequest.onProgress = args.onProgress;
xhr.send(null);
return xhrId;
},
onProgress: function NetworkManager_onProgress(xhrId, evt) {
var pendingRequest = this.pendingRequests[xhrId];
if (!pendingRequest) {
return;
}
if (pendingRequest.mozChunked) {
var chunk = getArrayBuffer(pendingRequest.xhr);
pendingRequest.onProgressiveData(chunk);
}
var onProgress = pendingRequest.onProgress;
if (onProgress) {
onProgress(evt);
}
},
onStateChange: function NetworkManager_onStateChange(xhrId, evt) {
var pendingRequest = this.pendingRequests[xhrId];
if (!pendingRequest) {
return;
}
var xhr = pendingRequest.xhr;
if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
pendingRequest.onHeadersReceived();
delete pendingRequest.onHeadersReceived;
}
if (xhr.readyState !== 4) {
return;
}
if (!(xhrId in this.pendingRequests)) {
return;
}
delete this.pendingRequests[xhrId];
if (xhr.status === 0 && this.isHttp) {
if (pendingRequest.onError) {
pendingRequest.onError(xhr.status);
}
return;
}
var xhrStatus = xhr.status || OK_RESPONSE;
var ok_response_on_range_request = xhrStatus === OK_RESPONSE &&
pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
if (!ok_response_on_range_request && xhrStatus !==
pendingRequest.expectedStatus) {
if (pendingRequest.onError) {
pendingRequest.onError(xhr.status);
}
return;
}
this.loadedRequests[xhrId] = true;
var chunk = getArrayBuffer(xhr);
if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
var rangeHeader = xhr.getResponseHeader('Content-Range');
var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
var begin = parseInt(matches[1], 10);
pendingRequest.onDone({
begin: begin,
chunk: chunk
});
} else if (pendingRequest.onProgressiveData) {
pendingRequest.onDone(null);
} else if (chunk) {
pendingRequest.onDone({
begin: 0,
chunk: chunk
});
} else if (pendingRequest.onError) {
pendingRequest.onError(xhr.status);
}
},
hasPendingRequests: function NetworkManager_hasPendingRequests() {
for (var xhrId in this.pendingRequests) {
return true;
}
return false;
},
getRequestXhr: function NetworkManager_getXhr(xhrId) {
return this.pendingRequests[xhrId].xhr;
},
isStreamingRequest: function NetworkManager_isStreamingRequest(xhrId) {
return !!this.pendingRequests[xhrId].onProgressiveData;
},
isPendingRequest: function NetworkManager_isPendingRequest(xhrId) {
return xhrId in this.pendingRequests;
},
isLoadedRequest: function NetworkManager_isLoadedRequest(xhrId) {
return xhrId in this.loadedRequests;
},
abortAllRequests: function NetworkManager_abortAllRequests() {
for (var xhrId in this.pendingRequests) {
this.abortRequest(xhrId | 0);
}
},
abortRequest: function NetworkManager_abortRequest(xhrId) {
var xhr = this.pendingRequests[xhrId].xhr;
delete this.pendingRequests[xhrId];
xhr.abort();
}
};
function PDFNetworkStream(options) {
this._options = options;
var source = options.source;
this._manager = new NetworkManager(source.url, {
httpHeaders: source.httpHeaders,
withCredentials: source.withCredentials
});
this._rangeChunkSize = source.rangeChunkSize;
this._fullRequestReader = null;
this._rangeRequestReaders = [];
}
PDFNetworkStream.prototype = {
_onRangeRequestReaderClosed: function
PDFNetworkStream_onRangeRequestReaderClosed(reader) {
var i = this._rangeRequestReaders.indexOf(reader);
if (i >= 0) {
this._rangeRequestReaders.splice(i, 1);
}
},
getFullReader: function PDFNetworkStream_getFullReader() {
(0, _util.assert)(!this._fullRequestReader);
this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager,
this._options);
return this._fullRequestReader;
},
getRangeReader: function PDFNetworkStream_getRangeReader(begin, end) {
var reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
this._rangeRequestReaders.push(reader);
return reader;
},
cancelAllRequests: function PDFNetworkStream_cancelAllRequests(reason) {
if (this._fullRequestReader) {
this._fullRequestReader.cancel(reason);
}
var readers = this._rangeRequestReaders.slice(0);
readers.forEach(function (reader) {
reader.cancel(reason);
});
}
};
function PDFNetworkStreamFullRequestReader(manager, options) {
this._manager = manager;
var source = options.source;
var args = {
onHeadersReceived: this._onHeadersReceived.bind(this),
onProgressiveData: source.disableStream ? null :
this._onProgressiveData.bind(this),
onDone: this._onDone.bind(this),
onError: this._onError.bind(this),
onProgress: this._onProgress.bind(this)
};
this._url = source.url;
this._fullRequestId = manager.requestFull(args);
this._headersReceivedCapability = (0, _util.createPromiseCapability)();
this._disableRange = options.disableRange || false;
this._contentLength = source.length;
this._rangeChunkSize = source.rangeChunkSize;
if (!this._rangeChunkSize && !this._disableRange) {
this._disableRange = true;
}
this._isStreamingSupported = false;
this._isRangeSupported = false;
this._cachedChunks = [];
this._requests = [];
this._done = false;
this._storedError = undefined;
this.onProgress = null;
}
PDFNetworkStreamFullRequestReader.prototype = {
_validateRangeRequestCapabilities: function
PDFNetworkStreamFullRequestReader_validateRangeRequestCapabilities() {
if (this._disableRange) {
return false;
}
var networkManager = this._manager;
if (!networkManager.isHttp) {
return false;
}
var fullRequestXhrId = this._fullRequestId;
var fullRequestXhr = networkManager.getRequestXhr(fullRequestXhrId);
if (fullRequestXhr.getResponseHeader('Accept-Ranges') !== 'bytes') {
return false;
}
var contentEncoding = fullRequestXhr.getResponseHeader('Content-Encoding') ||
'identity';
if (contentEncoding !== 'identity') {
return false;
}
var length = fullRequestXhr.getResponseHeader('Content-Length');
length = parseInt(length, 10);
if (!(0, _util.isInt)(length)) {
return false;
}
this._contentLength = length;
if (length <= 2 * this._rangeChunkSize) {
return false;
}
return true;
},
_onHeadersReceived: function
PDFNetworkStreamFullRequestReader_onHeadersReceived() {
if (this._validateRangeRequestCapabilities()) {
this._isRangeSupported = true;
}
var networkManager = this._manager;
var fullRequestXhrId = this._fullRequestId;
if (networkManager.isStreamingRequest(fullRequestXhrId)) {
this._isStreamingSupported = true;
} else if (this._isRangeSupported) {
networkManager.abortRequest(fullRequestXhrId);
}
this._headersReceivedCapability.resolve();
},
_onProgressiveData: function
PDFNetworkStreamFullRequestReader_onProgressiveData(chunk) {
if (this._requests.length > 0) {
var requestCapability = this._requests.shift();
requestCapability.resolve({
value: chunk,
done: false
});
} else {
this._cachedChunks.push(chunk);
}
},
_onDone: function PDFNetworkStreamFullRequestReader_onDone(args) {
if (args) {
this._onProgressiveData(args.chunk);
}
this._done = true;
if (this._cachedChunks.length > 0) {
return;
}
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
},
_onError: function PDFNetworkStreamFullRequestReader_onError(status) {
var url = this._url;
var exception;
if (status === 404 || status === 0 && /^file:/.test(url)) {
exception = new _util.MissingPDFException('Missing PDF "' + url + '".');
} else {
exception = new _util.UnexpectedResponseException('Unexpected server response
(' + status + ') while retrieving PDF "' + url + '".', status);
}
this._storedError = exception;
this._headersReceivedCapability.reject(exception);
this._requests.forEach(function (requestCapability) {
requestCapability.reject(exception);
});
this._requests = [];
this._cachedChunks = [];
},
_onProgress: function PDFNetworkStreamFullRequestReader_onProgress(data) {
if (this.onProgress) {
this.onProgress({
loaded: data.loaded,
total: data.lengthComputable ? data.total : this._contentLength
});
}
},
get isRangeSupported() {
return this._isRangeSupported;
},
get isStreamingSupported() {
return this._isStreamingSupported;
},
get contentLength() {
return this._contentLength;
},
get headersReady() {
return this._headersReceivedCapability.promise;
},
read: function PDFNetworkStreamFullRequestReader_read() {
if (this._storedError) {
return Promise.reject(this._storedError);
}
if (this._cachedChunks.length > 0) {
var chunk = this._cachedChunks.shift();
return Promise.resolve({
value: chunk,
done: false
});
}
if (this._done) {
return Promise.resolve({
value: undefined,
done: true
});
}
var requestCapability = (0, _util.createPromiseCapability)();
this._requests.push(requestCapability);
return requestCapability.promise;
},
cancel: function PDFNetworkStreamFullRequestReader_cancel(reason) {
this._done = true;
this._headersReceivedCapability.reject(reason);
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
if (this._manager.isPendingRequest(this._fullRequestId)) {
this._manager.abortRequest(this._fullRequestId);
}
this._fullRequestReader = null;
}
};
function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
this._manager = manager;
var args = {
onDone: this._onDone.bind(this),
onProgress: this._onProgress.bind(this)
};
this._requestId = manager.requestRange(begin, end, args);
this._requests = [];
this._queuedChunk = null;
this._done = false;
this.onProgress = null;
this.onClosed = null;
}
PDFNetworkStreamRangeRequestReader.prototype = {
_close: function PDFNetworkStreamRangeRequestReader_close() {
if (this.onClosed) {
this.onClosed(this);
}
},
_onDone: function PDFNetworkStreamRangeRequestReader_onDone(data) {
var chunk = data.chunk;
if (this._requests.length > 0) {
var requestCapability = this._requests.shift();
requestCapability.resolve({
value: chunk,
done: false
});
} else {
this._queuedChunk = chunk;
}
this._done = true;
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
this._close();
},
_onProgress: function PDFNetworkStreamRangeRequestReader_onProgress(evt) {
if (!this.isStreamingSupported && this.onProgress) {
this.onProgress({ loaded: evt.loaded });
}
},
get isStreamingSupported() {
return false;
},
read: function PDFNetworkStreamRangeRequestReader_read() {
if (this._queuedChunk !== null) {
var chunk = this._queuedChunk;
this._queuedChunk = null;
return Promise.resolve({
value: chunk,
done: false
});
}
if (this._done) {
return Promise.resolve({
value: undefined,
done: true
});
}
var requestCapability = (0, _util.createPromiseCapability)();
this._requests.push(requestCapability);
return requestCapability.promise;
},
cancel: function PDFNetworkStreamRangeRequestReader_cancel(reason) {
this._done = true;
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
if (this._manager.isPendingRequest(this._requestId)) {
this._manager.abortRequest(this._requestId);
}
this._close();
}
};
(0, _api.setPDFNetworkStreamClass)(PDFNetworkStream);
exports.PDFNetworkStream = PDFNetworkStream;
exports.NetworkManager = NetworkManager;

/***/ }),
/* 10 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var _typeof2 = 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; };

var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) ===

"symbol" ? function (obj) {
return typeof obj === 'undefined' ? 'undefined' : _typeof2(obj);
} : function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj
!== Symbol.prototype ? "symbol" : typeof obj === 'undefined' ? 'undefined' :
_typeof2(obj);
};
var _require = __w_pdfjs_require__(1),
assert = _require.assert;
function IsPropertyKey(argument) {
return typeof argument === 'string' || (typeof argument === 'undefined' ?
'undefined' : _typeof(argument)) === 'symbol';
}
exports.typeIsObject = function (x) {
return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' &&
x !== null || typeof x === 'function';
};
exports.createDataProperty = function (o, p, v) {
assert(exports.typeIsObject(o));
Object.defineProperty(o, p, {
value: v,
writable: true,
enumerable: true,
configurable: true
});
};
exports.createArrayFromList = function (elements) {
return elements.slice();
};
exports.ArrayBufferCopy = function (dest, destOffset, src, srcOffset, n) {
new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
};
exports.CreateIterResultObject = function (value, done) {
assert(typeof done === 'boolean');
var obj = {};
Object.defineProperty(obj, 'value', {
value: value,
enumerable: true,
writable: true,
configurable: true
});
Object.defineProperty(obj, 'done', {
value: done,
enumerable: true,
writable: true,
configurable: true
});
return obj;
};
exports.IsFiniteNonNegativeNumber = function (v) {
if (Number.isNaN(v)) {
return false;
}
if (v === Infinity) {
return false;
}
if (v < 0) {
return false;
}
return true;
};
function Call(F, V, args) {
if (typeof F !== 'function') {
throw new TypeError('Argument is not a function');
}
return Function.prototype.apply.call(F, V, args);
}
exports.InvokeOrNoop = function (O, P, args) {
assert(O !== undefined);
assert(IsPropertyKey(P));
assert(Array.isArray(args));
var method = O[P];
if (method === undefined) {
return undefined;
}
return Call(method, O, args);
};
exports.PromiseInvokeOrNoop = function (O, P, args) {
assert(O !== undefined);
assert(IsPropertyKey(P));
assert(Array.isArray(args));
try {
return Promise.resolve(exports.InvokeOrNoop(O, P, args));
} catch (returnValueE) {
return Promise.reject(returnValueE);
}
};
exports.PromiseInvokeOrPerformFallback = function (O, P, args, F, argsF) {
assert(O !== undefined);
assert(IsPropertyKey(P));
assert(Array.isArray(args));
assert(Array.isArray(argsF));
var method = void 0;
try {
method = O[P];
} catch (methodE) {
return Promise.reject(methodE);
}
if (method === undefined) {
return F.apply(null, argsF);
}
try {
return Promise.resolve(Call(method, O, args));
} catch (e) {
return Promise.reject(e);
}
};
exports.TransferArrayBuffer = function (O) {
return O.slice();
};
exports.ValidateAndNormalizeHighWaterMark = function (highWaterMark) {
highWaterMark = Number(highWaterMark);
if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
throw new RangeError('highWaterMark property of a queuing strategy must be
non-negative and non-NaN');
}
return highWaterMark;
};
exports.ValidateAndNormalizeQueuingStrategy = function (size, highWaterMark) {
if (size !== undefined && typeof size !== 'function') {
throw new TypeError('size property of a queuing strategy must be a
function');
}
highWaterMark = exports.ValidateAndNormalizeHighWaterMark(highWaterMark);
return {
size: size,
highWaterMark: highWaterMark
};
};
}, function (module, exports, __w_pdfjs_require__) {
"use strict";
function rethrowAssertionErrorRejection(e) {
if (e && e.constructor === AssertionError) {
setTimeout(function () {
throw e;
}, 0);
}
}
function AssertionError(message) {
this.name = 'AssertionError';
this.message = message || '';
this.stack = new Error().stack;
}
AssertionError.prototype = Object.create(Error.prototype);
AssertionError.prototype.constructor = AssertionError;
function assert(value, message) {
if (!value) {
throw new AssertionError(message);
}
}
module.exports = {
rethrowAssertionErrorRejection: rethrowAssertionErrorRejection,
AssertionError: AssertionError,
assert: assert
};
}, function (module, exports, __w_pdfjs_require__) {
"use strict";

var _createClass = function () {

var _require = __w_pdfjs_require__(0),

IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;
var _require2 = __w_pdfjs_require__(1),
assert = _require2.assert;
exports.DequeueValue = function (container) {
assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level
failure: DequeueValue should only be used on containers with [[queue]] and
[[queueTotalSize]].');
assert(container._queue.length > 0, 'Spec-level failure: should never dequeue
from an empty queue.');
var pair = container._queue.shift();
container._queueTotalSize -= pair.size;
if (container._queueTotalSize < 0) {
container._queueTotalSize = 0;
}
return pair.value;
};
exports.EnqueueValueWithSize = function (container, value, size) {
assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level
failure: EnqueueValueWithSize should only be used on containers with [[queue]] and
' + '[[queueTotalSize]].');
size = Number(size);
if (!IsFiniteNonNegativeNumber(size)) {
throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
}
container._queue.push({
value: value,
size: size
});
container._queueTotalSize += size;
};
exports.PeekQueueValue = function (container) {
assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level
failure: PeekQueueValue should only be used on containers with [[queue]] and
[[queueTotalSize]].');
assert(container._queue.length > 0, 'Spec-level failure: should never peek at
an empty queue.');
var pair = container._queue[0];
return pair.value;
};
exports.ResetQueue = function (container) {
assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level
failure: ResetQueue should only be used on containers with [[queue]] and
[[queueTotalSize]].');
container._queue = [];
container._queueTotalSize = 0;
};
}, function (module, exports, __w_pdfjs_require__) {
"use strict";

var _createClass = function () {

ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise);
return readable;
}
}, {
key: 'pipeTo',
value: function pipeTo(dest) {
var _this = this;
var _ref4 = arguments.length > 1 && arguments[1] !== undefined ?
arguments[1] : {},
preventClose = _ref4.preventClose,
preventAbort = _ref4.preventAbort,
preventCancel = _ref4.preventCancel;
if (IsReadableStream(this) === false) {
return Promise.reject(streamBrandCheckException('pipeTo'));
}
if (IsWritableStream(dest) === false) {
return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s
first argument must be a WritableStream'));
}
preventClose = Boolean(preventClose);
preventAbort = Boolean(preventAbort);
preventCancel = Boolean(preventCancel);
if (IsReadableStreamLocked(this) === true) {
return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo
cannot be used on a locked ReadableStream'));
}
if (IsWritableStreamLocked(dest) === true) {
return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo
cannot be used on a locked WritableStream'));
}
var reader = AcquireReadableStreamDefaultReader(this);
var writer = AcquireWritableStreamDefaultWriter(dest);
var shuttingDown = false;
var currentWrite = Promise.resolve();
return new Promise(function (resolve, reject) {
function pipeLoop() {
currentWrite = Promise.resolve();
if (shuttingDown === true) {
return Promise.resolve();
}
return writer._readyPromise.then(function () {
return ReadableStreamDefaultReaderRead(reader).then(function (_ref5)
{
var value = _ref5.value,
done = _ref5.done;
if (done === true) {
return;
}
currentWrite = WritableStreamDefaultWriterWrite(writer,
value).catch(function () {});
});
}).then(pipeLoop);
}
isOrBecomesErrored(_this, reader._closedPromise, function (storedError) {
if (preventAbort === false) {
shutdownWithAction(function () {
return WritableStreamAbort(dest, storedError);
}, true, storedError);
} else {
shutdown(true, storedError);
}
});
isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
if (preventCancel === false) {
shutdownWithAction(function () {
return ReadableStreamCancel(_this, storedError);
}, true, storedError);
} else {
shutdown(true, storedError);
}
});
isOrBecomesClosed(_this, reader._closedPromise, function () {
if (preventClose === false) {
shutdownWithAction(function () {
return
WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
});
} else {
shutdown();
}
});
if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state ===
'closed') {
var destClosed = new TypeError('the destination writable stream closed
before all data could be piped to it');
if (preventCancel === false) {
shutdownWithAction(function () {
return ReadableStreamCancel(_this, destClosed);
}, true, destClosed);
} else {
shutdown(true, destClosed);
}
}
pipeLoop().catch(function (err) {
currentWrite = Promise.resolve();
rethrowAssertionErrorRejection(err);
});
function waitForWritesToFinish() {
var oldCurrentWrite = currentWrite;
return currentWrite.then(function () {
return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() :
undefined;
});
}
function isOrBecomesErrored(stream, promise, action) {
if (stream._state === 'errored') {
action(stream._storedError);
} else {
promise.catch(action).catch(rethrowAssertionErrorRejection);
}
}
function isOrBecomesClosed(stream, promise, action) {
if (stream._state === 'closed') {
action();
} else {
promise.then(action).catch(rethrowAssertionErrorRejection);
}
}
function shutdownWithAction(action, originalIsError, originalError) {
if (shuttingDown === true) {
return;
}
shuttingDown = true;
if (dest._state === 'writable' &&
WritableStreamCloseQueuedOrInFlight(dest) === false) {
waitForWritesToFinish().then(doTheRest);
} else {
doTheRest();
}
function doTheRest() {
action().then(function () {
return finalize(originalIsError, originalError);
}, function (newError) {
return finalize(true, newError);
}).catch(rethrowAssertionErrorRejection);
}
}
function shutdown(isError, error) {
if (shuttingDown === true) {
return;
}
shuttingDown = true;
if (dest._state === 'writable' &&
WritableStreamCloseQueuedOrInFlight(dest) === false) {
waitForWritesToFinish().then(function () {
return finalize(isError, error);
}).catch(rethrowAssertionErrorRejection);
} else {
finalize(isError, error);
}
}
function finalize(isError, error) {
WritableStreamDefaultWriterRelease(writer);
ReadableStreamReaderGenericRelease(reader);
if (isError) {
reject(error);
} else {
resolve(undefined);
}
}
});
}
}, {
key: 'tee',
value: function tee() {
if (IsReadableStream(this) === false) {
throw streamBrandCheckException('tee');
}
var branches = ReadableStreamTee(this, false);
return createArrayFromList(branches);
}
}, {
key: 'locked',
get: function get() {
if (IsReadableStream(this) === false) {
throw streamBrandCheckException('locked');
}
return IsReadableStreamLocked(this);
}
}]);
return ReadableStream;
}();
module.exports = {
ReadableStream: ReadableStream,
IsReadableStreamDisturbed: IsReadableStreamDisturbed,
ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
ReadableStreamDefaultControllerGetDesiredSize:
ReadableStreamDefaultControllerGetDesiredSize
};
function AcquireReadableStreamBYOBReader(stream) {
return new ReadableStreamBYOBReader(stream);
}
function AcquireReadableStreamDefaultReader(stream) {
return new ReadableStreamDefaultReader(stream);
}
function IsReadableStream(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
return false;
}
return true;
}
function IsReadableStreamDisturbed(stream) {
assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should
only be used on known readable streams');
return stream._disturbed;
}
function IsReadableStreamLocked(stream) {
assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only
be used on known readable streams');
if (stream._reader === undefined) {
return false;
}
return true;
}
function ReadableStreamTee(stream, cloneForBranch2) {
assert(IsReadableStream(stream) === true);
assert(typeof cloneForBranch2 === 'boolean');
var reader = AcquireReadableStreamDefaultReader(stream);
var teeState = {
closedOrErrored: false,
canceled1: false,
canceled2: false,
reason1: undefined,
reason2: undefined
};
teeState.promise = new Promise(function (resolve) {
teeState._resolve = resolve;
});
var pull = create_ReadableStreamTeePullFunction();
pull._reader = reader;
pull._teeState = teeState;
pull._cloneForBranch2 = cloneForBranch2;
var cancel1 = create_ReadableStreamTeeBranch1CancelFunction();
cancel1._stream = stream;
cancel1._teeState = teeState;
var cancel2 = create_ReadableStreamTeeBranch2CancelFunction();
cancel2._stream = stream;
cancel2._teeState = teeState;
var underlyingSource1 = Object.create(Object.prototype);
createDataProperty(underlyingSource1, 'pull', pull);
createDataProperty(underlyingSource1, 'cancel', cancel1);
var branch1Stream = new ReadableStream(underlyingSource1);
var underlyingSource2 = Object.create(Object.prototype);
createDataProperty(underlyingSource2, 'pull', pull);
createDataProperty(underlyingSource2, 'cancel', cancel2);
var branch2Stream = new ReadableStream(underlyingSource2);
pull._branch1 = branch1Stream._readableStreamController;
pull._branch2 = branch2Stream._readableStreamController;
reader._closedPromise.catch(function (r) {
if (teeState.closedOrErrored === true) {
return;
}
ReadableStreamDefaultControllerError(pull._branch1, r);
ReadableStreamDefaultControllerError(pull._branch2, r);
teeState.closedOrErrored = true;
});
return [branch1Stream, branch2Stream];
}
function create_ReadableStreamTeePullFunction() {
function f() {
var reader = f._reader,
branch1 = f._branch1,
branch2 = f._branch2,
teeState = f._teeState;
return ReadableStreamDefaultReaderRead(reader).then(function (result) {
assert(typeIsObject(result));
var value = result.value;
var done = result.done;
assert(typeof done === 'boolean');
if (done === true && teeState.closedOrErrored === false) {
if (teeState.canceled1 === false) {
ReadableStreamDefaultControllerClose(branch1);
}
if (teeState.canceled2 === false) {
ReadableStreamDefaultControllerClose(branch2);
}
teeState.closedOrErrored = true;
}
if (teeState.closedOrErrored === true) {
return;
}
var value1 = value;
var value2 = value;
if (teeState.canceled1 === false) {
ReadableStreamDefaultControllerEnqueue(branch1, value1);
}
if (teeState.canceled2 === false) {
ReadableStreamDefaultControllerEnqueue(branch2, value2);
}
});
}
return f;
}
function create_ReadableStreamTeeBranch1CancelFunction() {
function f(reason) {
var stream = f._stream,
teeState = f._teeState;
teeState.canceled1 = true;
teeState.reason1 = reason;
if (teeState.canceled2 === true) {
var compositeReason = createArrayFromList([teeState.reason1,
teeState.reason2]);
var cancelResult = ReadableStreamCancel(stream, compositeReason);
teeState._resolve(cancelResult);
}
return teeState.promise;
}
return f;
}
function create_ReadableStreamTeeBranch2CancelFunction() {
function f(reason) {
var stream = f._stream,
teeState = f._teeState;
teeState.canceled2 = true;
teeState.reason2 = reason;
if (teeState.canceled1 === true) {
var compositeReason = createArrayFromList([teeState.reason1,
teeState.reason2]);
var cancelResult = ReadableStreamCancel(stream, compositeReason);
teeState._resolve(cancelResult);
}
return teeState.promise;
}
return f;
}
function ReadableStreamAddReadIntoRequest(stream) {
assert(IsReadableStreamBYOBReader(stream._reader) === true);
assert(stream._state === 'readable' || stream._state === 'closed');
var promise = new Promise(function (resolve, reject) {
var readIntoRequest = {
_resolve: resolve,
_reject: reject
};
stream._reader._readIntoRequests.push(readIntoRequest);
});
return promise;
}
function ReadableStreamAddReadRequest(stream) {
assert(IsReadableStreamDefaultReader(stream._reader) === true);
assert(stream._state === 'readable');
var promise = new Promise(function (resolve, reject) {
var readRequest = {
_resolve: resolve,
_reject: reject
};
stream._reader._readRequests.push(readRequest);
});
return promise;
}
function ReadableStreamCancel(stream, reason) {
stream._disturbed = true;
if (stream._state === 'closed') {
return Promise.resolve(undefined);
}
if (stream._state === 'errored') {
return Promise.reject(stream._storedError);
}
ReadableStreamClose(stream);
var sourceCancelPromise =
stream._readableStreamController.__cancelSteps(reason);
return sourceCancelPromise.then(function () {
return undefined;
});
}
function ReadableStreamClose(stream) {
assert(stream._state === 'readable');
stream._state = 'closed';
var reader = stream._reader;
if (reader === undefined) {
return undefined;
}
if (IsReadableStreamDefaultReader(reader) === true) {
for (var i = 0; i < reader._readRequests.length; i++) {
var _resolve = reader._readRequests[i]._resolve;
_resolve(CreateIterResultObject(undefined, true));
}
reader._readRequests = [];
}
defaultReaderClosedPromiseResolve(reader);
return undefined;
}
function ReadableStreamError(stream, e) {
assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
assert(stream._state === 'readable', 'state must be readable');
stream._state = 'errored';
stream._storedError = e;
var reader = stream._reader;
if (reader === undefined) {
return undefined;
}
if (IsReadableStreamDefaultReader(reader) === true) {
for (var i = 0; i < reader._readRequests.length; i++) {
var readRequest = reader._readRequests[i];
readRequest._reject(e);
}
reader._readRequests = [];
} else {
assert(IsReadableStreamBYOBReader(reader), 'reader must be
ReadableStreamBYOBReader');
for (var _i = 0; _i < reader._readIntoRequests.length; _i++) {
var readIntoRequest = reader._readIntoRequests[_i];
readIntoRequest._reject(e);
}
reader._readIntoRequests = [];
}
defaultReaderClosedPromiseReject(reader, e);
reader._closedPromise.catch(function () {});
}
function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
var reader = stream._reader;
assert(reader._readIntoRequests.length > 0);
var readIntoRequest = reader._readIntoRequests.shift();
readIntoRequest._resolve(CreateIterResultObject(chunk, done));
}
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
var reader = stream._reader;
assert(reader._readRequests.length > 0);
var readRequest = reader._readRequests.shift();
readRequest._resolve(CreateIterResultObject(chunk, done));
}
function ReadableStreamGetNumReadIntoRequests(stream) {
return stream._reader._readIntoRequests.length;
}
function ReadableStreamGetNumReadRequests(stream) {
return stream._reader._readRequests.length;
}
function ReadableStreamHasBYOBReader(stream) {
var reader = stream._reader;
if (reader === undefined) {
return false;
}
if (IsReadableStreamBYOBReader(reader) === false) {
return false;
}
return true;
}
function ReadableStreamHasDefaultReader(stream) {
var reader = stream._reader;
if (reader === undefined) {
return false;
}
if (IsReadableStreamDefaultReader(reader) === false) {
return false;
}
return true;
}
var ReadableStreamDefaultReader = function () {
function ReadableStreamDefaultReader(stream) {
_classCallCheck(this, ReadableStreamDefaultReader);
if (IsReadableStream(stream) === false) {
throw new TypeError('ReadableStreamDefaultReader can only be constructed
with a ReadableStream instance');
}
if (IsReadableStreamLocked(stream) === true) {
throw new TypeError('This stream has already been locked for exclusive
reading by another reader');
}
ReadableStreamReaderGenericInitialize(this, stream);
this._readRequests = [];
}
_createClass(ReadableStreamDefaultReader, [{
key: 'cancel',
value: function cancel(reason) {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise.reject(defaultReaderBrandCheckException('cancel'));
}
if (this._ownerReadableStream === undefined) {
return Promise.reject(readerLockException('cancel'));
}
return ReadableStreamReaderGenericCancel(this, reason);
}
}, {
key: 'read',
value: function read() {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise.reject(defaultReaderBrandCheckException('read'));
}
if (this._ownerReadableStream === undefined) {
return Promise.reject(readerLockException('read from'));
}
return ReadableStreamDefaultReaderRead(this);
}
}, {
key: 'releaseLock',
value: function releaseLock() {
if (IsReadableStreamDefaultReader(this) === false) {
throw defaultReaderBrandCheckException('releaseLock');
}
if (this._ownerReadableStream === undefined) {
return;
}
if (this._readRequests.length > 0) {
throw new TypeError('Tried to release a reader lock when that reader has
pending read() calls un-settled');
}
ReadableStreamReaderGenericRelease(this);
}
}, {
key: 'closed',
get: function get() {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise.reject(defaultReaderBrandCheckException('closed'));
}
return this._closedPromise;
}
}]);
return ReadableStreamDefaultReader;
}();
var ReadableStreamBYOBReader = function () {
function ReadableStreamBYOBReader(stream) {
_classCallCheck(this, ReadableStreamBYOBReader);
if (!IsReadableStream(stream)) {
throw new TypeError('ReadableStreamBYOBReader can only be constructed with
a ReadableStream instance given a ' + 'byte source');
}
if (IsReadableByteStreamController(stream._readableStreamController) ===
false) {
throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a
stream not constructed with a byte ' + 'source');
}
if (IsReadableStreamLocked(stream)) {
throw new TypeError('This stream has already been locked for exclusive
reading by another reader');
}
ReadableStreamReaderGenericInitialize(this, stream);
this._readIntoRequests = [];
}
_createClass(ReadableStreamBYOBReader, [{
key: 'cancel',
value: function cancel(reason) {
if (!IsReadableStreamBYOBReader(this)) {
return Promise.reject(byobReaderBrandCheckException('cancel'));
}
if (this._ownerReadableStream === undefined) {
return Promise.reject(readerLockException('cancel'));
}
return ReadableStreamReaderGenericCancel(this, reason);
}
}, {
key: 'read',
value: function read(view) {
if (!IsReadableStreamBYOBReader(this)) {
return Promise.reject(byobReaderBrandCheckException('read'));
}
if (this._ownerReadableStream === undefined) {
return Promise.reject(readerLockException('read from'));
}
if (!ArrayBuffer.isView(view)) {
return Promise.reject(new TypeError('view must be an array buffer
view'));
}
if (view.byteLength === 0) {
return Promise.reject(new TypeError('view must have non-zero
byteLength'));
}
return ReadableStreamBYOBReaderRead(this, view);
}
}, {
key: 'releaseLock',
value: function releaseLock() {
if (!IsReadableStreamBYOBReader(this)) {
throw byobReaderBrandCheckException('releaseLock');
}
if (this._ownerReadableStream === undefined) {
return;
}
if (this._readIntoRequests.length > 0) {
throw new TypeError('Tried to release a reader lock when that reader has
pending read() calls un-settled');
}
ReadableStreamReaderGenericRelease(this);
}
}, {
key: 'closed',
get: function get() {
if (!IsReadableStreamBYOBReader(this)) {
return Promise.reject(byobReaderBrandCheckException('closed'));
}
return this._closedPromise;
}
}]);
return ReadableStreamBYOBReader;
}();
function IsReadableStreamBYOBReader(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
return false;
}
return true;
}
function IsReadableStreamDefaultReader(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
return false;
}
return true;
}
function ReadableStreamReaderGenericInitialize(reader, stream) {
reader._ownerReadableStream = stream;
stream._reader = reader;
if (stream._state === 'readable') {
defaultReaderClosedPromiseInitialize(reader);
} else if (stream._state === 'closed') {
defaultReaderClosedPromiseInitializeAsResolved(reader);
} else {
assert(stream._state === 'errored', 'state must be errored');
defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
reader._closedPromise.catch(function () {});
}
}
function ReadableStreamReaderGenericCancel(reader, reason) {
var stream = reader._ownerReadableStream;
assert(stream !== undefined);
return ReadableStreamCancel(stream, reason);
}
function ReadableStreamReaderGenericRelease(reader) {
assert(reader._ownerReadableStream !== undefined);
assert(reader._ownerReadableStream._reader === reader);
if (reader._ownerReadableStream._state === 'readable') {
defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released
and can no longer be used to monitor the stream\'s closedness'));
} else {
defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was
released and can no longer be used to monitor the stream\'s closedness'));
}
reader._closedPromise.catch(function () {});
reader._ownerReadableStream._reader = undefined;
reader._ownerReadableStream = undefined;
}
function ReadableStreamBYOBReaderRead(reader, view) {
var stream = reader._ownerReadableStream;
assert(stream !== undefined);
stream._disturbed = true;
if (stream._state === 'errored') {
return Promise.reject(stream._storedError);
}
return ReadableByteStreamControllerPullInto(stream._readableStreamController,
view);
}
function ReadableStreamDefaultReaderRead(reader) {
var stream = reader._ownerReadableStream;
assert(stream !== undefined);
stream._disturbed = true;
if (stream._state === 'closed') {
return Promise.resolve(CreateIterResultObject(undefined, true));
}
if (stream._state === 'errored') {
return Promise.reject(stream._storedError);
}
assert(stream._state === 'readable');
return stream._readableStreamController.__pullSteps();
}
var ReadableStreamDefaultController = function () {
function ReadableStreamDefaultController(stream, underlyingSource, size,
highWaterMark) {
_classCallCheck(this, ReadableStreamDefaultController);
if (IsReadableStream(stream) === false) {
throw new TypeError('ReadableStreamDefaultController can only be
constructed with a ReadableStream instance');
}
if (stream._readableStreamController !== undefined) {
throw new TypeError('ReadableStreamDefaultController instances can only be
created by the ReadableStream constructor');
}
this._controlledReadableStream = stream;
this._underlyingSource = underlyingSource;
this._queue = undefined;
this._queueTotalSize = undefined;
ResetQueue(this);
this._started = false;
this._closeRequested = false;
this._pullAgain = false;
this._pulling = false;
var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size,
highWaterMark);
this._strategySize = normalizedStrategy.size;
this._strategyHWM = normalizedStrategy.highWaterMark;
var controller = this;
var startResult = InvokeOrNoop(underlyingSource, 'start', [this]);
Promise.resolve(startResult).then(function () {
controller._started = true;
assert(controller._pulling === false);
assert(controller._pullAgain === false);
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}, function (r) {
ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
}).catch(rethrowAssertionErrorRejection);
}
_createClass(ReadableStreamDefaultController, [{
key: 'close',
value: function close() {
if (IsReadableStreamDefaultController(this) === false) {
throw defaultControllerBrandCheckException('close');
}
if (this._closeRequested === true) {
throw new TypeError('The stream has already been closed; do not close it
again!');
}
var state = this._controlledReadableStream._state;
if (state !== 'readable') {
throw new TypeError('The stream (in ' + state + ' state) is not in the
readable state and cannot be closed');
}
ReadableStreamDefaultControllerClose(this);
}
}, {
key: 'enqueue',
value: function enqueue(chunk) {
if (IsReadableStreamDefaultController(this) === false) {
throw defaultControllerBrandCheckException('enqueue');
}
if (this._closeRequested === true) {
throw new TypeError('stream is closed or draining');
}
var state = this._controlledReadableStream._state;
if (state !== 'readable') {
throw new TypeError('The stream (in ' + state + ' state) is not in the
readable state and cannot be enqueued to');
}
return ReadableStreamDefaultControllerEnqueue(this, chunk);
}
}, {
key: 'error',
value: function error(e) {
if (IsReadableStreamDefaultController(this) === false) {
throw defaultControllerBrandCheckException('error');
}
var stream = this._controlledReadableStream;
if (stream._state !== 'readable') {
throw new TypeError('The stream is ' + stream._state + ' and so cannot be
errored');
}
ReadableStreamDefaultControllerError(this, e);
}
}, {
key: '__cancelSteps',
value: function __cancelSteps(reason) {
ResetQueue(this);
return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);
}
}, {
key: '__pullSteps',
value: function __pullSteps() {
var stream = this._controlledReadableStream;
if (this._queue.length > 0) {
var chunk = DequeueValue(this);
if (this._closeRequested === true && this._queue.length === 0) {
ReadableStreamClose(stream);
} else {
ReadableStreamDefaultControllerCallPullIfNeeded(this);
}
return Promise.resolve(CreateIterResultObject(chunk, false));
}
var pendingPromise = ReadableStreamAddReadRequest(stream);
ReadableStreamDefaultControllerCallPullIfNeeded(this);
return pendingPromise;
}
}, {
key: 'desiredSize',
get: function get() {
if (IsReadableStreamDefaultController(this) === false) {
throw defaultControllerBrandCheckException('desiredSize');
}
return ReadableStreamDefaultControllerGetDesiredSize(this);
}
}]);
return ReadableStreamDefaultController;
}();
function IsReadableStreamDefaultController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {
return false;
}
return true;
}
function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
if (shouldPull === false) {
return undefined;
}
if (controller._pulling === true) {
controller._pullAgain = true;
return undefined;
}
assert(controller._pullAgain === false);
controller._pulling = true;
var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull',
[controller]);
pullPromise.then(function () {
controller._pulling = false;
if (controller._pullAgain === true) {
controller._pullAgain = false;
return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}
return undefined;
}, function (e) {
ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
}).catch(rethrowAssertionErrorRejection);
return undefined;
}
function ReadableStreamDefaultControllerShouldCallPull(controller) {
var stream = controller._controlledReadableStream;
if (stream._state === 'closed' || stream._state === 'errored') {
return false;
}
if (controller._closeRequested === true) {
return false;
}
if (controller._started === false) {
return false;
}
if (IsReadableStreamLocked(stream) === true &&
ReadableStreamGetNumReadRequests(stream) > 0) {
return true;
}
var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
if (desiredSize > 0) {
return true;
}
return false;
}
function ReadableStreamDefaultControllerClose(controller) {
var stream = controller._controlledReadableStream;
assert(controller._closeRequested === false);
assert(stream._state === 'readable');
controller._closeRequested = true;
if (controller._queue.length === 0) {
ReadableStreamClose(stream);
}
}
function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
var stream = controller._controlledReadableStream;
assert(controller._closeRequested === false);
assert(stream._state === 'readable');
if (IsReadableStreamLocked(stream) === true &&
ReadableStreamGetNumReadRequests(stream) > 0) {
ReadableStreamFulfillReadRequest(stream, chunk, false);
} else {
var chunkSize = 1;
if (controller._strategySize !== undefined) {
var strategySize = controller._strategySize;
try {
chunkSize = strategySize(chunk);
} catch (chunkSizeE) {
ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
throw chunkSizeE;
}
}
try {
EnqueueValueWithSize(controller, chunk, chunkSize);
} catch (enqueueE) {
ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
throw enqueueE;
}
}
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
return undefined;
}
function ReadableStreamDefaultControllerError(controller, e) {
var stream = controller._controlledReadableStream;
assert(stream._state === 'readable');
ResetQueue(controller);
ReadableStreamError(stream, e);
}
function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
if (controller._controlledReadableStream._state === 'readable') {
ReadableStreamDefaultControllerError(controller, e);
}
}
function ReadableStreamDefaultControllerGetDesiredSize(controller) {
var stream = controller._controlledReadableStream;
var state = stream._state;
if (state === 'errored') {
return null;
}
if (state === 'closed') {
return 0;
}
return controller._strategyHWM - controller._queueTotalSize;
}
var ReadableStreamBYOBRequest = function () {
function ReadableStreamBYOBRequest(controller, view) {
_classCallCheck(this, ReadableStreamBYOBRequest);
this._associatedReadableByteStreamController = controller;
this._view = view;
}
_createClass(ReadableStreamBYOBRequest, [{
key: 'respond',
value: function respond(bytesWritten) {
if (IsReadableStreamBYOBRequest(this) === false) {
throw byobRequestBrandCheckException('respond');
}
if (this._associatedReadableByteStreamController === undefined) {
throw new TypeError('This BYOB request has been invalidated');
}

ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController,
bytesWritten);
}
}, {
key: 'respondWithNewView',
value: function respondWithNewView(view) {
if (IsReadableStreamBYOBRequest(this) === false) {
throw byobRequestBrandCheckException('respond');
}
if (this._associatedReadableByteStreamController === undefined) {
throw new TypeError('This BYOB request has been invalidated');
}
if (!ArrayBuffer.isView(view)) {
throw new TypeError('You can only respond with array buffer views');
}

ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamCo
ntroller, view);
}
}, {
key: 'view',
get: function get() {
return this._view;
}
}]);
return ReadableStreamBYOBRequest;
}();
var ReadableByteStreamController = function () {
function ReadableByteStreamController(stream, underlyingByteSource,
highWaterMark) {
_classCallCheck(this, ReadableByteStreamController);
if (IsReadableStream(stream) === false) {
throw new TypeError('ReadableByteStreamController can only be constructed
with a ReadableStream instance given ' + 'a byte source');
}
if (stream._readableStreamController !== undefined) {
throw new TypeError('ReadableByteStreamController instances can only be
created by the ReadableStream constructor given a byte ' + 'source');
}
this._controlledReadableStream = stream;
this._underlyingByteSource = underlyingByteSource;
this._pullAgain = false;
this._pulling = false;
ReadableByteStreamControllerClearPendingPullIntos(this);
this._queue = this._queueTotalSize = undefined;
ResetQueue(this);
this._closeRequested = false;
this._started = false;
this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
if (autoAllocateChunkSize !== undefined) {
if (Number.isInteger(autoAllocateChunkSize) === false ||
autoAllocateChunkSize <= 0) {
throw new RangeError('autoAllocateChunkSize must be a positive integer');
}
}
this._autoAllocateChunkSize = autoAllocateChunkSize;
this._pendingPullIntos = [];
var controller = this;
var startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);
Promise.resolve(startResult).then(function () {
controller._started = true;
assert(controller._pulling === false);
assert(controller._pullAgain === false);
ReadableByteStreamControllerCallPullIfNeeded(controller);
}, function (r) {
if (stream._state === 'readable') {
ReadableByteStreamControllerError(controller, r);
}
}).catch(rethrowAssertionErrorRejection);
}
_createClass(ReadableByteStreamController, [{
key: 'close',
value: function close() {
if (IsReadableByteStreamController(this) === false) {
throw byteStreamControllerBrandCheckException('close');
}
if (this._closeRequested === true) {
throw new TypeError('The stream has already been closed; do not close it
again!');
}
var state = this._controlledReadableStream._state;
if (state !== 'readable') {
throw new TypeError('The stream (in ' + state + ' state) is not in the
readable state and cannot be closed');
}
ReadableByteStreamControllerClose(this);
}
}, {
key: 'enqueue',
value: function enqueue(chunk) {
if (IsReadableByteStreamController(this) === false) {
throw byteStreamControllerBrandCheckException('enqueue');
}
if (this._closeRequested === true) {
throw new TypeError('stream is closed or draining');
}
var state = this._controlledReadableStream._state;
if (state !== 'readable') {
throw new TypeError('The stream (in ' + state + ' state) is not in the
readable state and cannot be enqueued to');
}
if (!ArrayBuffer.isView(chunk)) {
throw new TypeError('You can only enqueue array buffer views when using a
ReadableByteStreamController');
}
ReadableByteStreamControllerEnqueue(this, chunk);
}
}, {
key: 'error',
value: function error(e) {
if (IsReadableByteStreamController(this) === false) {
throw byteStreamControllerBrandCheckException('error');
}
var stream = this._controlledReadableStream;
if (stream._state !== 'readable') {
throw new TypeError('The stream is ' + stream._state + ' and so cannot be
errored');
}
ReadableByteStreamControllerError(this, e);
}
}, {
key: '__cancelSteps',
value: function __cancelSteps(reason) {
if (this._pendingPullIntos.length > 0) {
var firstDescriptor = this._pendingPullIntos[0];
firstDescriptor.bytesFilled = 0;
}
ResetQueue(this);
return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);
}
}, {
key: '__pullSteps',
value: function __pullSteps() {
var stream = this._controlledReadableStream;
assert(ReadableStreamHasDefaultReader(stream) === true);
if (this._queueTotalSize > 0) {
assert(ReadableStreamGetNumReadRequests(stream) === 0);
var entry = this._queue.shift();
this._queueTotalSize -= entry.byteLength;
ReadableByteStreamControllerHandleQueueDrain(this);
var view = void 0;
try {
view = new Uint8Array(entry.buffer, entry.byteOffset,
entry.byteLength);
} catch (viewE) {
return Promise.reject(viewE);
}
return Promise.resolve(CreateIterResultObject(view, false));
}
var autoAllocateChunkSize = this._autoAllocateChunkSize;
if (autoAllocateChunkSize !== undefined) {
var buffer = void 0;
try {
buffer = new ArrayBuffer(autoAllocateChunkSize);
} catch (bufferE) {
return Promise.reject(bufferE);
}
var pullIntoDescriptor = {
buffer: buffer,
byteOffset: 0,
byteLength: autoAllocateChunkSize,
bytesFilled: 0,
elementSize: 1,
ctor: Uint8Array,
readerType: 'default'
};
this._pendingPullIntos.push(pullIntoDescriptor);
}
var promise = ReadableStreamAddReadRequest(stream);
ReadableByteStreamControllerCallPullIfNeeded(this);
return promise;
}
}, {
key: 'byobRequest',
get: function get() {
if (IsReadableByteStreamController(this) === false) {
throw byteStreamControllerBrandCheckException('byobRequest');
}
if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
var firstDescriptor = this._pendingPullIntos[0];
var view = new Uint8Array(firstDescriptor.buffer,
firstDescriptor.byteOffset + firstDescriptor.bytesFilled,
firstDescriptor.byteLength - firstDescriptor.bytesFilled);
this._byobRequest = new ReadableStreamBYOBRequest(this, view);
}
return this._byobRequest;
}
}, {
key: 'desiredSize',
get: function get() {
if (IsReadableByteStreamController(this) === false) {
throw byteStreamControllerBrandCheckException('desiredSize');
}
return ReadableByteStreamControllerGetDesiredSize(this);
}
}]);
return ReadableByteStreamController;
}();
function IsReadableByteStreamController(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {
return false;
}
return true;
}
function IsReadableStreamBYOBRequest(x) {
if (!typeIsObject(x)) {
return false;
}
if (!Object.prototype.hasOwnProperty.call(x,
'_associatedReadableByteStreamController')) {
return false;
}
return true;
}
function ReadableByteStreamControllerCallPullIfNeeded(controller) {
var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
if (shouldPull === false) {
return undefined;
}
if (controller._pulling === true) {
controller._pullAgain = true;
return undefined;
}
assert(controller._pullAgain === false);
controller._pulling = true;
var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull',
[controller]);
pullPromise.then(function () {
controller._pulling = false;
if (controller._pullAgain === true) {
controller._pullAgain = false;
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
}, function (e) {
if (controller._controlledReadableStream._state === 'readable') {
ReadableByteStreamControllerError(controller, e);
}
}).catch(rethrowAssertionErrorRejection);
return undefined;
}
function ReadableByteStreamControllerClearPendingPullIntos(controller) {
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
controller._pendingPullIntos = [];
}
function ReadableByteStreamControllerCommitPullIntoDescriptor(stream,
pullIntoDescriptor) {
assert(stream._state !== 'errored', 'state must not be errored');
var done = false;
if (stream._state === 'closed') {
assert(pullIntoDescriptor.bytesFilled === 0);
done = true;
}
var filledView =
ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
if (pullIntoDescriptor.readerType === 'default') {
ReadableStreamFulfillReadRequest(stream, filledView, done);
} else {
assert(pullIntoDescriptor.readerType === 'byob');
ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
}
}
function
ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
var bytesFilled = pullIntoDescriptor.bytesFilled;
var elementSize = pullIntoDescriptor.elementSize;
assert(bytesFilled <= pullIntoDescriptor.byteLength);
assert(bytesFilled % elementSize === 0);
return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer,
pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
}
function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer,
byteOffset, byteLength) {
controller._queue.push({
buffer: buffer,
byteOffset: byteOffset,
byteLength: byteLength
});
controller._queueTotalSize += byteLength;
}
function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
pullIntoDescriptor) {
var elementSize = pullIntoDescriptor.elementSize;
var currentAlignedBytes = pullIntoDescriptor.bytesFilled -
pullIntoDescriptor.bytesFilled % elementSize;
var maxBytesToCopy = Math.min(controller._queueTotalSize,
pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
var totalBytesToCopyRemaining = maxBytesToCopy;
var ready = false;
if (maxAlignedBytes > currentAlignedBytes) {
totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
ready = true;
}
var queue = controller._queue;
while (totalBytesToCopyRemaining > 0) {
var headOfQueue = queue[0];
var bytesToCopy = Math.min(totalBytesToCopyRemaining,
headOfQueue.byteLength);
var destStart = pullIntoDescriptor.byteOffset +
pullIntoDescriptor.bytesFilled;
ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer,
headOfQueue.byteOffset, bytesToCopy);
if (headOfQueue.byteLength === bytesToCopy) {
queue.shift();
} else {
headOfQueue.byteOffset += bytesToCopy;
headOfQueue.byteLength -= bytesToCopy;
}
controller._queueTotalSize -= bytesToCopy;
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller,
bytesToCopy, pullIntoDescriptor);
totalBytesToCopyRemaining -= bytesToCopy;
}
if (ready === false) {
assert(controller._queueTotalSize === 0, 'queue must be empty');
assert(pullIntoDescriptor.bytesFilled > 0);
assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
}
return ready;
}
function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size,
pullIntoDescriptor) {
assert(controller._pendingPullIntos.length === 0 ||
controller._pendingPullIntos[0] === pullIntoDescriptor);
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
pullIntoDescriptor.bytesFilled += size;
}
function ReadableByteStreamControllerHandleQueueDrain(controller) {
assert(controller._controlledReadableStream._state === 'readable');
if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
ReadableStreamClose(controller._controlledReadableStream);
} else {
ReadableByteStreamControllerCallPullIfNeeded(controller);
}
}
function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
if (controller._byobRequest === undefined) {
return;
}
controller._byobRequest._associatedReadableByteStreamController = undefined;
controller._byobRequest._view = undefined;
controller._byobRequest = undefined;
}
function
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
assert(controller._closeRequested === false);
while (controller._pendingPullIntos.length > 0) {
if (controller._queueTotalSize === 0) {
return;
}
var pullIntoDescriptor = controller._pendingPullIntos[0];
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
pullIntoDescriptor) === true) {
ReadableByteStreamControllerShiftPendingPullInto(controller);

ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadable
Stream, pullIntoDescriptor);
}
}
}
function ReadableByteStreamControllerPullInto(controller, view) {
var stream = controller._controlledReadableStream;
var elementSize = 1;
if (view.constructor !== DataView) {
elementSize = view.constructor.BYTES_PER_ELEMENT;
}
var ctor = view.constructor;
var pullIntoDescriptor = {
buffer: view.buffer,
byteOffset: view.byteOffset,
byteLength: view.byteLength,
bytesFilled: 0,
elementSize: elementSize,
ctor: ctor,
readerType: 'byob'
};
if (controller._pendingPullIntos.length > 0) {
pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
controller._pendingPullIntos.push(pullIntoDescriptor);
return ReadableStreamAddReadIntoRequest(stream);
}
if (stream._state === 'closed') {
var emptyView = new view.constructor(pullIntoDescriptor.buffer,
pullIntoDescriptor.byteOffset, 0);
return Promise.resolve(CreateIterResultObject(emptyView, true));
}
if (controller._queueTotalSize > 0) {
if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller,
pullIntoDescriptor) === true) {
var filledView =
ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
ReadableByteStreamControllerHandleQueueDrain(controller);
return Promise.resolve(CreateIterResultObject(filledView, false));
}
if (controller._closeRequested === true) {
var e = new TypeError('Insufficient bytes to fill elements in the given
buffer');
ReadableByteStreamControllerError(controller, e);
return Promise.reject(e);
}
}
pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
controller._pendingPullIntos.push(pullIntoDescriptor);
var promise = ReadableStreamAddReadIntoRequest(stream);
ReadableByteStreamControllerCallPullIfNeeded(controller);
return promise;
}
function ReadableByteStreamControllerRespondInClosedState(controller,
firstDescriptor) {
firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');
var stream = controller._controlledReadableStream;
if (ReadableStreamHasBYOBReader(stream) === true) {
while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
var pullIntoDescriptor =
ReadableByteStreamControllerShiftPendingPullInto(controller);
ReadableByteStreamControllerCommitPullIntoDescriptor(stream,
pullIntoDescriptor);
}
}
}
function ReadableByteStreamControllerRespondInReadableState(controller,
bytesWritten, pullIntoDescriptor) {
if (pullIntoDescriptor.bytesFilled + bytesWritten >
pullIntoDescriptor.byteLength) {
throw new RangeError('bytesWritten out of range');
}
ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller,
bytesWritten, pullIntoDescriptor);
if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
return;
}
ReadableByteStreamControllerShiftPendingPullInto(controller);
var remainderSize = pullIntoDescriptor.bytesFilled %
pullIntoDescriptor.elementSize;
if (remainderSize > 0) {
var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0,
remainder.byteLength);
}
pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
pullIntoDescriptor.bytesFilled -= remainderSize;

ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadable
Stream, pullIntoDescriptor);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
}
function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
var firstDescriptor = controller._pendingPullIntos[0];
var stream = controller._controlledReadableStream;
if (stream._state === 'closed') {
if (bytesWritten !== 0) {
throw new TypeError('bytesWritten must be 0 when calling respond() on a
closed stream');
}
ReadableByteStreamControllerRespondInClosedState(controller,
firstDescriptor);
} else {
assert(stream._state === 'readable');
ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten,
firstDescriptor);
}
}
function ReadableByteStreamControllerShiftPendingPullInto(controller) {
var descriptor = controller._pendingPullIntos.shift();
ReadableByteStreamControllerInvalidateBYOBRequest(controller);
return descriptor;
}
function ReadableByteStreamControllerShouldCallPull(controller) {
var stream = controller._controlledReadableStream;
if (stream._state !== 'readable') {
return false;
}
if (controller._closeRequested === true) {
return false;
}
if (controller._started === false) {
return false;
}
if (ReadableStreamHasDefaultReader(stream) === true &&
ReadableStreamGetNumReadRequests(stream) > 0) {
return true;
}
if (ReadableStreamHasBYOBReader(stream) === true &&
ReadableStreamGetNumReadIntoRequests(stream) > 0) {
return true;
}
if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
return true;
}
return false;
}
function ReadableByteStreamControllerClose(controller) {
var stream = controller._controlledReadableStream;
assert(controller._closeRequested === false);
assert(stream._state === 'readable');
if (controller._queueTotalSize > 0) {
controller._closeRequested = true;
return;
}
if (controller._pendingPullIntos.length > 0) {
var firstPendingPullInto = controller._pendingPullIntos[0];
if (firstPendingPullInto.bytesFilled > 0) {
var e = new TypeError('Insufficient bytes to fill elements in the given
buffer');
ReadableByteStreamControllerError(controller, e);
throw e;
}
}
ReadableStreamClose(stream);
}
function ReadableByteStreamControllerEnqueue(controller, chunk) {
var stream = controller._controlledReadableStream;
assert(controller._closeRequested === false);
assert(stream._state === 'readable');
var buffer = chunk.buffer;
var byteOffset = chunk.byteOffset;
var byteLength = chunk.byteLength;
var transferredBuffer = TransferArrayBuffer(buffer);
if (ReadableStreamHasDefaultReader(stream) === true) {
if (ReadableStreamGetNumReadRequests(stream) === 0) {
ReadableByteStreamControllerEnqueueChunkToQueue(controller,
transferredBuffer, byteOffset, byteLength);
} else {
assert(controller._queue.length === 0);
var transferredView = new Uint8Array(transferredBuffer, byteOffset,
byteLength);
ReadableStreamFulfillReadRequest(stream, transferredView, false);
}
} else if (ReadableStreamHasBYOBReader(stream) === true) {
ReadableByteStreamControllerEnqueueChunkToQueue(controller,
transferredBuffer, byteOffset, byteLength);
ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
} else {
assert(IsReadableStreamLocked(stream) === false, 'stream must not be
locked');
ReadableByteStreamControllerEnqueueChunkToQueue(controller,
transferredBuffer, byteOffset, byteLength);
}
}
function ReadableByteStreamControllerError(controller, e) {
var stream = controller._controlledReadableStream;
assert(stream._state === 'readable');
ReadableByteStreamControllerClearPendingPullIntos(controller);
ResetQueue(controller);
ReadableStreamError(stream, e);
}
function ReadableByteStreamControllerGetDesiredSize(controller) {
var stream = controller._controlledReadableStream;
var state = stream._state;
if (state === 'errored') {
return null;
}
if (state === 'closed') {
return 0;
}
return controller._strategyHWM - controller._queueTotalSize;
}
function ReadableByteStreamControllerRespond(controller, bytesWritten) {
bytesWritten = Number(bytesWritten);
if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
throw new RangeError('bytesWritten must be a finite');
}
assert(controller._pendingPullIntos.length > 0);
ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
}
function ReadableByteStreamControllerRespondWithNewView(controller, view) {
assert(controller._pendingPullIntos.length > 0);
var firstDescriptor = controller._pendingPullIntos[0];
if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !==
view.byteOffset) {
throw new RangeError('The region specified by view does not match
byobRequest');
}
if (firstDescriptor.byteLength !== view.byteLength) {
throw new RangeError('The buffer of view has different capacity than
byobRequest');
}
firstDescriptor.buffer = view.buffer;
ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
}
function streamBrandCheckException(name) {
return new TypeError('ReadableStream.prototype.' + name + ' can only be used on
a ReadableStream');
}
function readerLockException(name) {
return new TypeError('Cannot ' + name + ' a stream using a released reader');
}
function defaultReaderBrandCheckException(name) {
return new TypeError('ReadableStreamDefaultReader.prototype.' + name + ' can
only be used on a ReadableStreamDefaultReader');
}
function defaultReaderClosedPromiseInitialize(reader) {
reader._closedPromise = new Promise(function (resolve, reject) {
reader._closedPromise_resolve = resolve;
reader._closedPromise_reject = reject;
});
}
function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
reader._closedPromise = Promise.reject(reason);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
function defaultReaderClosedPromiseInitializeAsResolved(reader) {
reader._closedPromise = Promise.resolve(undefined);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
function defaultReaderClosedPromiseReject(reader, reason) {
assert(reader._closedPromise_resolve !== undefined);
assert(reader._closedPromise_reject !== undefined);
reader._closedPromise_reject(reason);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
function defaultReaderClosedPromiseResetToRejected(reader, reason) {
assert(reader._closedPromise_resolve === undefined);
assert(reader._closedPromise_reject === undefined);
reader._closedPromise = Promise.reject(reason);
}
function defaultReaderClosedPromiseResolve(reader) {
assert(reader._closedPromise_resolve !== undefined);
assert(reader._closedPromise_reject !== undefined);
reader._closedPromise_resolve(undefined);
reader._closedPromise_resolve = undefined;
reader._closedPromise_reject = undefined;
}
function byobReaderBrandCheckException(name) {
return new TypeError('ReadableStreamBYOBReader.prototype.' + name + ' can only
be used on a ReadableStreamBYOBReader');
}
function defaultControllerBrandCheckException(name) {
return new TypeError('ReadableStreamDefaultController.prototype.' + name + '
can only be used on a ReadableStreamDefaultController');
}
function byobRequestBrandCheckException(name) {
return new TypeError('ReadableStreamBYOBRequest.prototype.' + name + ' can only
be used on a ReadableStreamBYOBRequest');
}
function byteStreamControllerBrandCheckException(name) {
return new TypeError('ReadableByteStreamController.prototype.' + name + ' can
only be used on a ReadableByteStreamController');
}
function
ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise) {
try {
Promise.prototype.then.call(promise, undefined, function () {});
} catch (e) {}
}
}, function (module, exports, __w_pdfjs_require__) {
"use strict";

var transformStream = __w_pdfjs_require__(6);

var readableStream = __w_pdfjs_require__(4);
var writableStream = __w_pdfjs_require__(2);
exports.TransformStream = transformStream.TransformStream;
exports.ReadableStream = readableStream.ReadableStream;
exports.IsReadableStreamDisturbed = readableStream.IsReadableStreamDisturbed;
exports.ReadableStreamDefaultControllerClose =
readableStream.ReadableStreamDefaultControllerClose;
exports.ReadableStreamDefaultControllerEnqueue =
readableStream.ReadableStreamDefaultControllerEnqueue;
exports.ReadableStreamDefaultControllerError =
readableStream.ReadableStreamDefaultControllerError;
exports.ReadableStreamDefaultControllerGetDesiredSize =
readableStream.ReadableStreamDefaultControllerGetDesiredSize;
exports.AcquireWritableStreamDefaultWriter =
writableStream.AcquireWritableStreamDefaultWriter;
exports.IsWritableStream = writableStream.IsWritableStream;
exports.IsWritableStreamLocked = writableStream.IsWritableStreamLocked;
exports.WritableStream = writableStream.WritableStream;
exports.WritableStreamAbort = writableStream.WritableStreamAbort;
exports.WritableStreamDefaultControllerError =
writableStream.WritableStreamDefaultControllerError;
exports.WritableStreamDefaultWriterCloseWithErrorPropagation =
writableStream.WritableStreamDefaultWriterCloseWithErrorPropagation;
exports.WritableStreamDefaultWriterRelease =
writableStream.WritableStreamDefaultWriterRelease;
exports.WritableStreamDefaultWriterWrite =
writableStream.WritableStreamDefaultWriterWrite;
}, function (module, exports, __w_pdfjs_require__) {
"use strict";

var _createClass = function () {

/***/ }),
/* 11 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.CanvasGraphics = undefined;

var _util = __w_pdfjs_require__(0);

var _pattern_helper = __w_pdfjs_require__(13);

var _webgl = __w_pdfjs_require__(7);

var MIN_FONT_SIZE = 16;

var width = this.ctx.canvas.width;

executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList,

executionStartIdx, continueCallback, stepper) {
var argsArray = operatorList.argsArray;
var fnArray = operatorList.fnArray;
var i = executionStartIdx || 0;
var argsArrayLen = argsArray.length;
if (argsArrayLen === i) {
return i;
}
var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof
continueCallback === 'function';
var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
var steps = 0;
var commonObjs = this.commonObjs;
var objs = this.objs;
var fnId;
while (true) {
if (stepper !== undefined && i === stepper.nextBreakPoint) {
stepper.breakIt(i, continueCallback);
return i;
}
fnId = fnArray[i];
if (fnId !== _util.OPS.dependency) {
this[fnId].apply(this, argsArray[i]);
} else {
var deps = argsArray[i];
for (var n = 0, nn = deps.length; n < nn; n++) {
var depObjId = deps[n];
var common = depObjId[0] === 'g' && depObjId[1] === '_';
var objsPool = common ? commonObjs : objs;
if (!objsPool.isResolved(depObjId)) {
objsPool.get(depObjId, continueCallback);
return i;
}
}
}
i++;
if (i === argsArrayLen) {
return i;
}
if (chunkOperations && ++steps > EXECUTION_STEPS) {
if (Date.now() > endTime) {
continueCallback();
return i;
}
steps = 0;
}
}
},
endDrawing: function CanvasGraphics_endDrawing() {
if (this.current.activeSMask !== null) {
this.endSMaskGroup();
}
this.ctx.restore();
if (this.transparentCanvas) {
this.ctx = this.compositeCtx;
this.ctx.save();
this.ctx.setTransform(1, 0, 0, 1, 0, 0);
this.ctx.drawImage(this.transparentCanvas, 0, 0);
this.ctx.restore();
this.transparentCanvas = null;
}
this.cachedCanvases.clear();
_webgl.WebGLUtils.clear();
if (this.imageLayer) {
this.imageLayer.endLayout();
}
},
setLineWidth: function CanvasGraphics_setLineWidth(width) {
this.current.lineWidth = width;
this.ctx.lineWidth = width;
},
setLineCap: function CanvasGraphics_setLineCap(style) {
this.ctx.lineCap = LINE_CAP_STYLES[style];
},
setLineJoin: function CanvasGraphics_setLineJoin(style) {
this.ctx.lineJoin = LINE_JOIN_STYLES[style];
},
setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
this.ctx.miterLimit = limit;
},
setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
var ctx = this.ctx;
if (ctx.setLineDash !== undefined) {
ctx.setLineDash(dashArray);
ctx.lineDashOffset = dashPhase;
}
},
setRenderingIntent: function CanvasGraphics_setRenderingIntent(intent) {},
setFlatness: function CanvasGraphics_setFlatness(flatness) {},
setGState: function CanvasGraphics_setGState(states) {
for (var i = 0, ii = states.length; i < ii; i++) {
var state = states[i];
var key = state[0];
var value = state[1];
switch (key) {
case 'LW':
this.setLineWidth(value);
break;
case 'LC':
this.setLineCap(value);
break;
case 'LJ':
this.setLineJoin(value);
break;
case 'ML':
this.setMiterLimit(value);
break;
case 'D':
this.setDash(value[0], value[1]);
break;
case 'RI':
this.setRenderingIntent(value);
break;
case 'FL':
this.setFlatness(value);
break;
case 'Font':
this.setFont(value[0], value[1]);
break;
case 'CA':
this.current.strokeAlpha = state[1];
break;
case 'ca':
this.current.fillAlpha = state[1];
this.ctx.globalAlpha = state[1];
break;
case 'BM':
this.ctx.globalCompositeOperation = value;
break;
case 'SMask':
if (this.current.activeSMask) {
if (this.stateStack.length > 0 &&
this.stateStack[this.stateStack.length - 1].activeSMask ===
this.current.activeSMask) {
this.suspendSMaskGroup();
} else {
this.endSMaskGroup();
}
}
this.current.activeSMask = value ? this.tempSMask : null;
if (this.current.activeSMask) {
this.beginSMaskGroup();
}
this.tempSMask = null;
break;
}
}
},
beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
var activeSMask = this.current.activeSMask;
var drawnWidth = activeSMask.canvas.width;
var drawnHeight = activeSMask.canvas.height;
var cacheId = 'smaskGroupAt' + this.groupLevel;
var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth,
drawnHeight, true);
var currentCtx = this.ctx;
var currentTransform = currentCtx.mozCurrentTransform;
this.ctx.save();
var groupCtx = scratchCanvas.context;
groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);
groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);
groupCtx.transform.apply(groupCtx, currentTransform);
activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;
copyCtxState(currentCtx, groupCtx);
this.ctx = groupCtx;
this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
this.groupStack.push(currentCtx);
this.groupLevel++;
},
suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {
var groupCtx = this.ctx;
this.groupLevel--;
this.ctx = this.groupStack.pop();
composeSMask(this.ctx, this.current.activeSMask, groupCtx);
this.ctx.restore();
this.ctx.save();
copyCtxState(groupCtx, this.ctx);
this.current.resumeSMaskCtx = groupCtx;
var deltaTransform =
_util.Util.transform(this.current.activeSMask.startTransformInverse,
groupCtx.mozCurrentTransform);
this.ctx.transform.apply(this.ctx, deltaTransform);
groupCtx.save();
groupCtx.setTransform(1, 0, 0, 1, 0, 0);
groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
groupCtx.restore();
},
resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {
var groupCtx = this.current.resumeSMaskCtx;
var currentCtx = this.ctx;
this.ctx = groupCtx;
this.groupStack.push(currentCtx);
this.groupLevel++;
},
endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
var groupCtx = this.ctx;
this.groupLevel--;
this.ctx = this.groupStack.pop();
composeSMask(this.ctx, this.current.activeSMask, groupCtx);
this.ctx.restore();
copyCtxState(groupCtx, this.ctx);
var deltaTransform =
_util.Util.transform(this.current.activeSMask.startTransformInverse,
groupCtx.mozCurrentTransform);
this.ctx.transform.apply(this.ctx, deltaTransform);
},
save: function CanvasGraphics_save() {
this.ctx.save();
var old = this.current;
this.stateStack.push(old);
this.current = old.clone();
this.current.resumeSMaskCtx = null;
},
restore: function CanvasGraphics_restore() {
if (this.current.resumeSMaskCtx) {
this.resumeSMaskGroup();
}
if (this.current.activeSMask !== null && (this.stateStack.length === 0 ||
this.stateStack[this.stateStack.length - 1].activeSMask !==
this.current.activeSMask)) {
this.endSMaskGroup();
}
if (this.stateStack.length !== 0) {
this.current = this.stateStack.pop();
this.ctx.restore();
this.pendingClip = null;
this.cachedGetSinglePixelWidth = null;
}
},
transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
this.ctx.transform(a, b, c, d, e, f);
this.cachedGetSinglePixelWidth = null;
},
constructPath: function CanvasGraphics_constructPath(ops, args) {
var ctx = this.ctx;
var current = this.current;
var x = current.x,
y = current.y;
for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
switch (ops[i] | 0) {
case _util.OPS.rectangle:
x = args[j++];
y = args[j++];
var width = args[j++];
var height = args[j++];
if (width === 0) {
width = this.getSinglePixelWidth();
}
if (height === 0) {
height = this.getSinglePixelWidth();
}
var xw = x + width;
var yh = y + height;
this.ctx.moveTo(x, y);
this.ctx.lineTo(xw, y);
this.ctx.lineTo(xw, yh);
this.ctx.lineTo(x, yh);
this.ctx.lineTo(x, y);
this.ctx.closePath();
break;
case _util.OPS.moveTo:
x = args[j++];
y = args[j++];
ctx.moveTo(x, y);
break;
case _util.OPS.lineTo:
x = args[j++];
y = args[j++];
ctx.lineTo(x, y);
break;
case _util.OPS.curveTo:
x = args[j + 4];
y = args[j + 5];
ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x,
y);
j += 6;
break;
case _util.OPS.curveTo2:
ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j +
3]);
x = args[j + 2];
y = args[j + 3];
j += 4;
break;
case _util.OPS.curveTo3:
x = args[j + 2];
y = args[j + 3];
ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
j += 4;
break;
case _util.OPS.closePath:
ctx.closePath();
break;
}
}
current.setCurrentPoint(x, y);
},
closePath: function CanvasGraphics_closePath() {
this.ctx.closePath();
},
stroke: function CanvasGraphics_stroke(consumePath) {
consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
var ctx = this.ctx;
var strokeColor = this.current.strokeColor;
ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR,
this.current.lineWidth);
ctx.globalAlpha = this.current.strokeAlpha;
if (strokeColor && strokeColor.hasOwnProperty('type') && strokeColor.type ===
'Pattern') {
ctx.save();
ctx.strokeStyle = strokeColor.getPattern(ctx, this);
ctx.stroke();
ctx.restore();
} else {
ctx.stroke();
}
if (consumePath) {
this.consumePath();
}
ctx.globalAlpha = this.current.fillAlpha;
},
closeStroke: function CanvasGraphics_closeStroke() {
this.closePath();
this.stroke();
},
fill: function CanvasGraphics_fill(consumePath) {
consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
var ctx = this.ctx;
var fillColor = this.current.fillColor;
var isPatternFill = this.current.patternFill;
var needRestore = false;
if (isPatternFill) {
ctx.save();
if (this.baseTransform) {
ctx.setTransform.apply(ctx, this.baseTransform);
}
ctx.fillStyle = fillColor.getPattern(ctx, this);
needRestore = true;
}
if (this.pendingEOFill) {
ctx.fill('evenodd');
this.pendingEOFill = false;
} else {
ctx.fill();
}
if (needRestore) {
ctx.restore();
}
if (consumePath) {
this.consumePath();
}
},
eoFill: function CanvasGraphics_eoFill() {
this.pendingEOFill = true;
this.fill();
},
fillStroke: function CanvasGraphics_fillStroke() {
this.fill(false);
this.stroke(false);
this.consumePath();
},
eoFillStroke: function CanvasGraphics_eoFillStroke() {
this.pendingEOFill = true;
this.fillStroke();
},
closeFillStroke: function CanvasGraphics_closeFillStroke() {
this.closePath();
this.fillStroke();
},
closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {
this.pendingEOFill = true;
this.closePath();
this.fillStroke();
},
endPath: function CanvasGraphics_endPath() {
this.consumePath();
},
clip: function CanvasGraphics_clip() {
this.pendingClip = NORMAL_CLIP;
},
eoClip: function CanvasGraphics_eoClip() {
this.pendingClip = EO_CLIP;
},
beginText: function CanvasGraphics_beginText() {
this.current.textMatrix = _util.IDENTITY_MATRIX;
this.current.textMatrixScale = 1;
this.current.x = this.current.lineX = 0;
this.current.y = this.current.lineY = 0;
},
endText: function CanvasGraphics_endText() {
var paths = this.pendingTextPaths;
var ctx = this.ctx;
if (paths === undefined) {
ctx.beginPath();
return;
}
ctx.save();
ctx.beginPath();
for (var i = 0; i < paths.length; i++) {
var path = paths[i];
ctx.setTransform.apply(ctx, path.transform);
ctx.translate(path.x, path.y);
path.addToPath(ctx, path.fontSize);
}
ctx.restore();
ctx.clip();
ctx.beginPath();
delete this.pendingTextPaths;
},
setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
this.current.charSpacing = spacing;
},
setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {
this.current.wordSpacing = spacing;
},
setHScale: function CanvasGraphics_setHScale(scale) {
this.current.textHScale = scale / 100;
},
setLeading: function CanvasGraphics_setLeading(leading) {
this.current.leading = -leading;
},
setFont: function CanvasGraphics_setFont(fontRefName, size) {
var fontObj = this.commonObjs.get(fontRefName);
var current = this.current;
if (!fontObj) {
throw new Error('Can\'t find font for ' + fontRefName);
}
current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix :
_util.FONT_IDENTITY_MATRIX;
if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
(0, _util.warn)('Invalid font matrix for font ' + fontRefName);
}
if (size < 0) {
size = -size;
current.fontDirection = -1;
} else {
current.fontDirection = 1;
}
this.current.font = fontObj;
this.current.fontSize = size;
if (fontObj.isType3Font) {
return;
}
var name = fontObj.loadedName || 'sans-serif';
var bold = fontObj.black ? '900' : fontObj.bold ? 'bold' : 'normal';
var italic = fontObj.italic ? 'italic' : 'normal';
var typeface = '"' + name + '", ' + fontObj.fallbackName;
var browserFontSize = size < MIN_FONT_SIZE ? MIN_FONT_SIZE : size >
MAX_FONT_SIZE ? MAX_FONT_SIZE : size;
this.current.fontSizeScale = size / browserFontSize;
var rule = italic + ' ' + bold + ' ' + browserFontSize + 'px ' + typeface;
this.ctx.font = rule;
},
setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
this.current.textRenderingMode = mode;
},
setTextRise: function CanvasGraphics_setTextRise(rise) {
this.current.textRise = rise;
},
moveText: function CanvasGraphics_moveText(x, y) {
this.current.x = this.current.lineX += x;
this.current.y = this.current.lineY += y;
},
setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {
this.setLeading(-y);
this.moveText(x, y);
},
setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {
this.current.textMatrix = [a, b, c, d, e, f];
this.current.textMatrixScale = Math.sqrt(a * a + b * b);
this.current.x = this.current.lineX = 0;
this.current.y = this.current.lineY = 0;
},
nextLine: function CanvasGraphics_nextLine() {
this.moveText(0, this.current.leading);
},
paintChar: function CanvasGraphics_paintChar(character, x, y) {
var ctx = this.ctx;
var current = this.current;
var font = current.font;
var textRenderingMode = current.textRenderingMode;
var fontSize = current.fontSize / current.fontSizeScale;
var fillStrokeMode = textRenderingMode &
_util.TextRenderingMode.FILL_STROKE_MASK;
var isAddToPathSet = !!(textRenderingMode &
_util.TextRenderingMode.ADD_TO_PATH_FLAG);
var addToPath;
if (font.disableFontFace || isAddToPathSet) {
addToPath = font.getPathGenerator(this.commonObjs, character);
}
if (font.disableFontFace) {
ctx.save();
ctx.translate(x, y);
ctx.beginPath();
addToPath(ctx, fontSize);
if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode ===
_util.TextRenderingMode.FILL_STROKE) {
ctx.fill();
}
if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode ===
_util.TextRenderingMode.FILL_STROKE) {
ctx.stroke();
}
ctx.restore();
} else {
if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode ===
_util.TextRenderingMode.FILL_STROKE) {
ctx.fillText(character, x, y);
}
if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode ===
_util.TextRenderingMode.FILL_STROKE) {
ctx.strokeText(character, x, y);
}
}
if (isAddToPathSet) {
var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
paths.push({
transform: ctx.mozCurrentTransform,
x: x,
y: y,
fontSize: fontSize,
addToPath: addToPath
});
}
},
get isFontSubpixelAAEnabled() {
var ctx = this.canvasFactory.create(10, 10).context;
ctx.scale(1.5, 1);
ctx.fillText('I', 0, 10);
var data = ctx.getImageData(0, 0, 10, 10).data;
var enabled = false;
for (var i = 3; i < data.length; i += 4) {
if (data[i] > 0 && data[i] < 255) {
enabled = true;
break;
}
}
return (0, _util.shadow)(this, 'isFontSubpixelAAEnabled', enabled);
},
showText: function CanvasGraphics_showText(glyphs) {
var current = this.current;
var font = current.font;
if (font.isType3Font) {
return this.showType3Text(glyphs);
}
var fontSize = current.fontSize;
if (fontSize === 0) {
return;
}
var ctx = this.ctx;
var fontSizeScale = current.fontSizeScale;
var charSpacing = current.charSpacing;
var wordSpacing = current.wordSpacing;
var fontDirection = current.fontDirection;
var textHScale = current.textHScale * fontDirection;
var glyphsLength = glyphs.length;
var vertical = font.vertical;
var spacingDir = vertical ? 1 : -1;
var defaultVMetrics = font.defaultVMetrics;
var widthAdvanceScale = fontSize * current.fontMatrix[0];
var simpleFillText = current.textRenderingMode ===
_util.TextRenderingMode.FILL && !font.disableFontFace;
ctx.save();
ctx.transform.apply(ctx, current.textMatrix);
ctx.translate(current.x, current.y + current.textRise);
if (current.patternFill) {
ctx.fillStyle = current.fillColor.getPattern(ctx, this);
}
if (fontDirection > 0) {
ctx.scale(textHScale, -1);
} else {
ctx.scale(textHScale, 1);
}
var lineWidth = current.lineWidth;
var scale = current.textMatrixScale;
if (scale === 0 || lineWidth === 0) {
var fillStrokeMode = current.textRenderingMode &
_util.TextRenderingMode.FILL_STROKE_MASK;
if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode ===
_util.TextRenderingMode.FILL_STROKE) {
this.cachedGetSinglePixelWidth = null;
lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
}
} else {
lineWidth /= scale;
}
if (fontSizeScale !== 1.0) {
ctx.scale(fontSizeScale, fontSizeScale);
lineWidth /= fontSizeScale;
}
ctx.lineWidth = lineWidth;
var x = 0,
i;
for (i = 0; i < glyphsLength; ++i) {
var glyph = glyphs[i];
if ((0, _util.isNum)(glyph)) {
x += spacingDir * glyph * fontSize / 1000;
continue;
}
var restoreNeeded = false;
var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
var character = glyph.fontChar;
var accent = glyph.accent;
var scaledX, scaledY, scaledAccentX, scaledAccentY;
var width = glyph.width;
if (vertical) {
var vmetric, vx, vy;
vmetric = glyph.vmetric || defaultVMetrics;
vx = glyph.vmetric ? vmetric[1] : width * 0.5;
vx = -vx * widthAdvanceScale;
vy = vmetric[2] * widthAdvanceScale;
width = vmetric ? -vmetric[0] : width;
scaledX = vx / fontSizeScale;
scaledY = (x + vy) / fontSizeScale;
} else {
scaledX = x / fontSizeScale;
scaledY = 0;
}
if (font.remeasure && width > 0) {
var measuredWidth = ctx.measureText(character).width * 1000 / fontSize *
fontSizeScale;
if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
var characterScaleX = width / measuredWidth;
restoreNeeded = true;
ctx.save();
ctx.scale(characterScaleX, 1);
scaledX /= characterScaleX;
} else if (width !== measuredWidth) {
scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
}
}
if (glyph.isInFont || font.missingFile) {
if (simpleFillText && !accent) {
ctx.fillText(character, scaledX, scaledY);
} else {
this.paintChar(character, scaledX, scaledY);
if (accent) {
scaledAccentX = scaledX + accent.offset.x / fontSizeScale;
scaledAccentY = scaledY - accent.offset.y / fontSizeScale;
this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY);
}
}
}
var charWidth = width * widthAdvanceScale + spacing * fontDirection;
x += charWidth;
if (restoreNeeded) {
ctx.restore();
}
}
if (vertical) {
current.y -= x * textHScale;
} else {
current.x += x * textHScale;
}
ctx.restore();
},
showType3Text: function CanvasGraphics_showType3Text(glyphs) {
var ctx = this.ctx;
var current = this.current;
var font = current.font;
var fontSize = current.fontSize;
var fontDirection = current.fontDirection;
var spacingDir = font.vertical ? 1 : -1;
var charSpacing = current.charSpacing;
var wordSpacing = current.wordSpacing;
var textHScale = current.textHScale * fontDirection;
var fontMatrix = current.fontMatrix || _util.FONT_IDENTITY_MATRIX;
var glyphsLength = glyphs.length;
var isTextInvisible = current.textRenderingMode ===
_util.TextRenderingMode.INVISIBLE;
var i, glyph, width, spacingLength;
if (isTextInvisible || fontSize === 0) {
return;
}
this.cachedGetSinglePixelWidth = null;
ctx.save();
ctx.transform.apply(ctx, current.textMatrix);
ctx.translate(current.x, current.y);
ctx.scale(textHScale, fontDirection);
for (i = 0; i < glyphsLength; ++i) {
glyph = glyphs[i];
if ((0, _util.isNum)(glyph)) {
spacingLength = spacingDir * glyph * fontSize / 1000;
this.ctx.translate(spacingLength, 0);
current.x += spacingLength * textHScale;
continue;
}
var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
var operatorList = font.charProcOperatorList[glyph.operatorListId];
if (!operatorList) {
(0, _util.warn)('Type3 character "' + glyph.operatorListId + '" is not
available.');
continue;
}
this.processingType3 = glyph;
this.save();
ctx.scale(fontSize, fontSize);
ctx.transform.apply(ctx, fontMatrix);
this.executeOperatorList(operatorList);
this.restore();
var transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
width = transformed[0] * fontSize + spacing;
ctx.translate(width, 0);
current.x += width * textHScale;
}
ctx.restore();
this.processingType3 = null;
},
setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {},
setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth,
yWidth, llx, lly, urx, ury) {
this.ctx.rect(llx, lly, urx - llx, ury - lly);
this.clip();
this.endPath();
},
getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
var _this = this;

var pattern;
if (IR[0] === 'TilingPattern') {
var color = IR[1];
var baseTransform = this.baseTransform ||
this.ctx.mozCurrentTransform.slice();
var canvasGraphicsFactory = {
createCanvasGraphics: function createCanvasGraphics(ctx) {
return new CanvasGraphics(ctx, _this.commonObjs, _this.objs,
_this.canvasFactory);
}
};
pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx,
canvasGraphicsFactory, baseTransform);
} else {
pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
}
return pattern;
},
setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
this.current.strokeColor = this.getColorN_Pattern(arguments);
},
setFillColorN: function CanvasGraphics_setFillColorN() {
this.current.fillColor = this.getColorN_Pattern(arguments);
this.current.patternFill = true;
},
setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
var color = _util.Util.makeCssRgb(r, g, b);
this.ctx.strokeStyle = color;
this.current.strokeColor = color;
},
setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
var color = _util.Util.makeCssRgb(r, g, b);
this.ctx.fillStyle = color;
this.current.fillColor = color;
this.current.patternFill = false;
},
shadingFill: function CanvasGraphics_shadingFill(patternIR) {
var ctx = this.ctx;
this.save();
var pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
ctx.fillStyle = pattern.getPattern(ctx, this, true);
var inv = ctx.mozCurrentTransformInverse;
if (inv) {
var canvas = ctx.canvas;
var width = canvas.width;
var height = canvas.height;
var bl = _util.Util.applyTransform([0, 0], inv);
var br = _util.Util.applyTransform([0, height], inv);
var ul = _util.Util.applyTransform([width, 0], inv);
var ur = _util.Util.applyTransform([width, height], inv);
var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
} else {
this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
}
this.restore();
},
beginInlineImage: function CanvasGraphics_beginInlineImage() {
throw new Error('Should not call beginInlineImage');
},
beginImageData: function CanvasGraphics_beginImageData() {
throw new Error('Should not call beginImageData');
},
paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix,
bbox) {
this.save();
this.baseTransformStack.push(this.baseTransform);
if ((0, _util.isArray)(matrix) && matrix.length === 6) {
this.transform.apply(this, matrix);
}
this.baseTransform = this.ctx.mozCurrentTransform;
if ((0, _util.isArray)(bbox) && bbox.length === 4) {
var width = bbox[2] - bbox[0];
var height = bbox[3] - bbox[1];
this.ctx.rect(bbox[0], bbox[1], width, height);
this.clip();
this.endPath();
}
},
paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
this.restore();
this.baseTransform = this.baseTransformStack.pop();
},
beginGroup: function CanvasGraphics_beginGroup(group) {
this.save();
var currentCtx = this.ctx;
if (!group.isolated) {
(0, _util.info)('TODO: Support non-isolated groups.');
}
if (group.knockout) {
(0, _util.warn)('Knockout groups not supported.');
}
var currentTransform = currentCtx.mozCurrentTransform;
if (group.matrix) {
currentCtx.transform.apply(currentCtx, group.matrix);
}
if (!group.bbox) {
throw new Error('Bounding box is required.');
}
var bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox,
currentCtx.mozCurrentTransform);
var canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
var offsetX = Math.floor(bounds[0]);
var offsetY = Math.floor(bounds[1]);
var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
var scaleX = 1,
scaleY = 1;
if (drawnWidth > MAX_GROUP_SIZE) {
scaleX = drawnWidth / MAX_GROUP_SIZE;
drawnWidth = MAX_GROUP_SIZE;
}
if (drawnHeight > MAX_GROUP_SIZE) {
scaleY = drawnHeight / MAX_GROUP_SIZE;
drawnHeight = MAX_GROUP_SIZE;
}
var cacheId = 'groupAt' + this.groupLevel;
if (group.smask) {
cacheId += '_smask_' + this.smaskCounter++ % 2;
}
var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth,
drawnHeight, true);
var groupCtx = scratchCanvas.context;
groupCtx.scale(1 / scaleX, 1 / scaleY);
groupCtx.translate(-offsetX, -offsetY);
groupCtx.transform.apply(groupCtx, currentTransform);
if (group.smask) {
this.smaskStack.push({
canvas: scratchCanvas.canvas,
context: groupCtx,
offsetX: offsetX,
offsetY: offsetY,
scaleX: scaleX,
scaleY: scaleY,
subtype: group.smask.subtype,
backdrop: group.smask.backdrop,
transferMap: group.smask.transferMap || null,
startTransformInverse: null
});
} else {
currentCtx.setTransform(1, 0, 0, 1, 0, 0);
currentCtx.translate(offsetX, offsetY);
currentCtx.scale(scaleX, scaleY);
}
copyCtxState(currentCtx, groupCtx);
this.ctx = groupCtx;
this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
this.groupStack.push(currentCtx);
this.groupLevel++;
this.current.activeSMask = null;
},
endGroup: function CanvasGraphics_endGroup(group) {
this.groupLevel--;
var groupCtx = this.ctx;
this.ctx = this.groupStack.pop();
if (this.ctx.imageSmoothingEnabled !== undefined) {
this.ctx.imageSmoothingEnabled = false;
} else {
this.ctx.mozImageSmoothingEnabled = false;
}
if (group.smask) {
this.tempSMask = this.smaskStack.pop();
} else {
this.ctx.drawImage(groupCtx.canvas, 0, 0);
}
this.restore();
},
beginAnnotations: function CanvasGraphics_beginAnnotations() {
this.save();
if (this.baseTransform) {
this.ctx.setTransform.apply(this.ctx, this.baseTransform);
}
},
endAnnotations: function CanvasGraphics_endAnnotations() {
this.restore();
},
beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform,
matrix) {
this.save();
resetCtxToDefault(this.ctx);
this.current = new CanvasExtraState();
if ((0, _util.isArray)(rect) && rect.length === 4) {
var width = rect[2] - rect[0];
var height = rect[3] - rect[1];
this.ctx.rect(rect[0], rect[1], width, height);
this.clip();
this.endPath();
}
this.transform.apply(this, transform);
this.transform.apply(this, matrix);
},
endAnnotation: function CanvasGraphics_endAnnotation() {
this.restore();
},
paintJpegXObject: function CanvasGraphics_paintJpegXObject(objId, w, h) {
var domImage = this.objs.get(objId);
if (!domImage) {
(0, _util.warn)('Dependent image isn\'t ready yet');
return;
}
this.save();
var ctx = this.ctx;
ctx.scale(1 / w, -1 / h);
ctx.drawImage(domImage, 0, 0, domImage.width, domImage.height, 0, -h, w, h);
if (this.imageLayer) {
var currentTransform = ctx.mozCurrentTransformInverse;
var position = this.getCanvasPosition(0, 0);
this.imageLayer.appendImage({
objId: objId,
left: position[0],
top: position[1],
width: w / currentTransform[0],
height: h / currentTransform[3]
});
}
this.restore();
},
paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
var ctx = this.ctx;
var width = img.width,
height = img.height;
var fillColor = this.current.fillColor;
var isPatternFill = this.current.patternFill;
var glyph = this.processingType3;
if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
glyph.compiled = compileType3Glyph({
data: img.data,
width: width,
height: height
});
} else {
glyph.compiled = null;
}
}
if (glyph && glyph.compiled) {
glyph.compiled(ctx);
return;
}
var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
var maskCtx = maskCanvas.context;
maskCtx.save();
putBinaryImageMask(maskCtx, img);
maskCtx.globalCompositeOperation = 'source-in';
maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) :
fillColor;
maskCtx.fillRect(0, 0, width, height);
maskCtx.restore();
this.paintInlineImageXObject(maskCanvas.canvas);
},
paintImageMaskXObjectRepeat: function
CanvasGraphics_paintImageMaskXObjectRepeat(imgData, scaleX, scaleY, positions) {
var width = imgData.width;
var height = imgData.height;
var fillColor = this.current.fillColor;
var isPatternFill = this.current.patternFill;
var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
var maskCtx = maskCanvas.context;
maskCtx.save();
putBinaryImageMask(maskCtx, imgData);
maskCtx.globalCompositeOperation = 'source-in';
maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) :
fillColor;
maskCtx.fillRect(0, 0, width, height);
maskCtx.restore();
var ctx = this.ctx;
for (var i = 0, ii = positions.length; i < ii; i += 2) {
ctx.save();
ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);
ctx.scale(1, -1);
ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
ctx.restore();
}
},
paintImageMaskXObjectGroup: function
CanvasGraphics_paintImageMaskXObjectGroup(images) {
var ctx = this.ctx;
var fillColor = this.current.fillColor;
var isPatternFill = this.current.patternFill;
for (var i = 0, ii = images.length; i < ii; i++) {
var image = images[i];
var width = image.width,
height = image.height;
var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width,
height);
var maskCtx = maskCanvas.context;
maskCtx.save();
putBinaryImageMask(maskCtx, image);
maskCtx.globalCompositeOperation = 'source-in';
maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) :
fillColor;
maskCtx.fillRect(0, 0, width, height);
maskCtx.restore();
ctx.save();
ctx.transform.apply(ctx, image.transform);
ctx.scale(1, -1);
ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
ctx.restore();
}
},
paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
var imgData = this.objs.get(objId);
if (!imgData) {
(0, _util.warn)('Dependent image isn\'t ready yet');
return;
}
this.paintInlineImageXObject(imgData);
},
paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId,
scaleX, scaleY, positions) {
var imgData = this.objs.get(objId);
if (!imgData) {
(0, _util.warn)('Dependent image isn\'t ready yet');
return;
}
var width = imgData.width;
var height = imgData.height;
var map = [];
for (var i = 0, ii = positions.length; i < ii; i += 2) {
map.push({
transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
x: 0,
y: 0,
w: width,
h: height
});
}
this.paintInlineImageXObjectGroup(imgData, map);
},
paintInlineImageXObject: function
CanvasGraphics_paintInlineImageXObject(imgData) {
var width = imgData.width;
var height = imgData.height;
var ctx = this.ctx;
this.save();
ctx.scale(1 / width, -1 / height);
var currentTransform = ctx.mozCurrentTransformInverse;
var a = currentTransform[0],
b = currentTransform[1];
var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);
var c = currentTransform[2],
d = currentTransform[3];
var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
var imgToPaint, tmpCanvas;
if (imgData instanceof HTMLElement || !imgData.data) {
imgToPaint = imgData;
} else {
tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', width, height);
var tmpCtx = tmpCanvas.context;
putBinaryImageData(tmpCtx, imgData);
imgToPaint = tmpCanvas.canvas;
}
var paintWidth = width,
paintHeight = height;
var tmpCanvasId = 'prescale1';
while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight >
1) {
var newWidth = paintWidth,
newHeight = paintHeight;
if (widthScale > 2 && paintWidth > 1) {
newWidth = Math.ceil(paintWidth / 2);
widthScale /= paintWidth / newWidth;
}
if (heightScale > 2 && paintHeight > 1) {
newHeight = Math.ceil(paintHeight / 2);
heightScale /= paintHeight / newHeight;
}
tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth,
newHeight);
tmpCtx = tmpCanvas.context;
tmpCtx.clearRect(0, 0, newWidth, newHeight);
tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth,
newHeight);
imgToPaint = tmpCanvas.canvas;
paintWidth = newWidth;
paintHeight = newHeight;
tmpCanvasId = tmpCanvasId === 'prescale1' ? 'prescale2' : 'prescale1';
}
ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width,
height);
if (this.imageLayer) {
var position = this.getCanvasPosition(0, -height);
this.imageLayer.appendImage({
imgData: imgData,
left: position[0],
top: position[1],
width: width / currentTransform[0],
height: height / currentTransform[3]
});
}
this.restore();
},
paintInlineImageXObjectGroup: function
CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
var ctx = this.ctx;
var w = imgData.width;
var h = imgData.height;
var tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', w, h);
var tmpCtx = tmpCanvas.context;
putBinaryImageData(tmpCtx, imgData);
for (var i = 0, ii = map.length; i < ii; i++) {
var entry = map[i];
ctx.save();
ctx.transform.apply(ctx, entry.transform);
ctx.scale(1, -1);
ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1,
1, 1);
if (this.imageLayer) {
var position = this.getCanvasPosition(entry.x, entry.y);
this.imageLayer.appendImage({
imgData: imgData,
left: position[0],
top: position[1],
width: w,
height: h
});
}
ctx.restore();
}
},
paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
this.ctx.fillRect(0, 0, 1, 1);
},
paintXObject: function CanvasGraphics_paintXObject() {
(0, _util.warn)('Unsupported \'paintXObject\' command.');
},
markPoint: function CanvasGraphics_markPoint(tag) {},
markPointProps: function CanvasGraphics_markPointProps(tag, properties) {},
beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {},
beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag,
properties) {},
endMarkedContent: function CanvasGraphics_endMarkedContent() {},
beginCompat: function CanvasGraphics_beginCompat() {},
endCompat: function CanvasGraphics_endCompat() {},
consumePath: function CanvasGraphics_consumePath() {
var ctx = this.ctx;
if (this.pendingClip) {
if (this.pendingClip === EO_CLIP) {
ctx.clip('evenodd');
} else {
ctx.clip();
}
this.pendingClip = null;
}
ctx.beginPath();
},
getSinglePixelWidth: function CanvasGraphics_getSinglePixelWidth(scale) {
if (this.cachedGetSinglePixelWidth === null) {
this.ctx.save();
var inverse = this.ctx.mozCurrentTransformInverse;
this.ctx.restore();
this.cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0]
+ inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
}
return this.cachedGetSinglePixelWidth;
},
getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
var transform = this.ctx.mozCurrentTransform;
return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x
+ transform[3] * y + transform[5]];
}
};
for (var op in _util.OPS) {
CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
}
return CanvasGraphics;
}();
exports.CanvasGraphics = CanvasGraphics;

/***/ }),
/* 12 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.FontLoader = exports.FontFaceObject = undefined;

var _util = __w_pdfjs_require__(0);

configurable: true
});
FontLoader.prototype.addNativeFontFace = function
fontLoader_addNativeFontFace(nativeFontFace) {
this.nativeFontFaces.push(nativeFontFace);
document.fonts.add(nativeFontFace);
};
FontLoader.prototype.bind = function fontLoaderBind(fonts, callback) {
var rules = [];
var fontsToLoad = [];
var fontLoadPromises = [];
var getNativeFontPromise = function getNativeFontPromise(nativeFontFace) {
return nativeFontFace.loaded.catch(function (e) {
(0, _util.warn)('Failed to load font "' + nativeFontFace.family + '": ' +
e);
});
};
var isFontLoadingAPISupported = FontLoader.isFontLoadingAPISupported && !
FontLoader.isSyncFontLoadingSupported;
for (var i = 0, ii = fonts.length; i < ii; i++) {
var font = fonts[i];
if (font.attached || font.loading === false) {
continue;
}
font.attached = true;
if (isFontLoadingAPISupported) {
var nativeFontFace = font.createNativeFontFace();
if (nativeFontFace) {
this.addNativeFontFace(nativeFontFace);
fontLoadPromises.push(getNativeFontPromise(nativeFontFace));
}
} else {
var rule = font.createFontFaceRule();
if (rule) {
this.insertRule(rule);
rules.push(rule);
fontsToLoad.push(font);
}
}
}
var request = this.queueLoadingCallback(callback);
if (isFontLoadingAPISupported) {
Promise.all(fontLoadPromises).then(function () {
request.complete();
});
} else if (rules.length > 0 && !FontLoader.isSyncFontLoadingSupported) {
this.prepareFontLoadEvent(rules, fontsToLoad, request);
} else {
request.complete();
}
};
FontLoader.prototype.queueLoadingCallback = function
FontLoader_queueLoadingCallback(callback) {
function LoadLoader_completeRequest() {
(0, _util.assert)(!request.end, 'completeRequest() cannot be called twice');
request.end = Date.now();
while (context.requests.length > 0 && context.requests[0].end) {
var otherRequest = context.requests.shift();
setTimeout(otherRequest.callback, 0);
}
}
var context = this.loadingContext;
var requestId = 'pdfjs-font-loading-' + context.nextRequestId++;
var request = {
id: requestId,
complete: LoadLoader_completeRequest,
callback: callback,
started: Date.now()
};
context.requests.push(request);
return request;
};
FontLoader.prototype.prepareFontLoadEvent = function
fontLoaderPrepareFontLoadEvent(rules, fonts, request) {
function int32(data, offset) {
return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 |
data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
}
function spliceString(s, offset, remove, insert) {
var chunk1 = s.substr(0, offset);
var chunk2 = s.substr(offset + remove);
return chunk1 + insert + chunk2;
}
var i, ii;
var canvas = document.createElement('canvas');
canvas.width = 1;
canvas.height = 1;
var ctx = canvas.getContext('2d');
var called = 0;
function isFontReady(name, callback) {
called++;
if (called > 30) {
(0, _util.warn)('Load test font never loaded.');
callback();
return;
}
ctx.font = '30px ' + name;
ctx.fillText('.', 0, 20);
var imageData = ctx.getImageData(0, 0, 1, 1);
if (imageData.data[3] > 0) {
callback();
return;
}
setTimeout(isFontReady.bind(null, name, callback));
}
var loadTestFontId = 'lt' + Date.now() + this.loadTestFontId++;
var data = this.loadTestFont;
var COMMENT_OFFSET = 976;
data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length,
loadTestFontId);
var CFF_CHECKSUM_OFFSET = 16;
var XXXX_VALUE = 0x58585858;
var checksum = int32(data, CFF_CHECKSUM_OFFSET);
for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
}
if (i < loadTestFontId.length) {
checksum = checksum - XXXX_VALUE + int32(loadTestFontId + 'XXX', i) | 0;
}
data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)
(checksum));
var url = 'url(data:font/opentype;base64,' + btoa(data) + ');';
var rule = '@font-face { font-family:"' + loadTestFontId + '";src:' + url +
'}';
this.insertRule(rule);
var names = [];
for (i = 0, ii = fonts.length; i < ii; i++) {
names.push(fonts[i].loadedName);
}
names.push(loadTestFontId);
var div = document.createElement('div');
div.setAttribute('style', 'visibility: hidden;' + 'width: 10px; height: 10px;'
+ 'position: absolute; top: 0px; left: 0px;');
for (i = 0, ii = names.length; i < ii; ++i) {
var span = document.createElement('span');
span.textContent = 'Hi';
span.style.fontFamily = names[i];
div.appendChild(span);
}
document.body.appendChild(div);
isFontReady(loadTestFontId, function () {
document.body.removeChild(div);
request.complete();
});
};
}
{
FontLoader.isFontLoadingAPISupported = typeof document !== 'undefined' && !!
document.fonts;
}
{
var isSyncFontLoadingSupported = function isSyncFontLoadingSupported() {
if (typeof navigator === 'undefined') {
return true;
}
var supported = false;
var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
if (m && m[1] >= 14) {
supported = true;
}
return supported;
};
Object.defineProperty(FontLoader, 'isSyncFontLoadingSupported', {
get: function get() {
return (0, _util.shadow)(FontLoader, 'isSyncFontLoadingSupported',
isSyncFontLoadingSupported());
},

enumerable: true,
configurable: true
});
}
var IsEvalSupportedCached = {
get value() {
return (0, _util.shadow)(this, 'value', (0, _util.isEvalSupported)());
}
};
var FontFaceObject = function FontFaceObjectClosure() {
function FontFaceObject(translatedData, options) {
this.compiledGlyphs = Object.create(null);
for (var i in translatedData) {
this[i] = translatedData[i];
}
this.options = options;
}
FontFaceObject.prototype = {
createNativeFontFace: function FontFaceObject_createNativeFontFace() {
if (!this.data) {
return null;
}
if (this.options.disableFontFace) {
this.disableFontFace = true;
return null;
}
var nativeFontFace = new FontFace(this.loadedName, this.data, {});
if (this.options.fontRegistry) {
this.options.fontRegistry.registerFont(this);
}
return nativeFontFace;
},
createFontFaceRule: function FontFaceObject_createFontFaceRule() {
if (!this.data) {
return null;
}
if (this.options.disableFontFace) {
this.disableFontFace = true;
return null;
}
var data = (0, _util.bytesToString)(new Uint8Array(this.data));
var fontName = this.loadedName;
var url = 'url(data:' + this.mimetype + ';base64,' + btoa(data) + ');';
var rule = '@font-face { font-family:"' + fontName + '";src:' + url + '}';
if (this.options.fontRegistry) {
this.options.fontRegistry.registerFont(this, url);
}
return rule;
},
getPathGenerator: function FontFaceObject_getPathGenerator(objs, character) {
if (!(character in this.compiledGlyphs)) {
var cmds = objs.get(this.loadedName + '_path_' + character);
var current, i, len;
if (this.options.isEvalSupported && IsEvalSupportedCached.value) {
var args,
js = '';
for (i = 0, len = cmds.length; i < len; i++) {
current = cmds[i];
if (current.args !== undefined) {
args = current.args.join(',');
} else {
args = '';
}
js += 'c.' + current.cmd + '(' + args + ');\n';
}
this.compiledGlyphs[character] = new Function('c', 'size', js);
} else {
this.compiledGlyphs[character] = function (c, size) {
for (i = 0, len = cmds.length; i < len; i++) {
current = cmds[i];
if (current.cmd === 'scale') {
current.args = [size, -size];
}
c[current.cmd].apply(c, current.args);
}
};
}
}
return this.compiledGlyphs[character];
}
};
return FontFaceObject;
}();
exports.FontFaceObject = FontFaceObject;
exports.FontLoader = FontLoader;

/***/ }),
/* 13 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

Object.defineProperty(exports, "__esModule", {
value: true
});
exports.TilingPattern = exports.getShadingPatternFromIR = undefined;

var _util = __w_pdfjs_require__(0);

var _webgl = __w_pdfjs_require__(7);

var ShadingIRs = {};

ShadingIRs.RadialAxial = {
fromIR: function RadialAxial_fromIR(raw) {
var type = raw[1];
var colorStops = raw[2];
var p0 = raw[3];
var p1 = raw[4];
var r0 = raw[5];
var r1 = raw[6];
return {
type: 'Pattern',
getPattern: function RadialAxial_getPattern(ctx) {
var grad;
if (type === 'axial') {
grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
} else if (type === 'radial') {
grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
}
for (var i = 0, ii = colorStops.length; i < ii; ++i) {
var c = colorStops[i];
grad.addColorStop(c[0], c[1]);
}
return grad;
}
};
}
};
var createMeshCanvas = function createMeshCanvasClosure() {
function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
var coords = context.coords,
colors = context.colors;
var bytes = data.data,
rowSize = data.width * 4;
var tmp;
if (coords[p1 + 1] > coords[p2 + 1]) {
tmp = p1;
p1 = p2;
p2 = tmp;
tmp = c1;
c1 = c2;
c2 = tmp;
}
if (coords[p2 + 1] > coords[p3 + 1]) {
tmp = p2;
p2 = p3;
p3 = tmp;
tmp = c2;
c2 = c3;
c3 = tmp;
}
if (coords[p1 + 1] > coords[p2 + 1]) {
tmp = p1;
p1 = p2;
p2 = tmp;
tmp = c1;
c1 = c2;
c2 = tmp;
}
var x1 = (coords[p1] + context.offsetX) * context.scaleX;
var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
var x2 = (coords[p2] + context.offsetX) * context.scaleX;
var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
var x3 = (coords[p3] + context.offsetX) * context.scaleX;
var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
if (y1 >= y3) {
return;
}
var c1r = colors[c1],
c1g = colors[c1 + 1],
c1b = colors[c1 + 2];
var c2r = colors[c2],
c2g = colors[c2 + 1],
c2b = colors[c2 + 2];
var c3r = colors[c3],
c3g = colors[c3 + 1],
c3b = colors[c3 + 2];
var minY = Math.round(y1),
maxY = Math.round(y3);
var xa, car, cag, cab;
var xb, cbr, cbg, cbb;
var k;
for (var y = minY; y <= maxY; y++) {
if (y < y2) {
k = y < y1 ? 0 : y1 === y2 ? 1 : (y1 - y) / (y1 - y2);
xa = x1 - (x1 - x2) * k;
car = c1r - (c1r - c2r) * k;
cag = c1g - (c1g - c2g) * k;
cab = c1b - (c1b - c2b) * k;
} else {
k = y > y3 ? 1 : y2 === y3 ? 0 : (y2 - y) / (y2 - y3);
xa = x2 - (x2 - x3) * k;
car = c2r - (c2r - c3r) * k;
cag = c2g - (c2g - c3g) * k;
cab = c2b - (c2b - c3b) * k;
}
k = y < y1 ? 0 : y > y3 ? 1 : (y1 - y) / (y1 - y3);
xb = x1 - (x1 - x3) * k;
cbr = c1r - (c1r - c3r) * k;
cbg = c1g - (c1g - c3g) * k;
cbb = c1b - (c1b - c3b) * k;
var x1_ = Math.round(Math.min(xa, xb));
var x2_ = Math.round(Math.max(xa, xb));
var j = rowSize * y + x1_ * 4;
for (var x = x1_; x <= x2_; x++) {
k = (xa - x) / (xa - xb);
k = k < 0 ? 0 : k > 1 ? 1 : k;
bytes[j++] = car - (car - cbr) * k | 0;
bytes[j++] = cag - (cag - cbg) * k | 0;
bytes[j++] = cab - (cab - cbb) * k | 0;
bytes[j++] = 255;
}
}
}
function drawFigure(data, figure, context) {
var ps = figure.coords;
var cs = figure.colors;
var i, ii;
switch (figure.type) {
case 'lattice':
var verticesPerRow = figure.verticesPerRow;
var rows = Math.floor(ps.length / verticesPerRow) - 1;
var cols = verticesPerRow - 1;
for (i = 0; i < rows; i++) {
var q = i * verticesPerRow;
for (var j = 0; j < cols; j++, q++) {
drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow],
cs[q], cs[q + 1], cs[q + verticesPerRow]);
drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q
+ verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
}
}
break;
case 'triangles':
for (i = 0, ii = ps.length; i < ii; i += 3) {
drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i +
1], cs[i + 2]);
}
break;
default:
throw new Error('illegal figure');
}
}
function createMeshCanvas(bounds, combinesScale, coords, colors, figures,
backgroundColor, cachedCanvases) {
var EXPECTED_SCALE = 1.1;
var MAX_PATTERN_SIZE = 3000;
var BORDER_SIZE = 2;
var offsetX = Math.floor(bounds[0]);
var offsetY = Math.floor(bounds[1]);
var boundsWidth = Math.ceil(bounds[2]) - offsetX;
var boundsHeight = Math.ceil(bounds[3]) - offsetY;
var width = Math.min(Math.ceil(Math.abs(boundsWidth * combinesScale[0] *
EXPECTED_SCALE)), MAX_PATTERN_SIZE);
var height = Math.min(Math.ceil(Math.abs(boundsHeight * combinesScale[1] *
EXPECTED_SCALE)), MAX_PATTERN_SIZE);
var scaleX = boundsWidth / width;
var scaleY = boundsHeight / height;
var context = {
coords: coords,
colors: colors,
offsetX: -offsetX,
offsetY: -offsetY,
scaleX: 1 / scaleX,
scaleY: 1 / scaleY
};
var paddedWidth = width + BORDER_SIZE * 2;
var paddedHeight = height + BORDER_SIZE * 2;
var canvas, tmpCanvas, i, ii;
if (_webgl.WebGLUtils.isEnabled) {
canvas = _webgl.WebGLUtils.drawFigures(width, height, backgroundColor,
figures, context);
tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight,
false);
tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
canvas = tmpCanvas.canvas;
} else {
tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight,
false);
var tmpCtx = tmpCanvas.context;
var data = tmpCtx.createImageData(width, height);
if (backgroundColor) {
var bytes = data.data;
for (i = 0, ii = bytes.length; i < ii; i += 4) {
bytes[i] = backgroundColor[0];
bytes[i + 1] = backgroundColor[1];
bytes[i + 2] = backgroundColor[2];
bytes[i + 3] = 255;
}
}
for (i = 0; i < figures.length; i++) {
drawFigure(data, figures[i], context);
}
tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
canvas = tmpCanvas.canvas;
}
return {
canvas: canvas,
offsetX: offsetX - BORDER_SIZE * scaleX,
offsetY: offsetY - BORDER_SIZE * scaleY,
scaleX: scaleX,
scaleY: scaleY
};
}
return createMeshCanvas;
}();
ShadingIRs.Mesh = {
fromIR: function Mesh_fromIR(raw) {
var coords = raw[2];
var colors = raw[3];
var figures = raw[4];
var bounds = raw[5];
var matrix = raw[6];
var background = raw[8];
return {
type: 'Pattern',
getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
var scale;
if (shadingFill) {
scale =
_util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
} else {
scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
if (matrix) {
var matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
}
}
var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords,
colors, figures, shadingFill ? null : background, owner.cachedCanvases);
if (!shadingFill) {
ctx.setTransform.apply(ctx, owner.baseTransform);
if (matrix) {
ctx.transform.apply(ctx, matrix);
}
}
ctx.translate(temporaryPatternCanvas.offsetX,
temporaryPatternCanvas.offsetY);
ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
return ctx.createPattern(temporaryPatternCanvas.canvas, 'no-repeat');
}
};
}
};
ShadingIRs.Dummy = {
fromIR: function Dummy_fromIR() {
return {
type: 'Pattern',
getPattern: function Dummy_fromIR_getPattern() {
return 'hotpink';
}
};
}
};
function getShadingPatternFromIR(raw) {
var shadingIR = ShadingIRs[raw[0]];
if (!shadingIR) {
throw new Error('Unknown IR type: ' + raw[0]);
}
return shadingIR.fromIR(raw);
}
var TilingPattern = function TilingPatternClosure() {
var PaintType = {
COLORED: 1,
UNCOLORED: 2
};
var MAX_PATTERN_SIZE = 3000;
function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
this.operatorList = IR[2];
this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
this.bbox = IR[4];
this.xstep = IR[5];
this.ystep = IR[6];
this.paintType = IR[7];
this.tilingType = IR[8];
this.color = color;
this.canvasGraphicsFactory = canvasGraphicsFactory;
this.baseTransform = baseTransform;
this.type = 'Pattern';
this.ctx = ctx;
}
TilingPattern.prototype = {
createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
var operatorList = this.operatorList;
var bbox = this.bbox;
var xstep = this.xstep;
var ystep = this.ystep;
var paintType = this.paintType;
var tilingType = this.tilingType;
var color = this.color;
var canvasGraphicsFactory = this.canvasGraphicsFactory;
(0, _util.info)('TilingType: ' + tilingType);
var x0 = bbox[0],
y0 = bbox[1],
x1 = bbox[2],
y1 = bbox[3];
var topLeft = [x0, y0];
var botRight = [x0 + xstep, y0 + ystep];
var width = botRight[0] - topLeft[0];
var height = botRight[1] - topLeft[1];
var matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
var curMatrixScale =
_util.Util.singularValueDecompose2dScale(this.baseTransform);
var combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] *
curMatrixScale[1]];
width = Math.min(Math.ceil(Math.abs(width * combinedScale[0])),
MAX_PATTERN_SIZE);
height = Math.min(Math.ceil(Math.abs(height * combinedScale[1])),
MAX_PATTERN_SIZE);
var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', width, height,
true);
var tmpCtx = tmpCanvas.context;
var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
graphics.groupLevel = owner.groupLevel;
this.setFillAndStrokeStyleToContext(tmpCtx, paintType, color);
this.setScale(width, height, xstep, ystep);
this.transformToScale(graphics);
var tmpTranslate = [1, 0, 0, 1, -topLeft[0], -topLeft[1]];
graphics.transform.apply(graphics, tmpTranslate);
this.clipBbox(graphics, bbox, x0, y0, x1, y1);
graphics.executeOperatorList(operatorList);
return tmpCanvas.canvas;
},
setScale: function TilingPattern_setScale(width, height, xstep, ystep) {
this.scale = [width / xstep, height / ystep];
},
transformToScale: function TilingPattern_transformToScale(graphics) {
var scale = this.scale;
var tmpScale = [scale[0], 0, 0, scale[1], 0, 0];
graphics.transform.apply(graphics, tmpScale);
},
scaleToContext: function TilingPattern_scaleToContext() {
var scale = this.scale;
this.ctx.scale(1 / scale[0], 1 / scale[1]);
},
clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
if ((0, _util.isArray)(bbox) && bbox.length === 4) {
var bboxWidth = x1 - x0;
var bboxHeight = y1 - y0;
graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
graphics.clip();
graphics.endPath();
}
},
setFillAndStrokeStyleToContext: function
setFillAndStrokeStyleToContext(context, paintType, color) {
switch (paintType) {
case PaintType.COLORED:
var ctx = this.ctx;
context.fillStyle = ctx.fillStyle;
context.strokeStyle = ctx.strokeStyle;
break;
case PaintType.UNCOLORED:
var cssColor = _util.Util.makeCssRgb(color[0], color[1], color[2]);
context.fillStyle = cssColor;
context.strokeStyle = cssColor;
break;
default:
throw new _util.FormatError('Unsupported paint type: ' + paintType);
}
},
getPattern: function TilingPattern_getPattern(ctx, owner) {
var temporaryPatternCanvas = this.createPatternCanvas(owner);
ctx = this.ctx;
ctx.setTransform.apply(ctx, this.baseTransform);
ctx.transform.apply(ctx, this.matrix);
this.scaleToContext();
return ctx.createPattern(temporaryPatternCanvas, 'repeat');
}
};
return TilingPattern;
}();
exports.getShadingPatternFromIR = getShadingPatternFromIR;
exports.TilingPattern = TilingPattern;

/***/ }),
/* 14 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PDFDataTransportStream = undefined;

var _util = __w_pdfjs_require__(0);

var PDFDataTransportStream = function PDFDataTransportStreamClosure() {

function PDFDataTransportStream(params, pdfDataRangeTransport) {
var _this = this;

(0, _util.assert)(pdfDataRangeTransport);
this._queuedChunks = [];
var initialData = params.initialData;
if (initialData && initialData.length > 0) {
var buffer = new Uint8Array(initialData).buffer;
this._queuedChunks.push(buffer);
}
this._pdfDataRangeTransport = pdfDataRangeTransport;
this._isRangeSupported = !params.disableRange;
this._isStreamingSupported = !params.disableStream;
this._contentLength = params.length;
this._fullRequestReader = null;
this._rangeReaders = [];
this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
_this._onReceiveData({
begin: begin,
chunk: chunk
});
});
this._pdfDataRangeTransport.addProgressListener(function (loaded) {
_this._onProgress({ loaded: loaded });
});
this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
_this._onReceiveData({ chunk: chunk });
});
this._pdfDataRangeTransport.transportReady();
}
PDFDataTransportStream.prototype = {
_onReceiveData: function PDFDataTransportStream_onReceiveData(args) {
var buffer = new Uint8Array(args.chunk).buffer;
if (args.begin === undefined) {
if (this._fullRequestReader) {
this._fullRequestReader._enqueue(buffer);
} else {
this._queuedChunks.push(buffer);
}
} else {
var found = this._rangeReaders.some(function (rangeReader) {
if (rangeReader._begin !== args.begin) {
return false;
}
rangeReader._enqueue(buffer);
return true;
});
(0, _util.assert)(found);
}
},
_onProgress: function PDFDataTransportStream_onDataProgress(evt) {
if (this._rangeReaders.length > 0) {
var firstReader = this._rangeReaders[0];
if (firstReader.onProgress) {
firstReader.onProgress({ loaded: evt.loaded });
}
}
},
_removeRangeReader: function PDFDataTransportStream_removeRangeReader(reader) {
var i = this._rangeReaders.indexOf(reader);
if (i >= 0) {
this._rangeReaders.splice(i, 1);
}
},
getFullReader: function PDFDataTransportStream_getFullReader() {
(0, _util.assert)(!this._fullRequestReader);
var queuedChunks = this._queuedChunks;
this._queuedChunks = null;
return new PDFDataTransportStreamReader(this, queuedChunks);
},
getRangeReader: function PDFDataTransportStream_getRangeReader(begin, end) {
var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
this._pdfDataRangeTransport.requestDataRange(begin, end);
this._rangeReaders.push(reader);
return reader;
},
cancelAllRequests: function PDFDataTransportStream_cancelAllRequests(reason) {
if (this._fullRequestReader) {
this._fullRequestReader.cancel(reason);
}
var readers = this._rangeReaders.slice(0);
readers.forEach(function (rangeReader) {
rangeReader.cancel(reason);
});
this._pdfDataRangeTransport.abort();
}
};
function PDFDataTransportStreamReader(stream, queuedChunks) {
this._stream = stream;
this._done = false;
this._queuedChunks = queuedChunks || [];
this._requests = [];
this._headersReady = Promise.resolve();
stream._fullRequestReader = this;
this.onProgress = null;
}
PDFDataTransportStreamReader.prototype = {
_enqueue: function PDFDataTransportStreamReader_enqueue(chunk) {
if (this._done) {
return;
}
if (this._requests.length > 0) {
var requestCapability = this._requests.shift();
requestCapability.resolve({
value: chunk,
done: false
});
return;
}
this._queuedChunks.push(chunk);
},
get headersReady() {
return this._headersReady;
},
get isRangeSupported() {
return this._stream._isRangeSupported;
},
get isStreamingSupported() {
return this._stream._isStreamingSupported;
},
get contentLength() {
return this._stream._contentLength;
},
read: function PDFDataTransportStreamReader_read() {
if (this._queuedChunks.length > 0) {
var chunk = this._queuedChunks.shift();
return Promise.resolve({
value: chunk,
done: false
});
}
if (this._done) {
return Promise.resolve({
value: undefined,
done: true
});
}
var requestCapability = (0, _util.createPromiseCapability)();
this._requests.push(requestCapability);
return requestCapability.promise;
},
cancel: function PDFDataTransportStreamReader_cancel(reason) {
this._done = true;
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
}
};
function PDFDataTransportStreamRangeReader(stream, begin, end) {
this._stream = stream;
this._begin = begin;
this._end = end;
this._queuedChunk = null;
this._requests = [];
this._done = false;
this.onProgress = null;
}
PDFDataTransportStreamRangeReader.prototype = {
_enqueue: function PDFDataTransportStreamRangeReader_enqueue(chunk) {
if (this._done) {
return;
}
if (this._requests.length === 0) {
this._queuedChunk = chunk;
} else {
var requestsCapability = this._requests.shift();
requestsCapability.resolve({
value: chunk,
done: false
});
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
}
this._done = true;
this._stream._removeRangeReader(this);
},
get isStreamingSupported() {
return false;
},
read: function PDFDataTransportStreamRangeReader_read() {
if (this._queuedChunk) {
var chunk = this._queuedChunk;
this._queuedChunk = null;
return Promise.resolve({
value: chunk,
done: false
});
}
if (this._done) {
return Promise.resolve({
value: undefined,
done: true
});
}
var requestCapability = (0, _util.createPromiseCapability)();
this._requests.push(requestCapability);
return requestCapability.promise;
},
cancel: function PDFDataTransportStreamRangeReader_cancel(reason) {
this._done = true;
this._requests.forEach(function (requestCapability) {
requestCapability.resolve({
value: undefined,
done: true
});
});
this._requests = [];
this._stream._removeRangeReader(this);
}
};
return PDFDataTransportStream;
}();
exports.PDFDataTransportStream = PDFDataTransportStream;

/***/ }),
/* 15 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";
var pdfjsVersion = '1.9.426';
var pdfjsBuild = '2558a58d';
var pdfjsSharedUtil = __w_pdfjs_require__(0);
var pdfjsDisplayGlobal = __w_pdfjs_require__(8);
var pdfjsDisplayAPI = __w_pdfjs_require__(2);
var pdfjsDisplayTextLayer = __w_pdfjs_require__(5);
var pdfjsDisplayAnnotationLayer = __w_pdfjs_require__(3);
var pdfjsDisplayDOMUtils = __w_pdfjs_require__(1);
var pdfjsDisplaySVG = __w_pdfjs_require__(4);
{
__w_pdfjs_require__(9);
}
exports.PDFJS = pdfjsDisplayGlobal.PDFJS;
exports.build = pdfjsDisplayAPI.build;
exports.version = pdfjsDisplayAPI.version;
exports.getDocument = pdfjsDisplayAPI.getDocument;
exports.LoopbackPort = pdfjsDisplayAPI.LoopbackPort;
exports.PDFDataRangeTransport = pdfjsDisplayAPI.PDFDataRangeTransport;
exports.PDFWorker = pdfjsDisplayAPI.PDFWorker;
exports.renderTextLayer = pdfjsDisplayTextLayer.renderTextLayer;
exports.AnnotationLayer = pdfjsDisplayAnnotationLayer.AnnotationLayer;
exports.CustomStyle = pdfjsDisplayDOMUtils.CustomStyle;
exports.createPromiseCapability = pdfjsSharedUtil.createPromiseCapability;
exports.PasswordResponses = pdfjsSharedUtil.PasswordResponses;
exports.InvalidPDFException = pdfjsSharedUtil.InvalidPDFException;
exports.MissingPDFException = pdfjsSharedUtil.MissingPDFException;
exports.SVGGraphics = pdfjsDisplaySVG.SVGGraphics;
exports.NativeImageDecoding = pdfjsSharedUtil.NativeImageDecoding;
exports.UnexpectedResponseException = pdfjsSharedUtil.UnexpectedResponseException;
exports.OPS = pdfjsSharedUtil.OPS;
exports.UNSUPPORTED_FEATURES = pdfjsSharedUtil.UNSUPPORTED_FEATURES;
exports.isValidUrl = pdfjsDisplayDOMUtils.isValidUrl;
exports.createValidAbsoluteUrl = pdfjsSharedUtil.createValidAbsoluteUrl;
exports.createObjectURL = pdfjsSharedUtil.createObjectURL;
exports.removeNullCharacters = pdfjsSharedUtil.removeNullCharacters;
exports.shadow = pdfjsSharedUtil.shadow;
exports.createBlob = pdfjsSharedUtil.createBlob;
exports.RenderingCancelledException =
pdfjsDisplayDOMUtils.RenderingCancelledException;
exports.getFilenameFromUrl = pdfjsDisplayDOMUtils.getFilenameFromUrl;
exports.addLinkAttributes = pdfjsDisplayDOMUtils.addLinkAttributes;
exports.StatTimer = pdfjsSharedUtil.StatTimer;

/***/ }),
/* 16 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

if (typeof PDFJS === 'undefined' || !PDFJS.compatibilityChecked) {

enumerable: false,
configurable: true
});
Object.defineProperty(cpaProto, 'byteLength', {
get: function get() {
return this.length;
},

enumerable: false,
configurable: true
});
})();
(function normalizeURLObject() {
if (!globalScope.URL) {
globalScope.URL = globalScope.webkitURL;
}
})();
(function checkObjectDefinePropertyCompatibility() {
if (typeof Object.defineProperty !== 'undefined') {
var definePropertyPossible = true;
try {
if (hasDOM) {
Object.defineProperty(new Image(), 'id', { value: 'test' });
}
var Test = function Test() {};
Test.prototype = {
get id() {}
};
Object.defineProperty(new Test(), 'id', {
value: '',
configurable: true,
enumerable: true,
writable: false
});
} catch (e) {
definePropertyPossible = false;
}
if (definePropertyPossible) {
return;
}
}
Object.defineProperty = function objectDefineProperty(obj, name, def) {
delete obj[name];
if ('get' in def) {
obj.__defineGetter__(name, def['get']);
}
if ('set' in def) {
obj.__defineSetter__(name, def['set']);
}
if ('value' in def) {
obj.__defineSetter__(name, function objectDefinePropertySetter(value) {
this.__defineGetter__(name, function objectDefinePropertyGetter() {
return value;
});
return value;
});
obj[name] = def.value;
}
};
})();
(function checkXMLHttpRequestResponseCompatibility() {
if (typeof XMLHttpRequest === 'undefined') {
return;
}
var xhrPrototype = XMLHttpRequest.prototype;
var xhr = new XMLHttpRequest();
if (!('overrideMimeType' in xhr)) {
Object.defineProperty(xhrPrototype, 'overrideMimeType', {
value: function xmlHttpRequestOverrideMimeType(mimeType) {}
});
}
if ('responseType' in xhr) {
return;
}
Object.defineProperty(xhrPrototype, 'responseType', {
get: function xmlHttpRequestGetResponseType() {
return this._responseType || 'text';
},
set: function xmlHttpRequestSetResponseType(value) {
if (value === 'text' || value === 'arraybuffer') {
this._responseType = value;
if (value === 'arraybuffer' && typeof this.overrideMimeType ===
'function') {
this.overrideMimeType('text/plain; charset=x-user-defined');
}
}
}
});
if (typeof VBArray !== 'undefined') {
Object.defineProperty(xhrPrototype, 'response', {
get: function xmlHttpRequestResponseGet() {
if (this.responseType === 'arraybuffer') {
return new Uint8Array(new VBArray(this.responseBody).toArray());
}
return this.responseText;
}
});
return;
}
Object.defineProperty(xhrPrototype, 'response', {
get: function xmlHttpRequestResponseGet() {
if (this.responseType !== 'arraybuffer') {
return this.responseText;
}
var text = this.responseText;
var i,
n = text.length;
var result = new Uint8Array(n);
for (i = 0; i < n; ++i) {
result[i] = text.charCodeAt(i) & 0xFF;
}
return result.buffer;
}
});
})();
(function checkWindowBtoaCompatibility() {
if ('btoa' in globalScope) {
return;
}
var digits =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
globalScope.btoa = function (chars) {
var buffer = '';
var i, n;
for (i = 0, n = chars.length; i < n; i += 3) {
var b1 = chars.charCodeAt(i) & 0xFF;
var b2 = chars.charCodeAt(i + 1) & 0xFF;
var b3 = chars.charCodeAt(i + 2) & 0xFF;
var d1 = b1 >> 2,
d2 = (b1 & 3) << 4 | b2 >> 4;
var d3 = i + 1 < n ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
var d4 = i + 2 < n ? b3 & 0x3F : 64;
buffer += digits.charAt(d1) + digits.charAt(d2) + digits.charAt(d3) +
digits.charAt(d4);
}
return buffer;
};
})();
(function checkWindowAtobCompatibility() {
if ('atob' in globalScope) {
return;
}
var digits =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
globalScope.atob = function (input) {
input = input.replace(/=+$/, '');
if (input.length % 4 === 1) {
throw new Error('bad atob input');
}
for (var bc = 0, bs, buffer, idx = 0, output = ''; buffer = input.charAt(idx+
+); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output +=
String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
buffer = digits.indexOf(buffer);
}
return output;
};
})();
(function checkFunctionPrototypeBindCompatibility() {
if (typeof Function.prototype.bind !== 'undefined') {
return;
}
Function.prototype.bind = function functionPrototypeBind(obj) {
var fn = this,
headArgs = Array.prototype.slice.call(arguments, 1);
var bound = function functionPrototypeBindBound() {
var args = headArgs.concat(Array.prototype.slice.call(arguments));
return fn.apply(obj, args);
};
return bound;
};
})();
(function checkDatasetProperty() {
if (!hasDOM) {
return;
}
var div = document.createElement('div');
if ('dataset' in div) {
return;
}
Object.defineProperty(HTMLElement.prototype, 'dataset', {
get: function get() {
if (this._dataset) {
return this._dataset;
}
var dataset = {};
for (var j = 0, jj = this.attributes.length; j < jj; j++) {
var attribute = this.attributes[j];
if (attribute.name.substring(0, 5) !== 'data-') {
continue;
}
var key = attribute.name.substring(5).replace(/\-([a-z])/g, function
(all, ch) {
return ch.toUpperCase();
});
dataset[key] = attribute.value;
}
Object.defineProperty(this, '_dataset', {
value: dataset,
writable: false,
enumerable: false
});
return dataset;
},

enumerable: true
});
})();
(function checkClassListProperty() {
function changeList(element, itemName, add, remove) {
var s = element.className || '';
var list = s.split(/\s+/g);
if (list[0] === '') {
list.shift();
}
var index = list.indexOf(itemName);
if (index < 0 && add) {
list.push(itemName);
}
if (index >= 0 && remove) {
list.splice(index, 1);
}
element.className = list.join(' ');
return index >= 0;
}
if (!hasDOM) {
return;
}
var div = document.createElement('div');
if ('classList' in div) {
return;
}
var classListPrototype = {
add: function add(name) {
changeList(this.element, name, true, false);
},
contains: function contains(name) {
return changeList(this.element, name, false, false);
},
remove: function remove(name) {
changeList(this.element, name, false, true);
},
toggle: function toggle(name) {
changeList(this.element, name, true, true);
}
};
Object.defineProperty(HTMLElement.prototype, 'classList', {
get: function get() {
if (this._classList) {
return this._classList;
}
var classList = Object.create(classListPrototype, {
element: {
value: this,
writable: false,
enumerable: true
}
});
Object.defineProperty(this, '_classList', {
value: classList,
writable: false,
enumerable: false
});
return classList;
},

enumerable: true
});
})();
(function checkWorkerConsoleCompatibility() {
if (typeof importScripts === 'undefined' || 'console' in globalScope) {
return;
}
var consoleTimer = {};
var workerConsole = {
log: function log() {
var args = Array.prototype.slice.call(arguments);
globalScope.postMessage({
targetName: 'main',
action: 'console_log',
data: args
});
},
error: function error() {
var args = Array.prototype.slice.call(arguments);
globalScope.postMessage({
targetName: 'main',
action: 'console_error',
data: args
});
},
time: function time(name) {
consoleTimer[name] = Date.now();
},
timeEnd: function timeEnd(name) {
var time = consoleTimer[name];
if (!time) {
throw new Error('Unknown timer name ' + name);
}
this.log('Timer:', name, Date.now() - time);
}
};
globalScope.console = workerConsole;
})();
(function checkConsoleCompatibility() {
if (!hasDOM) {
return;
}
if (!('console' in window)) {
window.console = {
log: function log() {},
error: function error() {},
warn: function warn() {}
};
return;
}
if (!('bind' in console.log)) {
console.log = function (fn) {
return function (msg) {
return fn(msg);
};
}(console.log);
console.error = function (fn) {
return function (msg) {
return fn(msg);
};
}(console.error);
console.warn = function (fn) {
return function (msg) {
return fn(msg);
};
}(console.warn);
return;
}
})();
(function checkOnClickCompatibility() {
function ignoreIfTargetDisabled(event) {
if (isDisabled(event.target)) {
event.stopPropagation();
}
}
function isDisabled(node) {
return node.disabled || node.parentNode && isDisabled(node.parentNode);
}
if (isOpera) {
document.addEventListener('click', ignoreIfTargetDisabled, true);
}
})();
(function checkOnBlobSupport() {
if (isIE || isIOSChrome) {
PDFJS.disableCreateObjectURL = true;
}
})();
(function checkNavigatorLanguage() {
if (typeof navigator === 'undefined') {
return;
}
if ('language' in navigator) {
return;
}
PDFJS.locale = navigator.userLanguage || 'en-US';
})();
(function checkRangeRequests() {
if (isSafari || isAndroidPre3 || isChromeWithRangeBug || isIOS) {
PDFJS.disableRange = true;
PDFJS.disableStream = true;
}
})();
(function checkHistoryManipulation() {
if (!hasDOM) {
return;
}
if (!history.pushState || isAndroidPre3) {
PDFJS.disableHistory = true;
}
})();
(function checkSetPresenceInImageData() {
if (!hasDOM) {
return;
}
if (window.CanvasPixelArray) {
if (typeof window.CanvasPixelArray.prototype.set !== 'function') {
window.CanvasPixelArray.prototype.set = function (arr) {
for (var i = 0, ii = this.length; i < ii; i++) {
this[i] = arr[i];
}
};
}
} else {
var polyfill = false,
versionMatch;
if (isChrome) {
versionMatch = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
polyfill = versionMatch && parseInt(versionMatch[2]) < 21;
} else if (isAndroid) {
polyfill = isAndroidPre5;
} else if (isSafari) {
versionMatch = userAgent.match(/Version\/([0-9]+)\.([0-9]+)\.([0-9]+)
Safari\//);
polyfill = versionMatch && parseInt(versionMatch[1]) < 6;
}
if (polyfill) {
var contextPrototype = window.CanvasRenderingContext2D.prototype;
var createImageData = contextPrototype.createImageData;
contextPrototype.createImageData = function (w, h) {
var imageData = createImageData.call(this, w, h);
imageData.data.set = function (arr) {
for (var i = 0, ii = this.length; i < ii; i++) {
this[i] = arr[i];
}
};
return imageData;
};
contextPrototype = null;
}
}
})();
(function checkRequestAnimationFrame() {
function installFakeAnimationFrameFunctions() {
window.requestAnimationFrame = function (callback) {
return window.setTimeout(callback, 20);
};
window.cancelAnimationFrame = function (timeoutID) {
window.clearTimeout(timeoutID);
};
}
if (!hasDOM) {
return;
}
if (isIOS) {
installFakeAnimationFrameFunctions();
return;
}
if ('requestAnimationFrame' in window) {
return;
}
window.requestAnimationFrame = window.mozRequestAnimationFrame ||
window.webkitRequestAnimationFrame;
if (window.requestAnimationFrame) {
return;
}
installFakeAnimationFrameFunctions();
})();
(function checkCanvasSizeLimitation() {
if (isIOS || isAndroid) {
PDFJS.maxCanvasPixels = 5242880;
}
})();
(function checkFullscreenSupport() {
if (!hasDOM) {
return;
}
if (isIE && window.parent !== window) {
PDFJS.disableFullscreen = true;
}
})();
(function checkCurrentScript() {
if (!hasDOM) {
return;
}
if ('currentScript' in document) {
return;
}
Object.defineProperty(document, 'currentScript', {
get: function get() {
var scripts = document.getElementsByTagName('script');
return scripts[scripts.length - 1];
},

enumerable: true,
configurable: true
});
})();
(function checkInputTypeNumberAssign() {
if (!hasDOM) {
return;
}
var el = document.createElement('input');
try {
el.type = 'number';
} catch (ex) {
var inputProto = el.constructor.prototype;
var typeProperty = Object.getOwnPropertyDescriptor(inputProto, 'type');
Object.defineProperty(inputProto, 'type', {
get: function get() {
return typeProperty.get.call(this);
},
set: function set(value) {
typeProperty.set.call(this, value === 'number' ? 'text' : value);
},

enumerable: true,
configurable: true
});
}
})();
(function checkDocumentReadyState() {
if (!hasDOM) {
return;
}
if (!document.attachEvent) {
return;
}
var documentProto = document.constructor.prototype;
var readyStateProto = Object.getOwnPropertyDescriptor(documentProto,
'readyState');
Object.defineProperty(documentProto, 'readyState', {
get: function get() {
var value = readyStateProto.get.call(this);
return value === 'interactive' ? 'loading' : value;
},
set: function set(value) {
readyStateProto.set.call(this, value);
},

enumerable: true,
configurable: true
});
})();
(function checkChildNodeRemove() {
if (!hasDOM) {
return;
}
if (typeof Element.prototype.remove !== 'undefined') {
return;
}
Element.prototype.remove = function () {
if (this.parentNode) {
this.parentNode.removeChild(this);
}
};
})();
(function checkNumberIsNaN() {
if (Number.isNaN) {
return;
}
Number.isNaN = function (value) {
return typeof value === 'number' && isNaN(value);
};
})();
(function checkNumberIsInteger() {
if (Number.isInteger) {
return;
}
Number.isInteger = function (value) {
return typeof value === 'number' && isFinite(value) && Math.floor(value) ===
value;
};
})();
(function checkPromise() {
if (globalScope.Promise) {
if (typeof globalScope.Promise.all !== 'function') {
globalScope.Promise.all = function (iterable) {
var count = 0,
results = [],
resolve,
reject;
var promise = new globalScope.Promise(function (resolve_, reject_) {
resolve = resolve_;
reject = reject_;
});
iterable.forEach(function (p, i) {
count++;
p.then(function (result) {
results[i] = result;
count--;
if (count === 0) {
resolve(results);
}
}, reject);
});
if (count === 0) {
resolve(results);
}
return promise;
};
}
if (typeof globalScope.Promise.resolve !== 'function') {
globalScope.Promise.resolve = function (value) {
return new globalScope.Promise(function (resolve) {
resolve(value);
});
};
}
if (typeof globalScope.Promise.reject !== 'function') {
globalScope.Promise.reject = function (reason) {
return new globalScope.Promise(function (resolve, reject) {
reject(reason);
});
};
}
if (typeof globalScope.Promise.prototype.catch !== 'function') {
globalScope.Promise.prototype.catch = function (onReject) {
return globalScope.Promise.prototype.then(undefined, onReject);
};
}
return;
}
var STATUS_PENDING = 0;
var STATUS_RESOLVED = 1;
var STATUS_REJECTED = 2;
var REJECTION_TIMEOUT = 500;
var HandlerManager = {
handlers: [],
running: false,
unhandledRejections: [],
pendingRejectionCheck: false,
scheduleHandlers: function scheduleHandlers(promise) {
if (promise._status === STATUS_PENDING) {
return;
}
this.handlers = this.handlers.concat(promise._handlers);
promise._handlers = [];
if (this.running) {
return;
}
this.running = true;
setTimeout(this.runHandlers.bind(this), 0);
},
runHandlers: function runHandlers() {
var RUN_TIMEOUT = 1;
var timeoutAt = Date.now() + RUN_TIMEOUT;
while (this.handlers.length > 0) {
var handler = this.handlers.shift();
var nextStatus = handler.thisPromise._status;
var nextValue = handler.thisPromise._value;
try {
if (nextStatus === STATUS_RESOLVED) {
if (typeof handler.onResolve === 'function') {
nextValue = handler.onResolve(nextValue);
}
} else if (typeof handler.onReject === 'function') {
nextValue = handler.onReject(nextValue);
nextStatus = STATUS_RESOLVED;
if (handler.thisPromise._unhandledRejection) {
this.removeUnhandeledRejection(handler.thisPromise);
}
}
} catch (ex) {
nextStatus = STATUS_REJECTED;
nextValue = ex;
}
handler.nextPromise._updateStatus(nextStatus, nextValue);
if (Date.now() >= timeoutAt) {
break;
}
}
if (this.handlers.length > 0) {
setTimeout(this.runHandlers.bind(this), 0);
return;
}
this.running = false;
},
addUnhandledRejection: function addUnhandledRejection(promise) {
this.unhandledRejections.push({
promise: promise,
time: Date.now()
});
this.scheduleRejectionCheck();
},
removeUnhandeledRejection: function removeUnhandeledRejection(promise) {
promise._unhandledRejection = false;
for (var i = 0; i < this.unhandledRejections.length; i++) {
if (this.unhandledRejections[i].promise === promise) {
this.unhandledRejections.splice(i);
i--;
}
}
},
scheduleRejectionCheck: function scheduleRejectionCheck() {
var _this = this;

if (this.pendingRejectionCheck) {
return;
}
this.pendingRejectionCheck = true;
setTimeout(function () {
_this.pendingRejectionCheck = false;
var now = Date.now();
for (var i = 0; i < _this.unhandledRejections.length; i++) {
if (now - _this.unhandledRejections[i].time > REJECTION_TIMEOUT) {
var unhandled = _this.unhandledRejections[i].promise._value;
var msg = 'Unhandled rejection: ' + unhandled;
if (unhandled.stack) {
msg += '\n' + unhandled.stack;
}
try {
throw new Error(msg);
} catch (_) {
console.warn(msg);
}
_this.unhandledRejections.splice(i);
i--;
}
}
if (_this.unhandledRejections.length) {
_this.scheduleRejectionCheck();
}
}, REJECTION_TIMEOUT);
}
};
var Promise = function Promise(resolver) {
this._status = STATUS_PENDING;
this._handlers = [];
try {
resolver.call(this, this._resolve.bind(this), this._reject.bind(this));
} catch (e) {
this._reject(e);
}
};
Promise.all = function Promise_all(promises) {
var resolveAll, rejectAll;
var deferred = new Promise(function (resolve, reject) {
resolveAll = resolve;
rejectAll = reject;
});
var unresolved = promises.length;
var results = [];
if (unresolved === 0) {
resolveAll(results);
return deferred;
}
function reject(reason) {
if (deferred._status === STATUS_REJECTED) {
return;
}
results = [];
rejectAll(reason);
}
for (var i = 0, ii = promises.length; i < ii; ++i) {
var promise = promises[i];
var resolve = function (i) {
return function (value) {
if (deferred._status === STATUS_REJECTED) {
return;
}
results[i] = value;
unresolved--;
if (unresolved === 0) {
resolveAll(results);
}
};
}(i);
if (Promise.isPromise(promise)) {
promise.then(resolve, reject);
} else {
resolve(promise);
}
}
return deferred;
};
Promise.isPromise = function Promise_isPromise(value) {
return value && typeof value.then === 'function';
};
Promise.resolve = function Promise_resolve(value) {
return new Promise(function (resolve) {
resolve(value);
});
};
Promise.reject = function Promise_reject(reason) {
return new Promise(function (resolve, reject) {
reject(reason);
});
};
Promise.prototype = {
_status: null,
_value: null,
_handlers: null,
_unhandledRejection: null,
_updateStatus: function Promise__updateStatus(status, value) {
if (this._status === STATUS_RESOLVED || this._status === STATUS_REJECTED) {
return;
}
if (status === STATUS_RESOLVED && Promise.isPromise(value)) {
value.then(this._updateStatus.bind(this, STATUS_RESOLVED),
this._updateStatus.bind(this, STATUS_REJECTED));
return;
}
this._status = status;
this._value = value;
if (status === STATUS_REJECTED && this._handlers.length === 0) {
this._unhandledRejection = true;
HandlerManager.addUnhandledRejection(this);
}
HandlerManager.scheduleHandlers(this);
},
_resolve: function Promise_resolve(value) {
this._updateStatus(STATUS_RESOLVED, value);
},
_reject: function Promise_reject(reason) {
this._updateStatus(STATUS_REJECTED, reason);
},
then: function Promise_then(onResolve, onReject) {
var nextPromise = new Promise(function (resolve, reject) {
this.resolve = resolve;
this.reject = reject;
});
this._handlers.push({
thisPromise: this,
onResolve: onResolve,
onReject: onReject,
nextPromise: nextPromise
});
HandlerManager.scheduleHandlers(this);
return nextPromise;
},
catch: function Promise_catch(onReject) {
return this.then(undefined, onReject);
}
};
globalScope.Promise = Promise;
})();
(function checkWeakMap() {
if (globalScope.WeakMap) {
return;
}
var id = 0;
function WeakMap() {
this.id = '$weakmap' + id++;
}
WeakMap.prototype = {
has: function has(obj) {
if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object'
&& typeof obj !== 'function' || obj === null) {
return false;
}
return !!Object.getOwnPropertyDescriptor(obj, this.id);
},
get: function get(obj) {
return this.has(obj) ? obj[this.id] : undefined;
},
set: function set(obj, value) {
Object.defineProperty(obj, this.id, {
value: value,
enumerable: false,
configurable: true
});
},
delete: function _delete(obj) {
delete obj[this.id];
}
};
globalScope.WeakMap = WeakMap;
})();
(function checkURLConstructor() {
var hasWorkingUrl = false;
try {
if (typeof URL === 'function' && _typeof(URL.prototype) === 'object' &&
'origin' in URL.prototype) {
var u = new URL('b', 'http://a');
u.pathname = 'c%20d';
hasWorkingUrl = u.href === 'http://a/c%20d';
}
} catch (e) {}
if (hasWorkingUrl) {
return;
}
var relative = Object.create(null);
relative['ftp'] = 21;
relative['file'] = 0;
relative['gopher'] = 70;
relative['http'] = 80;
relative['https'] = 443;
relative['ws'] = 80;
relative['wss'] = 443;
var relativePathDotMapping = Object.create(null);
relativePathDotMapping['%2e'] = '.';
relativePathDotMapping['.%2e'] = '..';
relativePathDotMapping['%2e.'] = '..';
relativePathDotMapping['%2e%2e'] = '..';
function isRelativeScheme(scheme) {
return relative[scheme] !== undefined;
}
function invalid() {
clear.call(this);
this._isInvalid = true;
}
function IDNAToASCII(h) {
if (h === '') {
invalid.call(this);
}
return h.toLowerCase();
}
function percentEscape(c) {
var unicode = c.charCodeAt(0);
if (unicode > 0x20 && unicode < 0x7F && [0x22, 0x23, 0x3C, 0x3E, 0x3F,
0x60].indexOf(unicode) === -1) {
return c;
}
return encodeURIComponent(c);
}
function percentEscapeQuery(c) {
var unicode = c.charCodeAt(0);
if (unicode > 0x20 && unicode < 0x7F && [0x22, 0x23, 0x3C, 0x3E,
0x60].indexOf(unicode) === -1) {
return c;
}
return encodeURIComponent(c);
}
var EOF,
ALPHA = /[a-zA-Z]/,
ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;
function parse(input, stateOverride, base) {
function err(message) {
errors.push(message);
}
var state = stateOverride || 'scheme start',
cursor = 0,
buffer = '',
seenAt = false,
seenBracket = false,
errors = [];
loop: while ((input[cursor - 1] !== EOF || cursor === 0) && !this._isInvalid)
{
var c = input[cursor];
switch (state) {
case 'scheme start':
if (c && ALPHA.test(c)) {
buffer += c.toLowerCase();
state = 'scheme';
} else if (!stateOverride) {
buffer = '';
state = 'no scheme';
continue;
} else {
err('Invalid scheme.');
break loop;
}
break;
case 'scheme':
if (c && ALPHANUMERIC.test(c)) {
buffer += c.toLowerCase();
} else if (c === ':') {
this._scheme = buffer;
buffer = '';
if (stateOverride) {
break loop;
}
if (isRelativeScheme(this._scheme)) {
this._isRelative = true;
}
if (this._scheme === 'file') {
state = 'relative';
} else if (this._isRelative && base && base._scheme === this._scheme)
{
state = 'relative or authority';
} else if (this._isRelative) {
state = 'authority first slash';
} else {
state = 'scheme data';
}
} else if (!stateOverride) {
buffer = '';
cursor = 0;
state = 'no scheme';
continue;
} else if (c === EOF) {
break loop;
} else {
err('Code point not allowed in scheme: ' + c);
break loop;
}
break;
case 'scheme data':
if (c === '?') {
this._query = '?';
state = 'query';
} else if (c === '#') {
this._fragment = '#';
state = 'fragment';
} else {
if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
this._schemeData += percentEscape(c);
}
}
break;
case 'no scheme':
if (!base || !isRelativeScheme(base._scheme)) {
err('Missing scheme.');
invalid.call(this);
} else {
state = 'relative';
continue;
}
break;
case 'relative or authority':
if (c === '/' && input[cursor + 1] === '/') {
state = 'authority ignore slashes';
} else {
err('Expected /, got: ' + c);
state = 'relative';
continue;
}
break;
case 'relative':
this._isRelative = true;
if (this._scheme !== 'file') {
this._scheme = base._scheme;
}
if (c === EOF) {
this._host = base._host;
this._port = base._port;
this._path = base._path.slice();
this._query = base._query;
this._username = base._username;
this._password = base._password;
break loop;
} else if (c === '/' || c === '\\') {
if (c === '\\') {
err('\\ is an invalid code point.');
}
state = 'relative slash';
} else if (c === '?') {
this._host = base._host;
this._port = base._port;
this._path = base._path.slice();
this._query = '?';
this._username = base._username;
this._password = base._password;
state = 'query';
} else if (c === '#') {
this._host = base._host;
this._port = base._port;
this._path = base._path.slice();
this._query = base._query;
this._fragment = '#';
this._username = base._username;
this._password = base._password;
state = 'fragment';
} else {
var nextC = input[cursor + 1];
var nextNextC = input[cursor + 2];
if (this._scheme !== 'file' || !ALPHA.test(c) || nextC !== ':' &&
nextC !== '|' || nextNextC !== EOF && nextNextC !== '/' && nextNextC !== '\\' &&
nextNextC !== '?' && nextNextC !== '#') {
this._host = base._host;
this._port = base._port;
this._username = base._username;
this._password = base._password;
this._path = base._path.slice();
this._path.pop();
}
state = 'relative path';
continue;
}
break;
case 'relative slash':
if (c === '/' || c === '\\') {
if (c === '\\') {
err('\\ is an invalid code point.');
}
if (this._scheme === 'file') {
state = 'file host';
} else {
state = 'authority ignore slashes';
}
} else {
if (this._scheme !== 'file') {
this._host = base._host;
this._port = base._port;
this._username = base._username;
this._password = base._password;
}
state = 'relative path';
continue;
}
break;
case 'authority first slash':
if (c === '/') {
state = 'authority second slash';
} else {
err('Expected \'/\', got: ' + c);
state = 'authority ignore slashes';
continue;
}
break;
case 'authority second slash':
state = 'authority ignore slashes';
if (c !== '/') {
err('Expected \'/\', got: ' + c);
continue;
}
break;
case 'authority ignore slashes':
if (c !== '/' && c !== '\\') {
state = 'authority';
continue;
} else {
err('Expected authority, got: ' + c);
}
break;
case 'authority':
if (c === '@') {
if (seenAt) {
err('@ already seen.');
buffer += '%40';
}
seenAt = true;
for (var i = 0; i < buffer.length; i++) {
var cp = buffer[i];
if (cp === '\t' || cp === '\n' || cp === '\r') {
err('Invalid whitespace in authority.');
continue;
}
if (cp === ':' && this._password === null) {
this._password = '';
continue;
}
var tempC = percentEscape(cp);
if (this._password !== null) {
this._password += tempC;
} else {
this._username += tempC;
}
}
buffer = '';
} else if (c === EOF || c === '/' || c === '\\' || c === '?' || c ===
'#') {
cursor -= buffer.length;
buffer = '';
state = 'host';
continue;
} else {
buffer += c;
}
break;
case 'file host':
if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
if (buffer.length === 2 && ALPHA.test(buffer[0]) && (buffer[1] ===
':' || buffer[1] === '|')) {
state = 'relative path';
} else if (buffer.length === 0) {
state = 'relative path start';
} else {
this._host = IDNAToASCII.call(this, buffer);
buffer = '';
state = 'relative path start';
}
continue;
} else if (c === '\t' || c === '\n' || c === '\r') {
err('Invalid whitespace in file host.');
} else {
buffer += c;
}
break;
case 'host':
case 'hostname':
if (c === ':' && !seenBracket) {
this._host = IDNAToASCII.call(this, buffer);
buffer = '';
state = 'port';
if (stateOverride === 'hostname') {
break loop;
}
} else if (c === EOF || c === '/' || c === '\\' || c === '?' || c ===
'#') {
this._host = IDNAToASCII.call(this, buffer);
buffer = '';
state = 'relative path start';
if (stateOverride) {
break loop;
}
continue;
} else if (c !== '\t' && c !== '\n' && c !== '\r') {
if (c === '[') {
seenBracket = true;
} else if (c === ']') {
seenBracket = false;
}
buffer += c;
} else {
err('Invalid code point in host/hostname: ' + c);
}
break;
case 'port':
if (/[0-9]/.test(c)) {
buffer += c;
} else if (c === EOF || c === '/' || c === '\\' || c === '?' || c ===
'#' || stateOverride) {
if (buffer !== '') {
var temp = parseInt(buffer, 10);
if (temp !== relative[this._scheme]) {
this._port = temp + '';
}
buffer = '';
}
if (stateOverride) {
break loop;
}
state = 'relative path start';
continue;
} else if (c === '\t' || c === '\n' || c === '\r') {
err('Invalid code point in port: ' + c);
} else {
invalid.call(this);
}
break;
case 'relative path start':
if (c === '\\') {
err('\'\\\' not allowed in path.');
}
state = 'relative path';
if (c !== '/' && c !== '\\') {
continue;
}
break;
case 'relative path':
if (c === EOF || c === '/' || c === '\\' || !stateOverride && (c ===
'?' || c === '#')) {
if (c === '\\') {
err('\\ not allowed in relative path.');
}
var tmp;
if (tmp = relativePathDotMapping[buffer.toLowerCase()]) {
buffer = tmp;
}
if (buffer === '..') {
this._path.pop();
if (c !== '/' && c !== '\\') {
this._path.push('');
}
} else if (buffer === '.' && c !== '/' && c !== '\\') {
this._path.push('');
} else if (buffer !== '.') {
if (this._scheme === 'file' && this._path.length === 0 &&
buffer.length === 2 && ALPHA.test(buffer[0]) && buffer[1] === '|') {
buffer = buffer[0] + ':';
}
this._path.push(buffer);
}
buffer = '';
if (c === '?') {
this._query = '?';
state = 'query';
} else if (c === '#') {
this._fragment = '#';
state = 'fragment';
}
} else if (c !== '\t' && c !== '\n' && c !== '\r') {
buffer += percentEscape(c);
}
break;
case 'query':
if (!stateOverride && c === '#') {
this._fragment = '#';
state = 'fragment';
} else if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
this._query += percentEscapeQuery(c);
}
break;
case 'fragment':
if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
this._fragment += c;
}
break;
}
cursor++;
}
}
function clear() {
this._scheme = '';
this._schemeData = '';
this._username = '';
this._password = null;
this._host = '';
this._port = '';
this._path = [];
this._query = '';
this._fragment = '';
this._isInvalid = false;
this._isRelative = false;
}
function JURL(url, base) {
if (base !== undefined && !(base instanceof JURL)) {
base = new JURL(String(base));
}
this._url = url;
clear.call(this);
var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, '');
parse.call(this, input, null, base);
}
JURL.prototype = {
toString: function toString() {
return this.href;
},

get href() {
if (this._isInvalid) {
return this._url;
}
var authority = '';
if (this._username !== '' || this._password !== null) {
authority = this._username + (this._password !== null ? ':' +
this._password : '') + '@';
}
return this.protocol + (this._isRelative ? '//' + authority + this.host :
'') + this.pathname + this._query + this._fragment;
},
set href(value) {
clear.call(this);
parse.call(this, value);
},
get protocol() {
return this._scheme + ':';
},
set protocol(value) {
if (this._isInvalid) {
return;
}
parse.call(this, value + ':', 'scheme start');
},
get host() {
return this._isInvalid ? '' : this._port ? this._host + ':' + this._port :
this._host;
},
set host(value) {
if (this._isInvalid || !this._isRelative) {
return;
}
parse.call(this, value, 'host');
},
get hostname() {
return this._host;
},
set hostname(value) {
if (this._isInvalid || !this._isRelative) {
return;
}
parse.call(this, value, 'hostname');
},
get port() {
return this._port;
},
set port(value) {
if (this._isInvalid || !this._isRelative) {
return;
}
parse.call(this, value, 'port');
},
get pathname() {
return this._isInvalid ? '' : this._isRelative ? '/' + this._path.join('/')
: this._schemeData;
},
set pathname(value) {
if (this._isInvalid || !this._isRelative) {
return;
}
this._path = [];
parse.call(this, value, 'relative path start');
},
get search() {
return this._isInvalid || !this._query || this._query === '?' ? '' :
this._query;
},
set search(value) {
if (this._isInvalid || !this._isRelative) {
return;
}
this._query = '?';
if (value[0] === '?') {
value = value.slice(1);
}
parse.call(this, value, 'query');
},
get hash() {
return this._isInvalid || !this._fragment || this._fragment === '#' ? '' :
this._fragment;
},
set hash(value) {
if (this._isInvalid) {
return;
}
this._fragment = '#';
if (value[0] === '#') {
value = value.slice(1);
}
parse.call(this, value, 'fragment');
},
get origin() {
var host;
if (this._isInvalid || !this._scheme) {
return '';
}
switch (this._scheme) {
case 'data':
case 'file':
case 'javascript':
case 'mailto':
return 'null';
case 'blob':
try {
return new JURL(this._schemeData).origin || 'null';
} catch (_) {}
return 'null';
}
host = this.host;
if (!host) {
return '';
}
return this._scheme + '://' + host;
}
};
var OriginalURL = globalScope.URL;
if (OriginalURL) {
JURL.createObjectURL = function (blob) {
return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
};
JURL.revokeObjectURL = function (url) {
OriginalURL.revokeObjectURL(url);
};
}
globalScope.URL = JURL;
})();
}

/***/ }),
/* 17 */
/***/ (function(module, exports, __w_pdfjs_require__) {

"use strict";

var isReadableStreamSupported = false;

if (typeof ReadableStream !== 'undefined') {
try {
new ReadableStream({
start: function start(controller) {
controller.close();
}
});
isReadableStreamSupported = true;
} catch (e) {}
}
if (isReadableStreamSupported) {
exports.ReadableStream = ReadableStream;
} else {
exports.ReadableStream = __w_pdfjs_require__(10).ReadableStream;
}

/***/ })
/******/ ]);
});
//# sourceMappingURL=pdf.js.map

Mod 1_BEC515D - Satellite and Optical Communication
No ratings yet
Mod 1_BEC515D - Satellite and Optical Communication
117 pages
Omsdk Session Client(1) 5
No ratings yet
Omsdk Session Client(1) 5
85 pages
Podofo
No ratings yet
Podofo
580 pages
react-pdf - npm-1
No ratings yet
react-pdf - npm-1
563 pages
Sofimsha: Import and Export of Finite Elements
No ratings yet
Sofimsha: Import and Export of Finite Elements
131 pages
Omsdk Session Client
No ratings yet
Omsdk Session Client
32 pages
PDF
No ratings yet
PDF
621 pages
Iit Jee Model Paper 4
67% (3)
Iit Jee Model Paper 4
14 pages
pdf worker min
No ratings yet
pdf worker min
162 pages
Yarn Lock
No ratings yet
Yarn Lock
111 pages
Elementary Surveying An Introduction To Geomatics 14th Edition Ghilani Solutions Manualinstant download
100% (4)
Elementary Surveying An Introduction To Geomatics 14th Edition Ghilani Solutions Manualinstant download
39 pages
Ilustradores 2012
No ratings yet
Ilustradores 2012
156 pages
Podofo
No ratings yet
Podofo
602 pages
WWW Academia Edu 7630500 Obligations and Contracts Reviewer
No ratings yet
WWW Academia Edu 7630500 Obligations and Contracts Reviewer
52 pages
PDF
No ratings yet
PDF
18 pages
Physics-GettingStartedGuide For Small Basic
No ratings yet
Physics-GettingStartedGuide For Small Basic
64 pages
La Industria Alimentaria en El Perú
No ratings yet
La Industria Alimentaria en El Perú
197 pages
Unity Ads Web App
No ratings yet
Unity Ads Web App
555 pages
Unit 5 Dom
No ratings yet
Unit 5 Dom
17 pages
Hyperref
No ratings yet
Hyperref
63 pages
01-Creating Nx Workspace With Eslint
No ratings yet
01-Creating Nx Workspace With Eslint
12 pages
PDF-LIB Create and Modify PDF Documents in Any JavaScript Environment
No ratings yet
PDF-LIB Create and Modify PDF Documents in Any JavaScript Environment
21 pages
Robot Configurations
No ratings yet
Robot Configurations
12 pages
xhtml2pdf Documentation: Release 0.1b3
No ratings yet
xhtml2pdf Documentation: Release 0.1b3
33 pages
PyX Manual
No ratings yet
PyX Manual
107 pages
Guia Alem 82
No ratings yet
Guia Alem 82
108 pages
1 Science Revision G5 (Topic 7)
No ratings yet
1 Science Revision G5 (Topic 7)
11 pages
gödel universe
No ratings yet
gödel universe
7 pages
Processo de Sopro
No ratings yet
Processo de Sopro
14 pages
main.587adb64.js.LICENSE
No ratings yet
main.587adb64.js.LICENSE
5 pages
{ddx
No ratings yet
{ddx
4 pages
1.2 Strain
No ratings yet
1.2 Strain
27 pages
Scenario Editor
No ratings yet
Scenario Editor
16 pages
410-Geometric Methods and Formulations in Computational Multibody System Dynamics
No ratings yet
410-Geometric Methods and Formulations in Computational Multibody System Dynamics
24 pages
G6 Science PT Q4
No ratings yet
G6 Science PT Q4
12 pages
FPC Unit 8r Key
No ratings yet
FPC Unit 8r Key
2 pages
Code Hs
No ratings yet
Code Hs
24 pages
Vendor Bundle Js LICENSE
No ratings yet
Vendor Bundle Js LICENSE
2 pages
const downloadReport = async () =
No ratings yet
const downloadReport = async () =
2 pages
Package
No ratings yet
Package
2 pages
Mathematical-Basics-of-Motion-and-Deformation-in-Computer-Graphics-Second-Edition
No ratings yet
Mathematical-Basics-of-Motion-and-Deformation-in-Computer-Graphics-Second-Edition
82 pages
Referências Bibliográficas
No ratings yet
Referências Bibliográficas
4 pages
Precession of The Earth
No ratings yet
Precession of The Earth
3 pages
This Little-Known PDF Parsing Library Will Save Enterprises Millions by Michael Ryaboy Jun, 2025
No ratings yet
This Little-Known PDF Parsing Library Will Save Enterprises Millions by Michael Ryaboy Jun, 2025
1 page
Cavidade Cavidade: 1,5 A 2,0 X Esp. Parison
No ratings yet
Cavidade Cavidade: 1,5 A 2,0 X Esp. Parison
2 pages
5 Axis Machines
No ratings yet
5 Axis Machines
33 pages
Formula Sheet Trig Identities
No ratings yet
Formula Sheet Trig Identities
1 page
афв
No ratings yet
афв
28 pages
Rot 3 D
No ratings yet
Rot 3 D
5 pages
(2013) Air Platforms and Missile Modeling With Six Degrees of Freedom in Air Defense Simulations
No ratings yet
(2013) Air Platforms and Missile Modeling With Six Degrees of Freedom in Air Defense Simulations
11 pages
Post processor CNI_eng
No ratings yet
Post processor CNI_eng
52 pages
LEP 1.3.31 Moment of Inertia and Torsional Vibrations: Related Topics Problems
No ratings yet
LEP 1.3.31 Moment of Inertia and Torsional Vibrations: Related Topics Problems
3 pages
Activity 1: Roll and Drop Toilet Paper!
No ratings yet
Activity 1: Roll and Drop Toilet Paper!
2 pages
XI Trigonometry Assignment
67% (3)
XI Trigonometry Assignment
1 page
Omsdk Session Client
No ratings yet
Omsdk Session Client
18 pages
SolidWorks Standalone Evaluation Instructions
No ratings yet
SolidWorks Standalone Evaluation Instructions
1 page
Sst class 8 worksheet
No ratings yet
Sst class 8 worksheet
29 pages
Group 2 Lab Report (Centrifugal Force)
No ratings yet
Group 2 Lab Report (Centrifugal Force)
12 pages
Catia v5 Assembly Design
100% (16)
Catia v5 Assembly Design
77 pages
Civil Engineering Design (1) : Analysis and Design of Slabs
83% (6)
Civil Engineering Design (1) : Analysis and Design of Slabs
40 pages
18ME53 B Scheme and Solution 20221
No ratings yet
18ME53 B Scheme and Solution 20221
19 pages
Wind Turbine Final
No ratings yet
Wind Turbine Final
5 pages
The Art of WebAssembly: Build Secure, Portable, High-Performance Applications
From Everand
The Art of WebAssembly: Build Secure, Portable, High-Performance Applications
Rick Battagline
No ratings yet
Angular Routing: Everything you need to know
From Everand
Angular Routing: Everything you need to know
Abdelfattah Ragab
No ratings yet
Python World War : Programming Fundamentals For Students: Python World war : programming Fundamentals series, #1
From Everand
Python World War : Programming Fundamentals For Students: Python World war : programming Fundamentals series, #1
Mahdjoubi Zineddine
No ratings yet
Visual Basic 6.0 Programming By Examples: 7 Windows Application Examples
From Everand
Visual Basic 6.0 Programming By Examples: 7 Windows Application Examples
Sergey Skudaev
3/5 (2)
Angular Portfolio App Development: Create your personal brand
From Everand
Angular Portfolio App Development: Create your personal brand
Abdelfattah Ragab
No ratings yet
NgRx SignalStore: An effortless solution for state management
From Everand
NgRx SignalStore: An effortless solution for state management
Abdelfattah Ragab
No ratings yet
Angular Shopping Store: From Scratch to Successful Payment
From Everand
Angular Shopping Store: From Scratch to Successful Payment
Abdelfattah Ragab
No ratings yet
Software Design Simplified
From Everand
Software Design Simplified
Liviu Catalin Dorobantu
No ratings yet
React Portfolio App Development: Increase your online presence and create your personal brand
From Everand
React Portfolio App Development: Increase your online presence and create your personal brand
Abdelfattah Ragab
No ratings yet
MCTS 70-515 Exam: Web Applications Development with Microsoft .NET Framework 4 (Exam Prep)
From Everand
MCTS 70-515 Exam: Web Applications Development with Microsoft .NET Framework 4 (Exam Prep)
Eddie Vi
4/5 (1)
Mastering Node.js Web Development: Go on a comprehensive journey from the fundamentals to advanced web development with Node.js
From Everand
Mastering Node.js Web Development: Go on a comprehensive journey from the fundamentals to advanced web development with Node.js
Adam Freeman
No ratings yet
JavaScript Patterns JumpStart Guide (Clean up your JavaScript Code)
From Everand
JavaScript Patterns JumpStart Guide (Clean up your JavaScript Code)
Dan Wahlin
4.5/5 (3)
Fresher PyQt5: A Beginner’s Guide to PyQt5
From Everand
Fresher PyQt5: A Beginner’s Guide to PyQt5
Edward Chang
No ratings yet
How to a Developers Guide in 4k: Developer edition, #2
From Everand
How to a Developers Guide in 4k: Developer edition, #2
Xinc Cyberwizard
No ratings yet
Stripe Integration in Angular: A Step-by-Step Guide to Creating Payment Functionality
From Everand
Stripe Integration in Angular: A Step-by-Step Guide to Creating Payment Functionality
Abdelfattah Ragab
No ratings yet
Understanding Software Engineering Vol 3: Programming Basic Software Functionalities.
From Everand
Understanding Software Engineering Vol 3: Programming Basic Software Functionalities.
Gabriel Clemente
No ratings yet
Pyqt6 101: A Beginner’s Guide to PyQt6
From Everand
Pyqt6 101: A Beginner’s Guide to PyQt6
Edward Chang
No ratings yet
Python-Deprecated Library v1.1 Documentation
From Everand
Python-Deprecated Library v1.1 Documentation
Laurent LAPORTE
No ratings yet
Core Java Programming Book
From Everand
Core Java Programming Book
Manish Soni
No ratings yet
PHP Package Mastery: 100 Essential Tools in One Hour - 2024 Edition
From Everand
PHP Package Mastery: 100 Essential Tools in One Hour - 2024 Edition
Kanto
No ratings yet
Introduction to PHP, Part 5, Second Edition
From Everand
Introduction to PHP, Part 5, Second Edition
Adam Majczak
No ratings yet
Introduction to PHP, Part 4, Second Edition
From Everand
Introduction to PHP, Part 4, Second Edition
Adam Majczak
No ratings yet
Stranger on the Plane
From Everand
Stranger on the Plane
Janet Garber
No ratings yet
50 Recipes for Programming Node.js
From Everand
50 Recipes for Programming Node.js
Jamie Munro
3/5 (4)
Microsoft Visual Basic Interview Questions: Microsoft VB Certification Review
From Everand
Microsoft Visual Basic Interview Questions: Microsoft VB Certification Review
Equity Press
No ratings yet
Python Advanced Programming: The Guide to Learn Python Programming. Reference with Exercises and Samples About Dynamical Programming, Multithreading, Multiprocessing, Debugging, Testing and More
From Everand
Python Advanced Programming: The Guide to Learn Python Programming. Reference with Exercises and Samples About Dynamical Programming, Multithreading, Multiprocessing, Debugging, Testing and More
Marcus Richards
No ratings yet
Spring Boot Intermediate Microservices: Resilient Microservices with Spring Boot 2 and Spring Cloud
From Everand
Spring Boot Intermediate Microservices: Resilient Microservices with Spring Boot 2 and Spring Cloud
Jens Boje
No ratings yet
Build your own Blockchain: Make your own blockchain and trading bot on your pc
From Everand
Build your own Blockchain: Make your own blockchain and trading bot on your pc
Magelan Cybersecurity
No ratings yet
150+ C Pattern Programs
From Everand
150+ C Pattern Programs
Hernando Abella
No ratings yet
How to a Developers Guide to 4k: Developer edition, #3
From Everand
How to a Developers Guide to 4k: Developer edition, #3
Xinc Cyberwizard
No ratings yet
Some Tutorials in Computer Networking Hacking
From Everand
Some Tutorials in Computer Networking Hacking
Dr. Hidaia Mahmood Alassouli
No ratings yet
Computer Engineering Laboratory Solution Primer
From Everand
Computer Engineering Laboratory Solution Primer
Karan Bhandari
No ratings yet