// Use strict in our context only - users might not want it

'use strict';

'use strict';

var globalScope = (typeof window === 'undefined') ? this : window;

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

var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];

var TextRenderingMode = {

FILL: 0,

STROKE: 1,

FILL_STROKE: 2,

INVISIBLE: 3,

FILL_ADD_TO_PATH: 4,

STROKE_ADD_TO_PATH: 5,

FILL_STROKE_ADD_TO_PATH: 6,

ADD_TO_PATH: 7,

FILL_STROKE_MASK: 3,

ADD_TO_PATH_FLAG: 4

};

var ImageKind = {

GRAYSCALE_1BPP: 1,

RGB_24BPP: 2,

RGBA_32BPP: 3

};

if (!globalScope.PDFJS) {

globalScope.PDFJS = {};

}

globalScope.PDFJS.pdfBug = false;

PDFJS.VERBOSITY_LEVELS = {

errors: 0,

warnings: 1,

infos: 5

};

var OPS = PDFJS.OPS = {

// Intentionally start from 1 so it is easy to spot bad operators that will be

// 0's.

dependency: 1,

setLineWidth: 2,

setLineCap: 3,

setLineJoin: 4,

setMiterLimit: 5,

setDash: 6,

setRenderingIntent: 7,

setFlatness: 8,

setGState: 9,

save: 10,

restore: 11,

transform: 12,

moveTo: 13,

lineTo: 14,

curveTo: 15,

curveTo2: 16,

curveTo3: 17,

closePath: 18,

rectangle: 19,

stroke: 20,

closeStroke: 21,

fill: 22,

eoFill: 23,

fillStroke: 24,

eoFillStroke: 25,

closeFillStroke: 26,

closeEOFillStroke: 27,

endPath: 28,

clip: 29,

eoClip: 30,

beginText: 31,

endText: 32,

setCharSpacing: 33,

setWordSpacing: 34,

setHScale: 35,

setLeading: 36,

setFont: 37,

setTextRenderingMode: 38,

setTextRise: 39,

moveText: 40,

setLeadingMoveText: 41,

setTextMatrix: 42,

nextLine: 43,

showText: 44,

showSpacedText: 45,

nextLineShowText: 46,

nextLineSetSpacingShowText: 47,

setCharWidth: 48,

setCharWidthAndBounds: 49,

setStrokeColorSpace: 50,

setFillColorSpace: 51,

setStrokeColor: 52,

setStrokeColorN: 53,

setFillColor: 54,

setFillColorN: 55,

setStrokeGray: 56,

setFillGray: 57,

setStrokeRGBColor: 58,

setFillRGBColor: 59,

setStrokeCMYKColor: 60,

setFillCMYKColor: 61,

shadingFill: 62,

beginInlineImage: 63,

beginImageData: 64,

endInlineImage: 65,

paintXObject: 66,

markPoint: 67,

markPointProps: 68,

beginMarkedContent: 69,

beginMarkedContentProps: 70,

endMarkedContent: 71,

beginCompat: 72,

endCompat: 73,

paintFormXObjectBegin: 74,

paintFormXObjectEnd: 75,

beginGroup: 76,

endGroup: 77,

beginAnnotations: 78,

endAnnotations: 79,

beginAnnotation: 80,

endAnnotation: 81,

paintJpegXObject: 82,

paintImageMaskXObject: 83,

paintImageMaskXObjectGroup: 84,

paintImageXObject: 85,

paintInlineImageXObject: 86,

paintInlineImageXObjectGroup: 87,

paintImageXObjectRepeat: 88,

paintImageMaskXObjectRepeat: 89,

paintSolidColorImageMask: 90

};

function info(msg) {

if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) {

console.log('Info: ' + msg);

}

}

function warn(msg) {

if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) {

console.log('Warning: ' + msg);

}

}

function error(msg) {

// If multiple arguments were passed, pass them all to the log function.

if (arguments.length > 1) {

var logArguments = ['Error:'];

logArguments.push.apply(logArguments, arguments);

console.log.apply(console, logArguments);

// Join the arguments into a single string for the lines below.

msg = [].join.call(arguments, ' ');

} else {

console.log('Error: ' + msg);

}

console.log(backtrace());

UnsupportedManager.notify(UNSUPPORTED_FEATURES.unknown);

throw new Error(msg);

}

function backtrace() {

try {

throw new Error();

} catch (e) {

return e.stack ? e.stack.split('\n').slice(2).join('\n') : '';

}

}

function assert(cond, msg) {

if (!cond) {

error(msg);

}

}

var UNSUPPORTED_FEATURES = PDFJS.UNSUPPORTED_FEATURES = {

unknown: 'unknown',

forms: 'forms',

javaScript: 'javaScript',

smask: 'smask',

shadingPattern: 'shadingPattern',

font: 'font'

};

var UnsupportedManager = PDFJS.UnsupportedManager =

(function UnsupportedManagerClosure() {

var listeners = [];

return {

listen: function (cb) {

listeners.push(cb);

},

notify: function (featureId) {

warn('Unsupported feature "' + featureId + '"');

for (var i = 0, ii = listeners.length; i < ii; i++) {

listeners[i](featureId);

}

}

};

})();

function combineUrl(baseUrl, url) {

if (!url) {

return baseUrl;

}

if (/^[a-z][a-z0-9+\-.]*:/i.test(url)) {

return url;

}

var i;

if (url.charAt(0) == '/') {

// absolute path

i = baseUrl.indexOf('://');

if (url.charAt(1) === '/') {

++i;

} else {

i = baseUrl.indexOf('/', i + 3);

}

return baseUrl.substring(0, i) + url;

} else {

// relative path

var pathLength = baseUrl.length;

i = baseUrl.lastIndexOf('#');

pathLength = i >= 0 ? i : pathLength;

i = baseUrl.lastIndexOf('?', pathLength);

pathLength = i >= 0 ? i : pathLength;

var prefixLength = baseUrl.lastIndexOf('/', pathLength);

return baseUrl.substring(0, prefixLength + 1) + url;

}

}

function isValidUrl(url, allowRelative) {

if (!url) {

return false;

}

// RFC 3986 (http://tools.ietf.org/html/rfc3986#section-3.1)

// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

var protocol = /^[a-z][a-z0-9+\-.]*(?=:)/i.exec(url);

if (!protocol) {

return allowRelative;

}

protocol = protocol[0].toLowerCase();

switch (protocol) {

case 'http':

case 'https':

case 'ftp':

case 'mailto':

return true;

default:

return false;

}

}

PDFJS.isValidUrl = isValidUrl;

function shadow(obj, prop, value) {

Object.defineProperty(obj, prop, { value: value,

enumerable: true,

configurable: true,

writable: false });

return value;

}

var PasswordResponses = PDFJS.PasswordResponses = {

NEED_PASSWORD: 1,

INCORRECT_PASSWORD: 2

};

var PasswordException = (function PasswordExceptionClosure() {

function PasswordException(msg, code) {

this.name = 'PasswordException';

this.message = msg;

this.code = code;

}

PasswordException.prototype = new Error();

PasswordException.constructor = PasswordException;

return PasswordException;

})();

var UnknownErrorException = (function UnknownErrorExceptionClosure() {

function UnknownErrorException(msg, details) {

this.name = 'UnknownErrorException';

this.message = msg;

this.details = details;

}

UnknownErrorException.prototype = new Error();

UnknownErrorException.constructor = UnknownErrorException;

return UnknownErrorException;

})();

var InvalidPDFException = (function InvalidPDFExceptionClosure() {

function InvalidPDFException(msg) {

this.name = 'InvalidPDFException';

this.message = msg;

}

InvalidPDFException.prototype = new Error();

InvalidPDFException.constructor = InvalidPDFException;

return InvalidPDFException;

})();

var MissingPDFException = (function MissingPDFExceptionClosure() {

function MissingPDFException(msg) {

this.name = 'MissingPDFException';

this.message = msg;

}

MissingPDFException.prototype = new Error();

MissingPDFException.constructor = MissingPDFException;

return MissingPDFException;

})();

var NotImplementedException = (function NotImplementedExceptionClosure() {

function NotImplementedException(msg) {

this.message = msg;

}

NotImplementedException.prototype = new Error();

NotImplementedException.prototype.name = 'NotImplementedException';

NotImplementedException.constructor = NotImplementedException;

return NotImplementedException;

})();

var MissingDataException = (function MissingDataExceptionClosure() {

function MissingDataException(begin, end) {

this.begin = begin;

this.end = end;

this.message = 'Missing data [' + begin + ', ' + end + ')';

}

MissingDataException.prototype = new Error();

MissingDataException.prototype.name = 'MissingDataException';

MissingDataException.constructor = MissingDataException;

return MissingDataException;

})();

var XRefParseException = (function XRefParseExceptionClosure() {

function XRefParseException(msg) {

this.message = msg;

}

XRefParseException.prototype = new Error();

XRefParseException.prototype.name = 'XRefParseException';

XRefParseException.constructor = XRefParseException;

return XRefParseException;

})();

function bytesToString(bytes) {

var length = bytes.length;

var MAX_ARGUMENT_COUNT = 8192;

if (length < MAX_ARGUMENT_COUNT) {

return String.fromCharCode.apply(null, bytes);

}

var strBuf = [];

for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {

var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);

var chunk = bytes.subarray(i, chunkEnd);

strBuf.push(String.fromCharCode.apply(null, chunk));

}

return strBuf.join('');

}

function stringToArray(str) {

var length = str.length;

var array = [];

for (var i = 0; i < length; ++i) {

array[i] = str.charCodeAt(i);

}

return array;

}

function stringToBytes(str) {

var length = str.length;

var bytes = new Uint8Array(length);

for (var i = 0; i < length; ++i) {

bytes[i] = str.charCodeAt(i) & 0xFF;

}

return bytes;

}

function string32(value) {

return String.fromCharCode((value >> 24) & 0xff, (value >> 16) & 0xff,

(value >> 8) & 0xff, value & 0xff);

}

function log2(x) {

var n = 1, i = 0;

while (x > n) {

n <<= 1;

i++;

}

return i;

}

function readInt8(data, start) {

return (data[start] << 24) >> 24;

}

function readUint16(data, offset) {

return (data[offset] << 8) | data[offset + 1];

}

function readUint32(data, offset) {

return ((data[offset] << 24) | (data[offset + 1] << 16) |

(data[offset + 2] << 8) | data[offset + 3]) >>> 0;

}

function isLittleEndian() {

var buffer8 = new Uint8Array(2);

buffer8[0] = 1;

var buffer16 = new Uint16Array(buffer8.buffer);

return (buffer16[0] === 1);

}

Object.defineProperty(PDFJS, 'isLittleEndian', {

configurable: true,

get: function PDFJS_isLittleEndian() {

return shadow(PDFJS, 'isLittleEndian', isLittleEndian());

}

});

// Lazy test if the userAgant support CanvasTypedArrays

function hasCanvasTypedArrays() {

var canvas = document.createElement('canvas');

canvas.width = canvas.height = 1;

var ctx = canvas.getContext('2d');

var imageData = ctx.createImageData(1, 1);

return (typeof imageData.data.buffer !== 'undefined');

}

Object.defineProperty(PDFJS, 'hasCanvasTypedArrays', {

configurable: true,

get: function PDFJS_hasCanvasTypedArrays() {

return shadow(PDFJS, 'hasCanvasTypedArrays', hasCanvasTypedArrays());

}

});

var Uint32ArrayView = (function Uint32ArrayViewClosure() {

function Uint32ArrayView(buffer, length) {

this.buffer = buffer;

this.byteLength = buffer.length;

this.length = length === undefined ? (this.byteLength >> 2) : length;

ensureUint32ArrayViewProps(this.length);

}

Uint32ArrayView.prototype = Object.create(null);

var uint32ArrayViewSetters = 0;

function createUint32ArrayProp(index) {

return {

get: function () {

var buffer = this.buffer, offset = index << 2;

return (buffer[offset] | (buffer[offset + 1] << 8) |

(buffer[offset + 2] << 16) | (buffer[offset + 3] << 24)) >>> 0;

},

set: function (value) {

var buffer = this.buffer, offset = index << 2;

buffer[offset] = value & 255;

buffer[offset + 1] = (value >> 8) & 255;

buffer[offset + 2] = (value >> 16) & 255;

buffer[offset + 3] = (value >>> 24) & 255;

}

};

}

function ensureUint32ArrayViewProps(length) {

while (uint32ArrayViewSetters < length) {

Object.defineProperty(Uint32ArrayView.prototype,

uint32ArrayViewSetters,

createUint32ArrayProp(uint32ArrayViewSetters));

uint32ArrayViewSetters++;

}

}

return Uint32ArrayView;

})();

var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];

var Util = PDFJS.Util = (function UtilClosure() {

function Util() {}

Util.makeCssRgb = function Util_makeCssRgb(rgb) {

return 'rgb(' + rgb[0] + ',' + rgb[1] + ',' + rgb[2] + ')';

};

Util.makeCssCmyk = function Util_makeCssCmyk(cmyk) {

var rgb = ColorSpace.singletons.cmyk.getRgb(cmyk, 0);

return Util.makeCssRgb(rgb);

};

// Concatenates two transformation matrices together and returns the result.

Util.transform = function Util_transform(m1, m2) {

return [

m1[0] * m2[0] + m1[2] * m2[1],

m1[1] * m2[0] + m1[3] * m2[1],

m1[0] * m2[2] + m1[2] * m2[3],

m1[1] * m2[2] + m1[3] * m2[3],

m1[0] * m2[4] + m1[2] * m2[5] + m1[4],

m1[1] * m2[4] + m1[3] * m2[5] + m1[5]

];

};

// For 2d affine transforms

Util.applyTransform = function Util_applyTransform(p, m) {

var xt = p[0] * m[0] + p[1] * m[2] + m[4];

var yt = p[0] * m[1] + p[1] * m[3] + m[5];

return [xt, yt];

};

Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {

var d = m[0] * m[3] - m[1] * m[2];

var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;

var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;

return [xt, yt];

};

// Applies the transform to the rectangle and finds the minimum axially

// aligned bounding box.

Util.getAxialAlignedBoundingBox =

function Util_getAxialAlignedBoundingBox(r, m) {

var p1 = Util.applyTransform(r, m);

var p2 = Util.applyTransform(r.slice(2, 4), m);

var p3 = Util.applyTransform([r[0], r[3]], m);

var p4 = Util.applyTransform([r[2], r[1]], m);

return [

Math.min(p1[0], p2[0], p3[0], p4[0]),

Math.min(p1[1], p2[1], p3[1], p4[1]),

Math.max(p1[0], p2[0], p3[0], p4[0]),

Math.max(p1[1], p2[1], p3[1], p4[1])

];

};

Util.inverseTransform = function Util_inverseTransform(m) {

var d = m[0] * m[3] - m[1] * m[2];

return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d,

(m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];

};

// Apply a generic 3d matrix M on a 3-vector v:

// | a b c | | X |

// | d e f | x | Y |

// | g h i | | Z |

// M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],

// with v as [X,Y,Z]

Util.apply3dTransform = function Util_apply3dTransform(m, v) {

return [

m[0] * v[0] + m[1] * v[1] + m[2] * v[2],

m[3] * v[0] + m[4] * v[1] + m[5] * v[2],

m[6] * v[0] + m[7] * v[1] + m[8] * v[2]

];

};

// This calculation uses Singular Value Decomposition.

// The SVD can be represented with formula A = USV. We are interested in the

// matrix S here because it represents the scale values.

Util.singularValueDecompose2dScale =

function Util_singularValueDecompose2dScale(m) {

var transpose = [m[0], m[2], m[1], m[3]];

// Multiply matrix m with its transpose.

var a = m[0] * transpose[0] + m[1] * transpose[2];

var b = m[0] * transpose[1] + m[1] * transpose[3];

var c = m[2] * transpose[0] + m[3] * transpose[2];

var d = m[2] * transpose[1] + m[3] * transpose[3];

// Solve the second degree polynomial to get roots.

var first = (a + d) / 2;

var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;

var sx = first + second || 1;

var sy = first - second || 1;

// Scale values are the square roots of the eigenvalues.

return [Math.sqrt(sx), Math.sqrt(sy)];

};

// Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)

// For coordinate systems whose origin lies in the bottom-left, this

// means normalization to (BL,TR) ordering. For systems with origin in the

// top-left, this means (TL,BR) ordering.

Util.normalizeRect = function Util_normalizeRect(rect) {

var r = rect.slice(0); // clone rect

if (rect[0] > rect[2]) {

r[0] = rect[2];

r[2] = rect[0];

}

if (rect[1] > rect[3]) {

r[1] = rect[3];

r[3] = rect[1];

}

return r;

};

// Returns a rectangle [x1, y1, x2, y2] corresponding to the

// intersection of rect1 and rect2. If no intersection, returns 'false'

// The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]

Util.intersect = function Util_intersect(rect1, rect2) {

function compare(a, b) {

return a - b;

}

// Order points along the axes

var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),

orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),

result = [];

rect1 = Util.normalizeRect(rect1);

rect2 = Util.normalizeRect(rect2);

// X: first and second points belong to different rectangles?

if ((orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||

(orderedX[0] === rect2[0] && orderedX[1] === rect1[0])) {

// Intersection must be between second and third points

result[0] = orderedX[1];

result[2] = orderedX[2];

} else {

return false;

}

// Y: first and second points belong to different rectangles?

if ((orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||

(orderedY[0] === rect2[1] && orderedY[1] === rect1[1])) {

// Intersection must be between second and third points

result[1] = orderedY[1];

result[3] = orderedY[2];

} else {

return false;

}

return result;

};

Util.sign = function Util_sign(num) {

return num < 0 ? -1 : 1;

};

// TODO(mack): Rename appendToArray

Util.concatenateToArray = function concatenateToArray(arr1, arr2) {

Array.prototype.push.apply(arr1, arr2);

};

Util.prependToArray = function concatenateToArray(arr1, arr2) {

Array.prototype.unshift.apply(arr1, arr2);

};

Util.extendObj = function extendObj(obj1, obj2) {

for (var key in obj2) {

obj1[key] = obj2[key];

}

};

Util.getInheritableProperty = function Util_getInheritableProperty(dict,

name) {

while (dict && !dict.has(name)) {

dict = dict.get('Parent');

}

if (!dict) {

return null;

}

return dict.get(name);

};

Util.inherit = function Util_inherit(sub, base, prototype) {

sub.prototype = Object.create(base.prototype);

sub.prototype.constructor = sub;

for (var prop in prototype) {

sub.prototype[prop] = prototype[prop];

}

};

Util.loadScript = function Util_loadScript(src, callback) {

var script = document.createElement('script');

var loaded = false;

script.setAttribute('src', src);

if (callback) {

script.onload = function() {

if (!loaded) {

callback();

}

loaded = true;

};

}

document.getElementsByTagName('head')[0].appendChild(script);

};

return Util;

})();

var PageViewport = PDFJS.PageViewport = (function PageViewportClosure() {

function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {

this.viewBox = viewBox;

this.scale = scale;

this.rotation = rotation;

this.offsetX = offsetX;

this.offsetY = offsetY;

// creating transform to convert pdf coordinate system to the normal

// canvas like coordinates taking in account scale and rotation

var centerX = (viewBox[2] + viewBox[0]) / 2;

var centerY = (viewBox[3] + viewBox[1]) / 2;

var rotateA, rotateB, rotateC, rotateD;

rotation = rotation % 360;

rotation = rotation < 0 ? rotation + 360 : rotation;

switch (rotation) {

case 180:

rotateA = -1; rotateB = 0; rotateC = 0; rotateD = 1;

break;

case 90:

rotateA = 0; rotateB = 1; rotateC = 1; rotateD = 0;

break;

case 270:

rotateA = 0; rotateB = -1; rotateC = -1; rotateD = 0;

break;

//case 0:

default:

rotateA = 1; rotateB = 0; rotateC = 0; rotateD = -1;

break;

}

if (dontFlip) {

rotateC = -rotateC; rotateD = -rotateD;

}

var offsetCanvasX, offsetCanvasY;

var width, height;

if (rotateA === 0) {

offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;

offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;

width = Math.abs(viewBox[3] - viewBox[1]) * scale;

height = Math.abs(viewBox[2] - viewBox[0]) * scale;

} else {

offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;

offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;

width = Math.abs(viewBox[2] - viewBox[0]) * scale;

height = Math.abs(viewBox[3] - viewBox[1]) * scale;

}

// creating transform for the following operations:

// translate(-centerX, -centerY), rotate and flip vertically,

// scale, and translate(offsetCanvasX, offsetCanvasY)

this.transform = [

rotateA * scale,

rotateB * scale,

rotateC * scale,

rotateD * scale,

offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,

offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY

];

this.width = width;

this.height = height;

this.fontScale = scale;

}

PageViewport.prototype = {

clone: function PageViewPort_clone(args) {

args = args || {};

var scale = 'scale' in args ? args.scale : this.scale;

var rotation = 'rotation' in args ? args.rotation : this.rotation;

return new PageViewport(this.viewBox.slice(), scale, rotation,

this.offsetX, this.offsetY, args.dontFlip);

},

convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {

return Util.applyTransform([x, y], this.transform);

},

convertToViewportRectangle:

function PageViewport_convertToViewportRectangle(rect) {

var tl = Util.applyTransform([rect[0], rect[1]], this.transform);

var br = Util.applyTransform([rect[2], rect[3]], this.transform);

return [tl[0], tl[1], br[0], br[1]];

},

convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {

return Util.applyInverseTransform([x, y], this.transform);

}

};

return PageViewport;

})();

var PDFStringTranslateTable = [

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,

0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,

0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,

0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC

];

function stringToPDFString(str) {

var i, n = str.length, strBuf = [];

if (str[0] === '\xFE' && str[1] === '\xFF') {

// UTF16BE BOM

for (i = 2; i < n; i += 2) {

strBuf.push(String.fromCharCode(

(str.charCodeAt(i) << 8) | str.charCodeAt(i + 1)));

}

} else {

for (i = 0; i < n; ++i) {

var code = PDFStringTranslateTable[str.charCodeAt(i)];

strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));

}

}

return strBuf.join('');

}

function stringToUTF8String(str) {

return decodeURIComponent(escape(str));

}

function isEmptyObj(obj) {

for (var key in obj) {

return false;

}

return true;

}

function isBool(v) {

return typeof v == 'boolean';

}

function isInt(v) {

return typeof v == 'number' && ((v | 0) == v);

}

function isNum(v) {

return typeof v == 'number';

}

function isString(v) {

return typeof v == 'string';

}

function isNull(v) {

return v === null;

}

function isName(v) {

return v instanceof Name;

}

function isCmd(v, cmd) {

return v instanceof Cmd && (!cmd || v.cmd == cmd);

}

function isDict(v, type) {

if (!(v instanceof Dict)) {

return false;

}

if (!type) {

return true;

}

var dictType = v.get('Type');

return isName(dictType) && dictType.name == type;

}

function isArray(v) {

return v instanceof Array;

}

function isStream(v) {

return typeof v == 'object' && v !== null && v !== undefined &&

('getBytes' in v);

}

function isArrayBuffer(v) {

return typeof v == 'object' && v !== null && v !== undefined &&

('byteLength' in v);

}

function isRef(v) {

return v instanceof Ref;

}

function isPDFFunction(v) {

var fnDict;

if (typeof v != 'object') {

return false;

} else if (isDict(v)) {

fnDict = v;

} else if (isStream(v)) {

fnDict = v.dict;

} else {

return false;

}

return fnDict.has('FunctionType');

}

var LegacyPromise = PDFJS.LegacyPromise = (function LegacyPromiseClosure() {

return function LegacyPromise() {

var resolve, reject;

var promise = new Promise(function (resolve_, reject_) {

resolve = resolve_;

reject = reject_;

});

promise.resolve = resolve;

promise.reject = reject;

return promise;

};

})();

(function PromiseClosure() {

if (globalScope.Promise) {

// Promises existing in the DOM/Worker, checking presence of all/resolve

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) {