From 3490d8aab796850d1f6956d5d1bf4c66f15dd2e5 Mon Sep 17 00:00:00 2001 From: Thomas FORGIONE Date: Fri, 9 Sep 2016 18:20:59 +0200 Subject: [PATCH] Initial commit --- LICENSE.md | 21 + README.md | 18 + lib/get.js | 61 + lib/log.js | 145 + lib/socket.js | 34 + package.json | 16 + routes/index/index.js | 6 + routes/index/urls.js | 3 + routes/index/views/index.pug | 5 + routes/speaker/index.js | 25 + routes/speaker/urls.js | 3 + routes/speaker/views/index.pug | 51 + routes/viewer/index.js | 25 + routes/viewer/urls.js | 3 + routes/viewer/views/index.pug | 17 + server.js | 72 + static/css/signin.css | 34 + static/css/speaker.css | 8 + static/css/style.css | 9 + static/css/viewer.css | 10 + static/js/pdf.js | 10375 ++++++++ static/js/pdf.worker.js | 42034 ++++++++++++++++++++++++++++++ static/js/speaker.js | 291 + static/js/viewer.js | 175 + static/uploaded/last_slides.pdf | Bin 0 -> 58906 bytes static/uploaded/main.pdf | Bin 0 -> 721845 bytes views/base.pug | 14 + views/main.pug | 28 + 28 files changed, 53483 insertions(+) create mode 100644 LICENSE.md create mode 100644 README.md create mode 100644 lib/get.js create mode 100644 lib/log.js create mode 100644 lib/socket.js create mode 100644 package.json create mode 100644 routes/index/index.js create mode 100644 routes/index/urls.js create mode 100644 routes/index/views/index.pug create mode 100644 routes/speaker/index.js create mode 100644 routes/speaker/urls.js create mode 100644 routes/speaker/views/index.pug create mode 100644 routes/viewer/index.js create mode 100644 routes/viewer/urls.js create mode 100644 routes/viewer/views/index.pug create mode 100644 server.js create mode 100644 static/css/signin.css create mode 100644 static/css/speaker.css create mode 100644 static/css/style.css create mode 100644 static/css/viewer.css create mode 100644 static/js/pdf.js create mode 100644 static/js/pdf.worker.js create mode 100644 static/js/speaker.js create mode 100644 static/js/viewer.js create mode 100644 static/uploaded/last_slides.pdf create mode 100644 static/uploaded/main.pdf create mode 100644 views/base.pug create mode 100644 views/main.pug diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..381f127 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Thomas FORGIONE + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..73481f8 --- /dev/null +++ b/README.md @@ -0,0 +1,18 @@ +# slideshow.io + +## What is it +Client-server application to manage slides on different computers during a +presentation. + +You can upload your pdf, and a link will be sent so you can share it with your +viewer. You will have a *speaker* interface, allowing you to switch between +slides and interact with them (underline elements, use a pointer...) and your +viewer will see what you are currently doing. + +## Install +A simple `npm install` will work. + +## License +This software is under MIT license. Check +[LICENSE.md](https://github.com/tforgione/slideshow.io/blob/master/LICENSE.md) for +more information. diff --git a/lib/get.js b/lib/get.js new file mode 100644 index 0000000..c108b70 --- /dev/null +++ b/lib/get.js @@ -0,0 +1,61 @@ +var express = require('express'); +var fs = require('fs'); +var log = require('log.js') + +module.exports = function(parent){ + + log.debug("Loading get :"); + + fs.readdirSync(__dirname + '/../routes').forEach(function(name){ + + // index.js in controller, with function as pages (views.py for django) + var obj = require('./../routes/' + name + '/index'); + + // urls.js, just like django urls.py + var urls = require('./../routes/' + name + '/urls'); + name = obj.name || name; + var app = express(); + + // allow specifying the view engine + if (obj.engine) app.set('view engine', obj.engine); + app.set('views', __dirname + '/../routes/' + name + '/views'); + + // generate routes based + // on the exported methods + + log.debug(' ' + name + ':'); + + for (var key in urls) { + + app.get(key, ((key) => function(req, res, next) { + + var path = obj[urls[key]](req, res, function(view) { + res.render( + __dirname + + '/../routes/' + + name + '/views/' + + view, + res.locals, + function(err, out) { + if (err !== null) { + log.pugerror(err); + } + res.send(out); + } + ); + + }, next); + + })(key)); + + log.debug(' ' + key + ' -> ' + name + '.' + urls[key]); + + } + + log.debug(); + + // mount the app + parent.use(app); + }); + +}; diff --git a/lib/log.js b/lib/log.js new file mode 100644 index 0000000..7433f5b --- /dev/null +++ b/lib/log.js @@ -0,0 +1,145 @@ +var express = require('express'); +var http = require('http'); +var yargs = require('yargs'); + +var argv = yargs.argv; + +var log = {}; + +var Color = { + DEFAULT:0, + BLACK:1, + RED:2, + GREEN:3, + YELLOW:4, + BLUE:5, + MAGENTA:6, + CYAN:7, + ORANGE:8 +} + +function getColorCode(c) { + switch (c) { + case Color.DEFAULT: return '\u001b[0m'; + case Color.BLACK: return '\u001b[30m'; + case Color.RED: return '\u001b[31m'; + case Color.GREEN: return '\u001b[32m'; + case Color.YELLOW: return '\u001b[33m'; + case Color.BLUE: return '\u001b[34m'; + case Color.MAGENTA: return '\u001b[35m'; + case Color.CYAN: return '\u001b[36m'; + case Color.ORANGE: return '\u001b[38;5;202m'; + } +} + +var isDev = require('express')().get('env') === 'development'; + +var write; + +if (argv.nolisten || argv.n) { + write = function(elt, color) { } +} else if (isDev) { + write = function(elt, color) { + console.log(getColorCode(color) + elt + getColorCode(Color.DEFAULT)); + } +} else { + write = function(elt, color) { + console.log(elt); + } +} + +log.ready = function(msg) { + write('[RDY] ' + new Date() + ' ' + msg, Color.GREEN); +} + +log.request = function(req, res, time) { + + if (req.headers['x-forwarded-for'] !== undefined || isDev) { + + var isStatic = req.url.substr(0, 7) === '/static' || req.url === '/favicon.ico'; + + write( + '[REQ] ' + new Date() + ' ' + + (req.headers['x-forwarded-for'] || req.connection.remoteAddress) + + (time !== undefined ? (' in ' + (" " + time).slice(-6) + ' ms') : '') + + ' : ' + (isStatic && req.url !== '/favicon.ico' ? '/static' + req.url : req.url), + isStatic ? Color.YELLOW : Color.CYAN + ); + } + +} + +log.socket = {}; + +log.socket.connection = function(socket, isTest) { + write( + '[SOK] ' + new Date() + ' ' + + (socket.handshake.headers['x-forwarded-for'] || socket.handshake.address) + (isTest ? ' test' : '') + ' connection', + Color.MAGENTA + ); +} + +log.socket.disconnect = function(socket, isTest) { + write( + '[SOK] ' + new Date() + ' ' + + (socket.handshake.headers['x-forwarded-for'] || socket.handshake.address) + (isTest ? ' test' : '') + ' disconnect', + Color.MAGENTA + ); +} + +log.dberror = function(error) { + write( + '[DBE] ' + new Date() + ' ' + error, + Color.RED + ); +} + +log.prefetcherror = function(error) { + write( + '[PFE] ' + new Date() + ' ' + error, + Color.RED + ); +} + +log.mailerror = function(error) { + write( + '[MLE] ' + new Date() + ' ' + error, + Color.RED + ); +} + +log.debug = function(info, force) { + if (isDev || force === true) { + write( + '[DBG] ' + (info !== undefined ? info : ''), + Color.YELLOW + ); + } +} + +log.pugerror = function(error) { + write( + '[PER] ' + new Date() + ' ' + error, + Color.RED + ); +} + +log.warning = function(message) { + + write( + '[WRN] ' + new Date() + ' ' + message, + Color.ORANGE + ); + +} + +log.faceerror = function(message) { + + write( + '[FER] ' + new Date() + ' ' + message, + Color.RED + ); + +} + +module.exports = log; diff --git a/lib/socket.js b/lib/socket.js new file mode 100644 index 0000000..61fc94b --- /dev/null +++ b/lib/socket.js @@ -0,0 +1,34 @@ +module.exports = function(io) { + + io.on('connection', function(socket) { + + socket.emit('welcome'); + + socket.on('viewer', function(filename) { + socket.join(filename); + }); + + socket.on('speaker', function(filename, socketId) { + socket.join(filename); + socket.speakerId = socketId; + }); + + socket.on('change-slide', function(filename, pageNumber) { + socket.broadcast.to(filename).emit('update', pageNumber); + }); + + socket.on('pointer', function(filename, id, x, y) { + if (id === socket.speakerId) { + socket.broadcast.to(filename).emit('pointer', 'speaker', x, y); + } else { + socket.broadcast.to(filename).emit('pointer', 'speaker', x, y); + } + }); + + socket.on('viewer-laser', function(filename, enabled) { + socket.broadcast.to(filename).emit('viewer-laser', enabled); + }); + + }); + +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..1461318 --- /dev/null +++ b/package.json @@ -0,0 +1,16 @@ +{ + "name" : "slideshow.io", + "version" : "0.1.0", + "dependencies" : { + "express" : "*", + "pug" : "*", + "socket.io" : "*", + "node-uuid" : "*", + "body-parser" : "*", + "app-module-path":"*" + }, + "repository" : { + "type" : "git", + "url" : "https://github.com/tforgione/slideshow.io" + } +} diff --git a/routes/index/index.js b/routes/index/index.js new file mode 100644 index 0000000..c5d085f --- /dev/null +++ b/routes/index/index.js @@ -0,0 +1,6 @@ +module.exports.index = function(req, res, render, next) { + + res.setHeader('Content-Type', 'text/html'); + render('index.pug', res.locals) + +} diff --git a/routes/index/urls.js b/routes/index/urls.js new file mode 100644 index 0000000..bc78ad0 --- /dev/null +++ b/routes/index/urls.js @@ -0,0 +1,3 @@ +module.exports = { + '/' : 'index' +} diff --git a/routes/index/views/index.pug b/routes/index/views/index.pug new file mode 100644 index 0000000..e417bf1 --- /dev/null +++ b/routes/index/views/index.pug @@ -0,0 +1,5 @@ +extends ../../../views/main.pug + +block content + p. + Hello world ! diff --git a/routes/speaker/index.js b/routes/speaker/index.js new file mode 100644 index 0000000..ba7441f --- /dev/null +++ b/routes/speaker/index.js @@ -0,0 +1,25 @@ +var fs = require('fs'); + +module.exports.index = function(req, res, render, next) { + + fs.stat('static/uploaded/' + req.params.file + '.pdf', function(err) { + + if (err === null) { + + res.locals.file = req.params.file; + + res.setHeader('Content-Type', 'text/html'); + render('index.pug', res.locals); + + } else { + + // 404 : file does not exist + var error = new Error('File does not exist'); + error.status = 404; + next(error); + } + + }); + + +} diff --git a/routes/speaker/urls.js b/routes/speaker/urls.js new file mode 100644 index 0000000..b6cd7a2 --- /dev/null +++ b/routes/speaker/urls.js @@ -0,0 +1,3 @@ +module.exports = { + '/speaker/:file' : 'index' +} diff --git a/routes/speaker/views/index.pug b/routes/speaker/views/index.pug new file mode 100644 index 0000000..58bb16f --- /dev/null +++ b/routes/speaker/views/index.pug @@ -0,0 +1,51 @@ +extends ../../../views/main.pug + +block append css + link(href="/static/css/style.css", rel="stylesheet") + link(href="/static/css/speaker.css", rel="stylesheet") + +block content + + .row + .col-md-8 + #canvases + canvas#canvas-pdf(style={"border" : "1px solid #000000", position:'absolute'}) + canvas#canvas-paint.noselect(onmousedown="sio.onMouseDown(event);", onmousemove="sio.onMouseMove(event);", onmouseup="sio.onMouseUp(event);", onmouseout="sio.onMouseUp(event);", style={position:'absolute'}) + + p + .btn-group + button.btn.btn-default#first(onclick="sio.firstSlide();") + span.glyphicon.glyphicon-step-backward + button.btn.btn-default#previous(aria-hidden='true', onclick="sio.previousSlide();") + span.glyphicon.glyphicon-play.glyphicon-flip + input.btn.btn-default#counter(type='text', onclick="sio.clearCounter();", onblur="sio.update();", onkeydown="if (event.keyCode === 13) sio.changeSlideFromCounter(event);") + button.btn.btn-default#next(onclick="sio.nextSlide();") + span.glyphicon.glyphicon-play + button.btn.btn-default#last(onclick="sio.lastSlide();") + span.glyphicon.glyphicon-step-forward + + span(style={'margin-left':'10px'}) + .btn-group + button.btn.btn-default#sync(onclick="sio.syncAudience();") Sync viewer + + span(style={'margin-left':'10px'}) + .btn-group + button.btn.btn-default#viewer-laser(onclick="sio.switchAudienceLaser();") Audience laser is disabled + + .col-md-4 + .btn-group + button.btn.btn-default#start(onclick="sio.startPresentation();") + span.glyphicon.glyphicon-play + button.btn.btn-default#stop(onclick="sio.stopPresentation();", disabled) + span.glyphicon.glyphicon-stop + p Total time :  + span#totalTime + p Slide time :  + span#slideTime + +block js + script filename = '#{file}'; + script(src="/static/js/pdf.js") + script(src="/static/js/pdf.worker.js") + script(src="/socket.io/socket.io.js") + script(src="/static/js/speaker.js") diff --git a/routes/viewer/index.js b/routes/viewer/index.js new file mode 100644 index 0000000..ba7441f --- /dev/null +++ b/routes/viewer/index.js @@ -0,0 +1,25 @@ +var fs = require('fs'); + +module.exports.index = function(req, res, render, next) { + + fs.stat('static/uploaded/' + req.params.file + '.pdf', function(err) { + + if (err === null) { + + res.locals.file = req.params.file; + + res.setHeader('Content-Type', 'text/html'); + render('index.pug', res.locals); + + } else { + + // 404 : file does not exist + var error = new Error('File does not exist'); + error.status = 404; + next(error); + } + + }); + + +} diff --git a/routes/viewer/urls.js b/routes/viewer/urls.js new file mode 100644 index 0000000..7a966fc --- /dev/null +++ b/routes/viewer/urls.js @@ -0,0 +1,3 @@ +module.exports = { + '/viewer/:file' : 'index' +} diff --git a/routes/viewer/views/index.pug b/routes/viewer/views/index.pug new file mode 100644 index 0000000..e98dc71 --- /dev/null +++ b/routes/viewer/views/index.pug @@ -0,0 +1,17 @@ +extends ../../../views/base.pug + +block css + link(href="/static/css/style.css", rel="stylesheet") + link(href="/static/css/viewer.css", rel="stylesheet") + +block base_content + #canvases + canvas#canvas-pdf.absoluteCenter(style={position:'absolute'}) + canvas#canvas-paint.absoluteCenter.noselect(onmousedown="sio.onMouseDown(event);", onmousemove="sio.onMouseMove(event);", onmouseup="sio.onMouseUp(event);", onmouseout="sio.onMouseUp(event);", style={position:'absolute'}) + +block js + script filename = '#{file}'; + script(src="/static/js/pdf.js") + script(src="/static/js/pdf.worker.js") + script(src="/socket.io/socket.io.js") + script(src="/static/js/viewer.js") diff --git a/server.js b/server.js new file mode 100644 index 0000000..4a2c7b4 --- /dev/null +++ b/server.js @@ -0,0 +1,72 @@ +require('app-module-path').addPath('./lib'); + +var http = require('http'); +var express = require('express'); +var pug = require('pug'); +var bp = require('body-parser'); +var socket = require('socket.js'); +var log = require('log.js'); +var app = express(); + +// Socket.io initialization +var http = require('http').Server(app); +var io = require('socket.io')(http); +require('./lib/socket.js')(io); + +var isDev = app.get('env') === 'development'; + +app.set('view engine', 'pug'); +app.set('trust proxy', 1); + +// parse application/x-www-form-urlencoded +app.use(bp.urlencoded({ extended: false })) + +// parse application/json +app.use(bp.json()) + +// Log request and time to answer +app.use(function(req, res, next) { + let start = Date.now(); + res.on('finish', function() { + log.request(req, res, Date.now() - start); + }); + res.locals.title = "slideshow.io"; + next(); +}); + +// Load controllers +require('./lib/get')(app); + +// Static files +app.use('/static', express.static('static')); + +// When error raised +app.use(function(err, req, res, next) { + if (err.status === 404) { + res.setHeader('Content-Type', 'text/html'); + res.send('Error 404'); + } +}); + +// When route not found, raise not found +app.use(function(req, res) { + res.setHeader('Content-Type', 'text/html'); + res.send('Error 404'); +}); + +// Set ports and ip address +var serverPort, serverIpAddress; + +if ( isDev ) { + serverPort = 4001; + serverIpAddress = 'localhost'; +} else { + // Openhift conf + serverPort = process.env.OPENSHIFT_NODEJS_PORT || 8080; + serverIpAddress = process.env.OPENSHIFT_NODEJS_IP || '127.0.0.1'; +} + +// Start server +http.listen(serverPort, serverIpAddress, function() { + log.debug("Now listening " + serverIpAddress + ":" + serverPort); +}); diff --git a/static/css/signin.css b/static/css/signin.css new file mode 100644 index 0000000..c83a1a9 --- /dev/null +++ b/static/css/signin.css @@ -0,0 +1,34 @@ +.form-signin { + max-width: 330px; + padding: 15px; + margin: 0 auto; +} +.form-signin .form-signin-heading, +.form-signin .checkbox { + margin-bottom: 10px; +} +.form-signin .checkbox { + font-weight: normal; +} +.form-signin .form-control { + position: relative; + height: auto; + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + padding: 10px; + font-size: 16px; +} +.form-signin .form-control:focus { + z-index: 2; +} +.form-signin input[type="email"] { + margin-bottom: -1px; + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.form-signin input[type="password"] { + margin-bottom: 10px; + border-top-left-radius: 0; + border-top-right-radius: 0; +} diff --git a/static/css/speaker.css b/static/css/speaker.css new file mode 100644 index 0000000..cdf9e10 --- /dev/null +++ b/static/css/speaker.css @@ -0,0 +1,8 @@ +.glyphicon-flip { + -moz-transform: scaleX(-1); + -o-transform: scaleX(-1); + -webkit-transform: scaleX(-1); + transform: scaleX(-1); + filter: FlipH; + -ms-filter: "FlipH"; +} diff --git a/static/css/style.css b/static/css/style.css new file mode 100644 index 0000000..4a80e91 --- /dev/null +++ b/static/css/style.css @@ -0,0 +1,9 @@ +.noselect { + cursor: default; + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} diff --git a/static/css/viewer.css b/static/css/viewer.css new file mode 100644 index 0000000..68a5881 --- /dev/null +++ b/static/css/viewer.css @@ -0,0 +1,10 @@ +#canvas { + margin:auto; + position:absolute; + top:0; + bottom:0; + left:0; + right:0; + max-height:100%; + max-width:100%; +} diff --git a/static/js/pdf.js b/static/js/pdf.js new file mode 100644 index 0000000..c8877d5 --- /dev/null +++ b/static/js/pdf.js @@ -0,0 +1,10375 @@ +/* Copyright 2012 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. + */ +/* jshint globalstrict: false */ +/* umdutils ignore */ + +(function (root, factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { +define('pdfjs-dist/build/pdf', ['exports'], factory); + } else if (typeof exports !== 'undefined') { + factory(exports); + } else { +factory((root.pdfjsDistBuildPdf = {})); + } +}(this, function (exports) { + // Use strict in our context only - users might not want it + 'use strict'; + +var pdfjsVersion = '1.4.20'; +var pdfjsBuild = 'b15f335'; + + var pdfjsFilePath = + typeof document !== 'undefined' && document.currentScript ? + document.currentScript.src : null; + + var pdfjsLibs = {}; + + (function pdfjsWrapper() { + + + +(function (root, factory) { + { + factory((root.pdfjsSharedGlobal = {})); + } +}(this, function (exports) { + + var globalScope = (typeof window !== 'undefined') ? window : + (typeof global !== 'undefined') ? global : + (typeof self !== 'undefined') ? self : this; + + var isWorker = (typeof window === 'undefined'); + + // The global PDFJS object exposes the API + // In production, it will be declared outside a global wrapper + // In development, it will be declared here + if (!globalScope.PDFJS) { + globalScope.PDFJS = {}; + } + + if (typeof pdfjsVersion !== 'undefined') { + globalScope.PDFJS.version = pdfjsVersion; + } + if (typeof pdfjsVersion !== 'undefined') { + globalScope.PDFJS.build = pdfjsBuild; + } + + globalScope.PDFJS.pdfBug = false; + + exports.globalScope = globalScope; + exports.isWorker = isWorker; + exports.PDFJS = globalScope.PDFJS; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayDOMUtils = {}), root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedGlobal) { + +var PDFJS = sharedGlobal.PDFJS; + +/** + * Optimised CSS custom property getter/setter. + * @class + */ +var CustomStyle = (function CustomStyleClosure() { + + // As noted on: http://www.zachstronaut.com/posts/2009/02/17/ + // animate-css-transforms-firefox-webkit.html + // in some versions of IE9 it is critical that ms appear in this list + // before Moz + var prefixes = ['ms', 'Moz', 'Webkit', 'O']; + var _cache = {}; + + function CustomStyle() {} + + CustomStyle.getProp = function get(propName, element) { + // check cache only when no element is given + if (arguments.length === 1 && typeof _cache[propName] === 'string') { + return _cache[propName]; + } + + element = element || document.documentElement; + var style = element.style, prefixed, uPropName; + + // test standard property first + if (typeof style[propName] === 'string') { + return (_cache[propName] = propName); + } + + // capitalize + uPropName = propName.charAt(0).toUpperCase() + propName.slice(1); + + // test vendor specific properties + for (var i = 0, l = prefixes.length; i < l; i++) { + prefixed = prefixes[i] + uPropName; + if (typeof style[prefixed] === 'string') { + return (_cache[propName] = prefixed); + } + } + + //if all fails then set to undefined + return (_cache[propName] = 'undefined'); + }; + + CustomStyle.setProp = function set(propName, element, str) { + var prop = this.getProp(propName); + if (prop !== 'undefined') { + element.style[prop] = str; + } + }; + + return CustomStyle; +})(); + +PDFJS.CustomStyle = CustomStyle; + +exports.CustomStyle = CustomStyle; +})); + + +(function (root, factory) { + { + factory((root.pdfjsSharedUtil = {}), root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedGlobal) { + +var PDFJS = sharedGlobal.PDFJS; +var globalScope = sharedGlobal.globalScope; + +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 +}; + +var AnnotationType = { + TEXT: 1, + LINK: 2, + FREETEXT: 3, + LINE: 4, + SQUARE: 5, + CIRCLE: 6, + POLYGON: 7, + POLYLINE: 8, + HIGHLIGHT: 9, + UNDERLINE: 10, + SQUIGGLY: 11, + STRIKEOUT: 12, + STAMP: 13, + CARET: 14, + INK: 15, + POPUP: 16, + FILEATTACHMENT: 17, + SOUND: 18, + MOVIE: 19, + WIDGET: 20, + SCREEN: 21, + PRINTERMARK: 22, + TRAPNET: 23, + WATERMARK: 24, + THREED: 25, + REDACT: 26 +}; + +var AnnotationFlag = { + INVISIBLE: 0x01, + HIDDEN: 0x02, + PRINT: 0x04, + NOZOOM: 0x08, + NOROTATE: 0x10, + NOVIEW: 0x20, + READONLY: 0x40, + LOCKED: 0x80, + TOGGLENOVIEW: 0x100, + LOCKEDCONTENTS: 0x200 +}; + +var AnnotationBorderStyleType = { + SOLID: 1, + DASHED: 2, + BEVELED: 3, + INSET: 4, + UNDERLINE: 5 +}; + +var StreamType = { + UNKNOWN: 0, + FLATE: 1, + LZW: 2, + DCT: 3, + JPX: 4, + JBIG: 5, + A85: 6, + AHX: 7, + CCF: 8, + RL: 9 +}; + +var FontType = { + UNKNOWN: 0, + TYPE1: 1, + TYPE1C: 2, + CIDFONTTYPE0: 3, + CIDFONTTYPE0C: 4, + TRUETYPE: 5, + CIDFONTTYPE2: 6, + TYPE3: 7, + OPENTYPE: 8, + TYPE0: 9, + MMTYPE1: 10 +}; + +PDFJS.VERBOSITY_LEVELS = { + errors: 0, + warnings: 1, + infos: 5 +}; + +// All the possible operations for an operator list. +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, + constructPath: 91 +}; + +// A notice for devs. These are good for things that are helpful to devs, such +// as warning that Workers were disabled, which is important to devs but not +// end users. +function info(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) { + console.log('Info: ' + msg); + } +} + +// Non-fatal warnings. +function warn(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) { + console.log('Warning: ' + msg); + } +} + +// Deprecated API function -- treated as warnings. +function deprecated(details) { + warn('Deprecated API usage: ' + details); +} + +// Fatal errors that should trigger the fallback UI and halt execution by +// throwing an exception. +function error(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.errors) { + console.log('Error: ' + msg); + console.log(backtrace()); + } + 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' +}; + +// Combines two URLs. The baseUrl shall be absolute URL. If the url is an +// absolute URL, it will be returned as is. +function combineUrl(baseUrl, url) { + if (!url) { + return baseUrl; + } + return new URL(url, baseUrl).href; +} + +// Validates if URL is safe and allowed, e.g. to avoid XSS. +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': + case 'tel': + return true; + default: + return false; + } +} +PDFJS.isValidUrl = isValidUrl; + +/** + * Adds various attributes (href, title, target, rel) to hyperlinks. + * @param {HTMLLinkElement} link - The link element. + * @param {Object} params - An object with the properties: + * @param {string} params.url - An absolute URL. + */ +function addLinkAttributes(link, params) { + var url = params && params.url; + link.href = link.title = (url ? removeNullCharacters(url) : ''); + + if (url) { + if (isExternalLinkTargetSet()) { + link.target = LinkTargetStringMap[PDFJS.externalLinkTarget]; + } + // Strip referrer from the URL. + link.rel = PDFJS.externalLinkRel; + } +} +PDFJS.addLinkAttributes = addLinkAttributes; + +function shadow(obj, prop, value) { + Object.defineProperty(obj, prop, { value: value, + enumerable: true, + configurable: true, + writable: false }); + return value; +} +PDFJS.shadow = shadow; + +var LinkTarget = PDFJS.LinkTarget = { + NONE: 0, // Default value. + SELF: 1, + BLANK: 2, + PARENT: 3, + TOP: 4, +}; +var LinkTargetStringMap = [ + '', + '_self', + '_blank', + '_parent', + '_top' +]; + +function isExternalLinkTargetSet() { + if (PDFJS.openExternalLinksInNewWindow) { + deprecated('PDFJS.openExternalLinksInNewWindow, please use ' + + '"PDFJS.externalLinkTarget = PDFJS.LinkTarget.BLANK" instead.'); + if (PDFJS.externalLinkTarget === LinkTarget.NONE) { + PDFJS.externalLinkTarget = LinkTarget.BLANK; + } + // Reset the deprecated parameter, to suppress further warnings. + PDFJS.openExternalLinksInNewWindow = false; + } + switch (PDFJS.externalLinkTarget) { + case LinkTarget.NONE: + return false; + case LinkTarget.SELF: + case LinkTarget.BLANK: + case LinkTarget.PARENT: + case LinkTarget.TOP: + return true; + } + warn('PDFJS.externalLinkTarget is invalid: ' + PDFJS.externalLinkTarget); + // Reset the external link target, to suppress further warnings. + PDFJS.externalLinkTarget = LinkTarget.NONE; + return false; +} +PDFJS.isExternalLinkTargetSet = isExternalLinkTargetSet; + +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; +})(); +PDFJS.PasswordException = 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; +})(); +PDFJS.UnknownErrorException = UnknownErrorException; + +var InvalidPDFException = (function InvalidPDFExceptionClosure() { + function InvalidPDFException(msg) { + this.name = 'InvalidPDFException'; + this.message = msg; + } + + InvalidPDFException.prototype = new Error(); + InvalidPDFException.constructor = InvalidPDFException; + + return InvalidPDFException; +})(); +PDFJS.InvalidPDFException = InvalidPDFException; + +var MissingPDFException = (function MissingPDFExceptionClosure() { + function MissingPDFException(msg) { + this.name = 'MissingPDFException'; + this.message = msg; + } + + MissingPDFException.prototype = new Error(); + MissingPDFException.constructor = MissingPDFException; + + return MissingPDFException; +})(); +PDFJS.MissingPDFException = MissingPDFException; + +var UnexpectedResponseException = + (function UnexpectedResponseExceptionClosure() { + function UnexpectedResponseException(msg, status) { + this.name = 'UnexpectedResponseException'; + this.message = msg; + this.status = status; + } + + UnexpectedResponseException.prototype = new Error(); + UnexpectedResponseException.constructor = UnexpectedResponseException; + + return UnexpectedResponseException; +})(); +PDFJS.UnexpectedResponseException = UnexpectedResponseException; + +var NotImplementedException = (function NotImplementedExceptionClosure() { + function NotImplementedException(msg) { + this.message = msg; + } + + NotImplementedException.prototype = new Error(); + NotImplementedException.prototype.name = 'NotImplementedException'; + NotImplementedException.constructor = NotImplementedException; + + return NotImplementedException; +})(); + +var MissingDataException = (function MissingDataExceptionClosure() { + function MissingDataException(begin, end) { + this.begin = begin; + this.end = end; + this.message = 'Missing data [' + begin + ', ' + end + ')'; + } + + MissingDataException.prototype = new Error(); + MissingDataException.prototype.name = 'MissingDataException'; + MissingDataException.constructor = MissingDataException; + + return MissingDataException; +})(); + +var XRefParseException = (function XRefParseExceptionClosure() { + function XRefParseException(msg) { + this.message = msg; + } + + XRefParseException.prototype = new Error(); + XRefParseException.prototype.name = 'XRefParseException'; + XRefParseException.constructor = XRefParseException; + + return XRefParseException; +})(); + +var NullCharactersRegExp = /\x00/g; + +function removeNullCharacters(str) { + if (typeof str !== 'string') { + warn('The argument for removeNullCharacters must be a string.'); + return str; + } + return str.replace(NullCharactersRegExp, ''); +} +PDFJS.removeNullCharacters = removeNullCharacters; + +function bytesToString(bytes) { + assert(bytes !== null && typeof bytes === 'object' && + bytes.length !== undefined, 'Invalid argument for bytesToString'); + var length = bytes.length; + var MAX_ARGUMENT_COUNT = 8192; + if (length < MAX_ARGUMENT_COUNT) { + return String.fromCharCode.apply(null, bytes); + } + var strBuf = []; + for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) { + var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length); + var chunk = bytes.subarray(i, chunkEnd); + strBuf.push(String.fromCharCode.apply(null, chunk)); + } + return strBuf.join(''); +} + +function stringToBytes(str) { + assert(typeof str === 'string', 'Invalid argument for stringToBytes'); + var length = str.length; + var bytes = new Uint8Array(length); + for (var i = 0; i < length; ++i) { + bytes[i] = str.charCodeAt(i) & 0xFF; + } + return bytes; +} + +function 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; +} + +// Lazy test the endianness of the platform +// NOTE: This will be 'true' for simulated TypedArrays +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 userAgent 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; +})(); + +exports.Uint32ArrayView = Uint32ArrayView; + +var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]; + +var Util = PDFJS.Util = (function UtilClosure() { + function Util() {} + + var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')']; + + // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids + // creating many intermediate strings. + Util.makeCssRgb = function Util_makeCssRgb(r, g, b) { + rgbBuf[1] = r; + rgbBuf[3] = g; + rgbBuf[5] = b; + return rgbBuf.join(''); + }; + + // 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; + }; + + var ROMAN_NUMBER_MAP = [ + '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', + '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', + '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX' + ]; + /** + * Converts positive integers to (upper case) Roman numerals. + * @param {integer} number - The number that should be converted. + * @param {boolean} lowerCase - Indicates if the result should be converted + * to lower case letters. The default is false. + * @return {string} The resulting Roman number. + */ + Util.toRoman = function Util_toRoman(number, lowerCase) { + assert(isInt(number) && number > 0, + 'The number should be a positive integer.'); + var pos, romanBuf = []; + // Thousands + while (number >= 1000) { + number -= 1000; + romanBuf.push('M'); + } + // Hundreds + pos = (number / 100) | 0; + number %= 100; + romanBuf.push(ROMAN_NUMBER_MAP[pos]); + // Tens + pos = (number / 10) | 0; + number %= 10; + romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]); + // Ones + romanBuf.push(ROMAN_NUMBER_MAP[20 + number]); + + var romanStr = romanBuf.join(''); + return (lowerCase ? romanStr.toLowerCase() : romanStr); + }; + + Util.appendToArray = function Util_appendToArray(arr1, arr2) { + Array.prototype.push.apply(arr1, arr2); + }; + + Util.prependToArray = function Util_prependToArray(arr1, arr2) { + Array.prototype.unshift.apply(arr1, arr2); + }; + + Util.extendObj = function extendObj(obj1, obj2) { + for (var key in obj2) { + obj1[key] = obj2[key]; + } + }; + + Util.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; +})(); + +/** + * PDF page viewport created based on scale, rotation and offset. + * @class + * @alias PDFJS.PageViewport + */ +var PageViewport = PDFJS.PageViewport = (function PageViewportClosure() { + /** + * @constructor + * @private + * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates. + * @param scale {number} scale of the viewport. + * @param rotation {number} rotations of the viewport in degrees. + * @param offsetX {number} offset X + * @param offsetY {number} offset Y + * @param dontFlip {boolean} if true, axis Y will not be flipped. + */ + 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 = /** @lends PDFJS.PageViewport.prototype */ { + /** + * Clones viewport with additional properties. + * @param args {Object} (optional) If specified, may contain the 'scale' or + * 'rotation' properties to override the corresponding properties in + * the cloned viewport. + * @returns {PDFJS.PageViewport} Cloned viewport. + */ + 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); + }, + /** + * Converts PDF point to the viewport coordinates. For examples, useful for + * converting PDF location into canvas pixel coordinates. + * @param x {number} X coordinate. + * @param y {number} Y coordinate. + * @returns {Object} Object that contains 'x' and 'y' properties of the + * point in the viewport coordinate space. + * @see {@link convertToPdfPoint} + * @see {@link convertToViewportRectangle} + */ + convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) { + return Util.applyTransform([x, y], this.transform); + }, + /** + * Converts PDF rectangle to the viewport coordinates. + * @param rect {Array} xMin, yMin, xMax and yMax coordinates. + * @returns {Array} Contains corresponding coordinates of the rectangle + * in the viewport coordinate space. + * @see {@link convertToViewportPoint} + */ + 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]]; + }, + /** + * Converts viewport coordinates to the PDF location. For examples, useful + * for converting canvas pixel location into PDF one. + * @param x {number} X coordinate. + * @param y {number} Y coordinate. + * @returns {Object} Object that contains 'x' and 'y' properties of the + * point in the PDF coordinate space. + * @see {@link convertToViewportPoint} + */ + 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 utf8StringToString(str) { + return unescape(encodeURIComponent(str)); +} + +function isEmptyObj(obj) { + for (var key in obj) { + return false; + } + return true; +} + +function isBool(v) { + return typeof v === 'boolean'; +} + +function isInt(v) { + return typeof v === 'number' && ((v | 0) === v); +} + +function isNum(v) { + return typeof v === 'number'; +} + +function isString(v) { + return typeof v === 'string'; +} + +function isArray(v) { + return v instanceof Array; +} + +function isArrayBuffer(v) { + return typeof v === 'object' && v !== null && v.byteLength !== undefined; +} + +/** + * Promise Capability object. + * + * @typedef {Object} PromiseCapability + * @property {Promise} promise - A promise object. + * @property {function} resolve - Fullfills the promise. + * @property {function} reject - Rejects the promise. + */ + +/** + * Creates a promise capability object. + * @alias PDFJS.createPromiseCapability + * + * @return {PromiseCapability} A capability object contains: + * - a Promise, resolve and reject methods. + */ +function createPromiseCapability() { + var capability = {}; + capability.promise = new Promise(function (resolve, reject) { + capability.resolve = resolve; + capability.reject = reject; + }); + return capability; +} + +PDFJS.createPromiseCapability = createPromiseCapability; + +/** + * Polyfill for Promises: + * The following promise implementation tries to generally implement the + * Promise/A+ spec. Some notable differences from other promise libaries are: + * - There currently isn't a seperate deferred and promise object. + * - Unhandled rejections eventually show an error if they aren't handled. + * + * Based off of the work in: + * https://bugzilla.mozilla.org/show_bug.cgi?id=810490 + */ +(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) { + 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; + + // In an attempt to avoid silent exceptions, unhandled rejections are + // tracked and if they aren't handled in a certain amount of time an + // error is logged. + 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; // ms + 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() { + if (this.pendingRejectionCheck) { + return; + } + this.pendingRejectionCheck = true; + setTimeout(function rejectionCheck() { + 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; + } + warn(msg); + this.unhandledRejections.splice(i); + i--; + } + } + if (this.unhandledRejections.length) { + this.scheduleRejectionCheck(); + } + }.bind(this), REJECTION_TIMEOUT); + } + }; + + 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); + } + } + /** + * Builds a promise that is resolved when all the passed in promises are + * resolved. + * @param {array} array of data and/or promises to wait for. + * @return {Promise} New dependant promise. + */ + 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; + }; + + /** + * Checks if the value is likely a promise (has a 'then' function). + * @return {boolean} true if value is thenable + */ + Promise.isPromise = function Promise_isPromise(value) { + return value && typeof value.then === 'function'; + }; + + /** + * Creates resolved promise + * @param value resolve value + * @returns {Promise} + */ + Promise.resolve = function Promise_resolve(value) { + return new Promise(function (resolve) { resolve(value); }); + }; + + /** + * Creates rejected promise + * @param reason rejection value + * @returns {Promise} + */ + 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; +})(); + +var StatTimer = (function StatTimerClosure() { + function rpad(str, pad, length) { + while (str.length < length) { + str += pad; + } + return str; + } + function StatTimer() { + this.started = {}; + this.times = []; + this.enabled = true; + } + StatTimer.prototype = { + time: function StatTimer_time(name) { + if (!this.enabled) { + return; + } + if (name in this.started) { + warn('Timer is already running for ' + name); + } + this.started[name] = Date.now(); + }, + timeEnd: function StatTimer_timeEnd(name) { + if (!this.enabled) { + return; + } + if (!(name in this.started)) { + warn('Timer has not been started for ' + name); + } + this.times.push({ + 'name': name, + 'start': this.started[name], + 'end': Date.now() + }); + // Remove timer from started so it can be called again. + delete this.started[name]; + }, + toString: function StatTimer_toString() { + var i, ii; + var times = this.times; + var out = ''; + // Find the longest name for padding purposes. + var longest = 0; + for (i = 0, ii = times.length; i < ii; ++i) { + var name = times[i]['name']; + if (name.length > longest) { + longest = name.length; + } + } + for (i = 0, ii = times.length; i < ii; ++i) { + var span = times[i]; + var duration = span.end - span.start; + out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n'; + } + return out; + } + }; + return StatTimer; +})(); + +PDFJS.createBlob = function createBlob(data, contentType) { + if (typeof Blob !== 'undefined') { + return new Blob([data], { type: contentType }); + } + // Blob builder is deprecated in FF14 and removed in FF18. + var bb = new MozBlobBuilder(); + bb.append(data); + return bb.getBlob(contentType); +}; + +PDFJS.createObjectURL = (function createObjectURLClosure() { + // Blob/createObjectURL is not available, falling back to data schema. + var digits = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + + return function createObjectURL(data, contentType) { + if (!PDFJS.disableCreateObjectURL && + typeof URL !== 'undefined' && URL.createObjectURL) { + var blob = PDFJS.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 MessageHandler(sourceName, targetName, comObj) { + this.sourceName = sourceName; + this.targetName = targetName; + this.comObj = comObj; + this.callbackIndex = 1; + this.postMessageTransfers = true; + var callbacksCapabilities = this.callbacksCapabilities = {}; + var ah = this.actionHandler = {}; + + this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) { + var data = event.data; + if (data.targetName !== this.sourceName) { + return; + } + 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(data.error); + } else { + callback.resolve(data.data); + } + } else { + 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) { + // Serialize error to avoid "DataCloneError" + reason = reason + ''; + } + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + isReply: true, + callbackId: data.callbackId, + error: reason + }); + }); + } else { + action[0].call(action[1], data.data); + } + } else { + error('Unknown action from worker: ' + data.action); + } + }.bind(this); + comObj.addEventListener('message', this._onComObjOnMessage); +} + +MessageHandler.prototype = { + on: function messageHandlerOn(actionName, handler, scope) { + var ah = this.actionHandler; + if (ah[actionName]) { + error('There is already an actionName called "' + actionName + '"'); + } + ah[actionName] = [handler, scope]; + }, + /** + * Sends a message to the comObj to invoke the action with the supplied data. + * @param {String} actionName Action to call. + * @param {JSON} data JSON data to send. + * @param {Array} [transfers] Optional list of transfers/ArrayBuffers + */ + send: function messageHandlerSend(actionName, data, transfers) { + var message = { + sourceName: this.sourceName, + targetName: this.targetName, + action: actionName, + data: data + }; + this.postMessage(message, transfers); + }, + /** + * Sends a message to the comObj to invoke the action with the supplied data. + * Expects that other side will callback with the response. + * @param {String} actionName Action to call. + * @param {JSON} data JSON data to send. + * @param {Array} [transfers] Optional list of transfers/ArrayBuffers. + * @returns {Promise} Promise to be resolved with response data. + */ + sendWithPromise: + function messageHandlerSendWithPromise(actionName, data, transfers) { + var callbackId = this.callbackIndex++; + 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; + }, + /** + * Sends raw message to the comObj. + * @private + * @param message {Object} Raw message. + * @param transfers List of transfers/ArrayBuffers, or undefined. + */ + postMessage: function (message, transfers) { + if (transfers && this.postMessageTransfers) { + this.comObj.postMessage(message, transfers); + } else { + this.comObj.postMessage(message); + } + }, + + destroy: function () { + 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; +} + + // Polyfill from https://github.com/Polymer/URL +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ +(function checkURLConstructor(scope) { + /* jshint ignore:start */ + + // feature detect for URL constructor + 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) + } + // XXX + 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) { + // XXX This actually needs to encode c using encoding and then + // convert the bytes one-by-one. + + var unicode = c.charCodeAt(0); + if (unicode > 0x20 && + unicode < 0x7F && + // " # < > ` (do not escape '?') + [0x22, 0x23, 0x3C, 0x3E, 0x60].indexOf(unicode) == -1 + ) { + return c; + } + return encodeURIComponent(c); + } + + var EOF = undefined, + 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(); // ASCII-safe + 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(); // ASCII-safe + } else if (':' == c) { + this._scheme = buffer; + buffer = ''; + if (stateOverride) { + break loop; + } + if (isRelativeScheme(this._scheme)) { + this._isRelative = true; + } + if ('file' == this._scheme) { + 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 (EOF == c) { + 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 { + // XXX error handling + if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + 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 ('file' != this._scheme) + this._scheme = base._scheme; + if (EOF == c) { + 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 ( + 'file' != this._scheme || !ALPHA.test(c) || + (nextC != ':' && nextC != '|') || + (EOF != nextNextC && '/' != 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 ('file' == this._scheme) { + state = 'file host'; + } else { + state = 'authority ignore slashes'; + } + } else { + if ('file' != this._scheme) { + 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 ('\t' == cp || '\n' == cp || '\r' == cp) { + err('Invalid whitespace in authority.'); + continue; + } + // XXX check URL code points + if (':' == cp && null === this._password) { + this._password = ''; + continue; + } + var tempC = percentEscape(cp); + (null !== this._password) ? this._password += tempC : this._username += tempC; + } + buffer = ''; + } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) { + cursor -= buffer.length; + buffer = ''; + state = 'host'; + continue; + } else { + buffer += c; + } + break; + + case 'file host': + if (EOF == c || '/' == 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 ('\t' == c || '\n' == c || '\r' == c) { + err('Invalid whitespace in file host.'); + } else { + buffer += c; + } + break; + + case 'host': + case 'hostname': + if (':' == c && !seenBracket) { + // XXX host parsing + this._host = IDNAToASCII.call(this, buffer); + buffer = ''; + state = 'port'; + if ('hostname' == stateOverride) { + break loop; + } + } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) { + this._host = IDNAToASCII.call(this, buffer); + buffer = ''; + state = 'relative path start'; + if (stateOverride) { + break loop; + } + continue; + } else if ('\t' != c && '\n' != c && '\r' != c) { + 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 (EOF == c || '/' == 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 ('\t' == c || '\n' == c || '\r' == c) { + 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 (EOF == c || '/' == 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 ('file' == this._scheme && 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 ('\t' != c && '\n' != c && '\r' != c) { + buffer += percentEscape(c); + } + break; + + case 'query': + if (!stateOverride && '#' == c) { + this._fragment = '#'; + state = 'fragment'; + } else if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + this._query += percentEscapeQuery(c); + } + break; + + case 'fragment': + if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + 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; + } + + // Does not process domain names or IP addresses. + // Does not handle encoding for the query parameter. + function jURL(url, base /* , encoding */) { + 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, ''); + // encoding = encoding || 'utf-8' + + parse.call(this, input, null, base); + } + + jURL.prototype = { + toString: function() { + return this.href; + }, + get href() { + if (this._isInvalid) + return this._url; + + var authority = ''; + if ('' != this._username || null != this._password) { + authority = this._username + + (null != this._password ? ':' + this._password : '') + '@'; + } + + return this.protocol + + (this._isRelative ? '//' + authority + this.host : '') + + this.pathname + this._query + this._fragment; + }, + set href(href) { + clear.call(this); + parse.call(this, href); + }, + + get protocol() { + return this._scheme + ':'; + }, + set protocol(protocol) { + if (this._isInvalid) + return; + parse.call(this, protocol + ':', 'scheme start'); + }, + + get host() { + return this._isInvalid ? '' : this._port ? + this._host + ':' + this._port : this._host; + }, + set host(host) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, host, 'host'); + }, + + get hostname() { + return this._host; + }, + set hostname(hostname) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, hostname, 'hostname'); + }, + + get port() { + return this._port; + }, + set port(port) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, port, 'port'); + }, + + get pathname() { + return this._isInvalid ? '' : this._isRelative ? + '/' + this._path.join('/') : this._schemeData; + }, + set pathname(pathname) { + if (this._isInvalid || !this._isRelative) + return; + this._path = []; + parse.call(this, pathname, 'relative path start'); + }, + + get search() { + return this._isInvalid || !this._query || '?' == this._query ? + '' : this._query; + }, + set search(search) { + if (this._isInvalid || !this._isRelative) + return; + this._query = '?'; + if ('?' == search[0]) + search = search.slice(1); + parse.call(this, search, 'query'); + }, + + get hash() { + return this._isInvalid || !this._fragment || '#' == this._fragment ? + '' : this._fragment; + }, + set hash(hash) { + if (this._isInvalid) + return; + this._fragment = '#'; + if ('#' == hash[0]) + hash = hash.slice(1); + parse.call(this, hash, 'fragment'); + }, + + get origin() { + var host; + if (this._isInvalid || !this._scheme) { + return ''; + } + // javascript: Gecko returns String(""), WebKit/Blink String("null") + // Gecko throws error for "data://" + // data: Gecko returns "", Blink returns "data://", WebKit returns "null" + // Gecko returns String("") for file: mailto: + // WebKit/Blink returns String("SCHEME://") for file: mailto: + switch (this._scheme) { + case 'data': + case 'file': + case 'javascript': + case 'mailto': + return 'null'; + } + host = this.host; + if (!host) { + return ''; + } + return this._scheme + '://' + host; + } + }; + + // Copy over the static methods + var OriginalURL = scope.URL; + if (OriginalURL) { + jURL.createObjectURL = function(blob) { + // IE extension allows a second optional options argument. + // http://msdn.microsoft.com/en-us/library/ie/hh772302(v=vs.85).aspx + return OriginalURL.createObjectURL.apply(OriginalURL, arguments); + }; + jURL.revokeObjectURL = function(url) { + OriginalURL.revokeObjectURL(url); + }; + } + + scope.URL = jURL; + /* jshint ignore:end */ +})(globalScope); + +exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX; +exports.IDENTITY_MATRIX = IDENTITY_MATRIX; +exports.OPS = OPS; +exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES; +exports.AnnotationBorderStyleType = AnnotationBorderStyleType; +exports.AnnotationFlag = AnnotationFlag; +exports.AnnotationType = AnnotationType; +exports.FontType = FontType; +exports.ImageKind = ImageKind; +exports.InvalidPDFException = InvalidPDFException; +exports.LinkTarget = LinkTarget; +exports.LinkTargetStringMap = LinkTargetStringMap; +exports.MessageHandler = MessageHandler; +exports.MissingDataException = MissingDataException; +exports.MissingPDFException = MissingPDFException; +exports.NotImplementedException = NotImplementedException; +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.assert = assert; +exports.bytesToString = bytesToString; +exports.combineUrl = combineUrl; +exports.createPromiseCapability = createPromiseCapability; +exports.deprecated = deprecated; +exports.error = error; +exports.info = info; +exports.isArray = isArray; +exports.isArrayBuffer = isArrayBuffer; +exports.isBool = isBool; +exports.isEmptyObj = isEmptyObj; +exports.isExternalLinkTargetSet = isExternalLinkTargetSet; +exports.isInt = isInt; +exports.isNum = isNum; +exports.isString = isString; +exports.isValidUrl = isValidUrl; +exports.addLinkAttributes = addLinkAttributes; +exports.loadJpegStream = loadJpegStream; +exports.log2 = log2; +exports.readInt8 = readInt8; +exports.readUint16 = readUint16; +exports.readUint32 = readUint32; +exports.removeNullCharacters = removeNullCharacters; +exports.shadow = shadow; +exports.string32 = string32; +exports.stringToBytes = stringToBytes; +exports.stringToPDFString = stringToPDFString; +exports.stringToUTF8String = stringToUTF8String; +exports.utf8StringToString = utf8StringToString; +exports.warn = warn; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayAnnotationLayer = {}), root.pdfjsSharedUtil, + root.pdfjsDisplayDOMUtils); + } +}(this, function (exports, sharedUtil, displayDOMUtils) { + +var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType; +var AnnotationType = sharedUtil.AnnotationType; +var Util = sharedUtil.Util; +var addLinkAttributes = sharedUtil.addLinkAttributes; +var warn = sharedUtil.warn; +var CustomStyle = displayDOMUtils.CustomStyle; + +/** + * @typedef {Object} AnnotationElementParameters + * @property {Object} data + * @property {HTMLDivElement} layer + * @property {PDFPage} page + * @property {PageViewport} viewport + * @property {IPDFLinkService} linkService + */ + +/** + * @class + * @alias AnnotationElementFactory + */ +function AnnotationElementFactory() {} +AnnotationElementFactory.prototype = + /** @lends AnnotationElementFactory.prototype */ { + /** + * @param {AnnotationElementParameters} parameters + * @returns {AnnotationElement} + */ + create: function AnnotationElementFactory_create(parameters) { + var subtype = parameters.data.annotationType; + + switch (subtype) { + case AnnotationType.LINK: + return new LinkAnnotationElement(parameters); + + case AnnotationType.TEXT: + return new TextAnnotationElement(parameters); + + case AnnotationType.WIDGET: + return new WidgetAnnotationElement(parameters); + + case AnnotationType.POPUP: + return new PopupAnnotationElement(parameters); + + case AnnotationType.HIGHLIGHT: + return new HighlightAnnotationElement(parameters); + + case AnnotationType.UNDERLINE: + return new UnderlineAnnotationElement(parameters); + + case AnnotationType.SQUIGGLY: + return new SquigglyAnnotationElement(parameters); + + case AnnotationType.STRIKEOUT: + return new StrikeOutAnnotationElement(parameters); + + default: + throw new Error('Unimplemented annotation type "' + subtype + '"'); + } + } +}; + +/** + * @class + * @alias AnnotationElement + */ +var AnnotationElement = (function AnnotationElementClosure() { + function AnnotationElement(parameters) { + this.data = parameters.data; + this.layer = parameters.layer; + this.page = parameters.page; + this.viewport = parameters.viewport; + this.linkService = parameters.linkService; + + this.container = this._createContainer(); + } + + AnnotationElement.prototype = /** @lends AnnotationElement.prototype */ { + /** + * Create an empty container for the annotation's HTML element. + * + * @private + * @memberof AnnotationElement + * @returns {HTMLSectionElement} + */ + _createContainer: function AnnotationElement_createContainer() { + var data = this.data, page = this.page, viewport = this.viewport; + var container = document.createElement('section'); + var width = data.rect[2] - data.rect[0]; + var height = data.rect[3] - data.rect[1]; + + container.setAttribute('data-annotation-id', data.id); + + // Do *not* modify `data.rect`, since that will corrupt the annotation + // position on subsequent calls to `_createContainer` (see issue 6804). + var rect = Util.normalizeRect([ + data.rect[0], + page.view[3] - data.rect[1] + page.view[1], + data.rect[2], + page.view[3] - data.rect[3] + page.view[1] + ]); + + CustomStyle.setProp('transform', container, + 'matrix(' + viewport.transform.join(',') + ')'); + CustomStyle.setProp('transformOrigin', container, + -rect[0] + 'px ' + -rect[1] + 'px'); + + if (data.borderStyle.width > 0) { + container.style.borderWidth = data.borderStyle.width + 'px'; + if (data.borderStyle.style !== AnnotationBorderStyleType.UNDERLINE) { + // Underline styles only have a bottom border, so we do not need + // to adjust for all borders. This yields a similar result as + // Adobe Acrobat/Reader. + width = width - 2 * data.borderStyle.width; + height = height - 2 * data.borderStyle.width; + } + + var horizontalRadius = data.borderStyle.horizontalCornerRadius; + var verticalRadius = data.borderStyle.verticalCornerRadius; + if (horizontalRadius > 0 || verticalRadius > 0) { + var radius = horizontalRadius + 'px / ' + verticalRadius + 'px'; + CustomStyle.setProp('borderRadius', container, radius); + } + + switch (data.borderStyle.style) { + case AnnotationBorderStyleType.SOLID: + container.style.borderStyle = 'solid'; + break; + + case AnnotationBorderStyleType.DASHED: + container.style.borderStyle = 'dashed'; + break; + + case AnnotationBorderStyleType.BEVELED: + warn('Unimplemented border style: beveled'); + break; + + case AnnotationBorderStyleType.INSET: + warn('Unimplemented border style: inset'); + break; + + case AnnotationBorderStyleType.UNDERLINE: + container.style.borderBottomStyle = 'solid'; + break; + + default: + break; + } + + if (data.color) { + container.style.borderColor = + Util.makeCssRgb(data.color[0] | 0, + data.color[1] | 0, + data.color[2] | 0); + } else { + // Transparent (invisible) border, so do not draw it at all. + container.style.borderWidth = 0; + } + } + + container.style.left = rect[0] + 'px'; + container.style.top = rect[1] + 'px'; + + container.style.width = width + 'px'; + container.style.height = height + 'px'; + + return container; + }, + + /** + * Render the annotation's HTML element in the empty container. + * + * @public + * @memberof AnnotationElement + */ + render: function AnnotationElement_render() { + throw new Error('Abstract method AnnotationElement.render called'); + } + }; + + return AnnotationElement; +})(); + +/** + * @class + * @alias LinkAnnotationElement + */ +var LinkAnnotationElement = (function LinkAnnotationElementClosure() { + function LinkAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(LinkAnnotationElement, AnnotationElement, { + /** + * Render the link annotation's HTML element in the empty container. + * + * @public + * @memberof LinkAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function LinkAnnotationElement_render() { + this.container.className = 'linkAnnotation'; + + var link = document.createElement('a'); + addLinkAttributes(link, { url: this.data.url }); + + if (!this.data.url) { + if (this.data.action) { + this._bindNamedAction(link, this.data.action); + } else { + this._bindLink(link, ('dest' in this.data) ? this.data.dest : null); + } + } + + this.container.appendChild(link); + return this.container; + }, + + /** + * Bind internal links to the link element. + * + * @private + * @param {Object} link + * @param {Object} destination + * @memberof LinkAnnotationElement + */ + _bindLink: function LinkAnnotationElement_bindLink(link, destination) { + var self = this; + + link.href = this.linkService.getDestinationHash(destination); + link.onclick = function() { + if (destination) { + self.linkService.navigateTo(destination); + } + return false; + }; + if (destination) { + link.className = 'internalLink'; + } + }, + + /** + * Bind named actions to the link element. + * + * @private + * @param {Object} link + * @param {Object} action + * @memberof LinkAnnotationElement + */ + _bindNamedAction: + function LinkAnnotationElement_bindNamedAction(link, action) { + var self = this; + + link.href = this.linkService.getAnchorUrl(''); + link.onclick = function() { + self.linkService.executeNamedAction(action); + return false; + }; + link.className = 'internalLink'; + } + }); + + return LinkAnnotationElement; +})(); + +/** + * @class + * @alias TextAnnotationElement + */ +var TextAnnotationElement = (function TextAnnotationElementClosure() { + function TextAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(TextAnnotationElement, AnnotationElement, { + /** + * Render the text annotation's HTML element in the empty container. + * + * @public + * @memberof TextAnnotationElement + * @returns {HTMLSectionElement} + */ + 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 = PDFJS.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) { + var popupElement = new PopupElement({ + container: this.container, + trigger: image, + color: this.data.color, + title: this.data.title, + contents: this.data.contents, + hideWrapper: true + }); + var popup = popupElement.render(); + + // Position the popup next to the Text annotation's container. + popup.style.left = image.style.width; + + this.container.appendChild(popup); + } + + this.container.appendChild(image); + return this.container; + } + }); + + return TextAnnotationElement; +})(); + +/** + * @class + * @alias WidgetAnnotationElement + */ +var WidgetAnnotationElement = (function WidgetAnnotationElementClosure() { + function WidgetAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(WidgetAnnotationElement, AnnotationElement, { + /** + * Render the widget annotation's HTML element in the empty container. + * + * @public + * @memberof WidgetAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function WidgetAnnotationElement_render() { + var content = document.createElement('div'); + content.textContent = this.data.fieldValue; + var textAlignment = this.data.textAlignment; + content.style.textAlign = ['left', 'center', 'right'][textAlignment]; + content.style.verticalAlign = 'middle'; + content.style.display = 'table-cell'; + + var font = (this.data.fontRefName ? + this.page.commonObjs.getData(this.data.fontRefName) : null); + this._setTextStyle(content, font); + + this.container.appendChild(content); + return this.container; + }, + + /** + * Apply text styles to the text in the element. + * + * @private + * @param {HTMLDivElement} element + * @param {Object} font + * @memberof WidgetAnnotationElement + */ + _setTextStyle: + function WidgetAnnotationElement_setTextStyle(element, font) { + // TODO: This duplicates some of the logic in CanvasGraphics.setFont(). + 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'); + + // Use a reasonable default font if the font doesn't specify a fallback. + var fontFamily = font.loadedName ? '"' + font.loadedName + '", ' : ''; + var fallbackName = font.fallbackName || 'Helvetica, sans-serif'; + style.fontFamily = fontFamily + fallbackName; + } + }); + + return WidgetAnnotationElement; +})(); + +/** + * @class + * @alias PopupAnnotationElement + */ +var PopupAnnotationElement = (function PopupAnnotationElementClosure() { + function PopupAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(PopupAnnotationElement, AnnotationElement, { + /** + * Render the popup annotation's HTML element in the empty container. + * + * @public + * @memberof PopupAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function PopupAnnotationElement_render() { + this.container.className = 'popupAnnotation'; + + 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 + }); + + // Position the popup next to the parent annotation's container. + // PDF viewers ignore a popup annotation's rectangle. + var parentLeft = parseFloat(parentElement.style.left); + var parentWidth = parseFloat(parentElement.style.width); + 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; +})(); + +/** + * @class + * @alias PopupElement + */ +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 = /** @lends PopupElement.prototype */ { + /** + * Render the popup's HTML element. + * + * @public + * @memberof PopupElement + * @returns {HTMLSectionElement} + */ + render: function PopupElement_render() { + var wrapper = document.createElement('div'); + wrapper.className = 'popupWrapper'; + + // For Popup annotations we hide the entire section because it contains + // only the popup. However, for Text annotations without a separate Popup + // annotation, we cannot hide the entire container as the image would + // disappear too. In that special case, hiding the wrapper suffices. + 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) { + // Enlighten the 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.makeCssRgb(r | 0, g | 0, b | 0); + } + + var contents = this._formatContents(this.contents); + var title = document.createElement('h1'); + title.textContent = this.title; + + // Attach the event listeners to the trigger element. + 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; + }, + + /** + * Format the contents of the popup by adding newlines where necessary. + * + * @private + * @param {string} contents + * @memberof PopupElement + * @returns {HTMLParagraphElement} + */ + _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 the visibility of the popup. + * + * @private + * @memberof PopupElement + */ + _toggle: function PopupElement_toggle() { + if (this.pinned) { + this._hide(true); + } else { + this._show(true); + } + }, + + /** + * Show the popup. + * + * @private + * @param {boolean} pin + * @memberof PopupElement + */ + _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 the popup. + * + * @private + * @param {boolean} unpin + * @memberof PopupElement + */ + _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; +})(); + +/** + * @class + * @alias HighlightAnnotationElement + */ +var HighlightAnnotationElement = ( + function HighlightAnnotationElementClosure() { + function HighlightAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(HighlightAnnotationElement, AnnotationElement, { + /** + * Render the highlight annotation's HTML element in the empty container. + * + * @public + * @memberof HighlightAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function HighlightAnnotationElement_render() { + this.container.className = 'highlightAnnotation'; + return this.container; + } + }); + + return HighlightAnnotationElement; +})(); + +/** + * @class + * @alias UnderlineAnnotationElement + */ +var UnderlineAnnotationElement = ( + function UnderlineAnnotationElementClosure() { + function UnderlineAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(UnderlineAnnotationElement, AnnotationElement, { + /** + * Render the underline annotation's HTML element in the empty container. + * + * @public + * @memberof UnderlineAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function UnderlineAnnotationElement_render() { + this.container.className = 'underlineAnnotation'; + return this.container; + } + }); + + return UnderlineAnnotationElement; +})(); + +/** + * @class + * @alias SquigglyAnnotationElement + */ +var SquigglyAnnotationElement = (function SquigglyAnnotationElementClosure() { + function SquigglyAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(SquigglyAnnotationElement, AnnotationElement, { + /** + * Render the squiggly annotation's HTML element in the empty container. + * + * @public + * @memberof SquigglyAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function SquigglyAnnotationElement_render() { + this.container.className = 'squigglyAnnotation'; + return this.container; + } + }); + + return SquigglyAnnotationElement; +})(); + +/** + * @class + * @alias StrikeOutAnnotationElement + */ +var StrikeOutAnnotationElement = ( + function StrikeOutAnnotationElementClosure() { + function StrikeOutAnnotationElement(parameters) { + AnnotationElement.call(this, parameters); + } + + Util.inherit(StrikeOutAnnotationElement, AnnotationElement, { + /** + * Render the strikeout annotation's HTML element in the empty container. + * + * @public + * @memberof StrikeOutAnnotationElement + * @returns {HTMLSectionElement} + */ + render: function StrikeOutAnnotationElement_render() { + this.container.className = 'strikeoutAnnotation'; + return this.container; + } + }); + + return StrikeOutAnnotationElement; +})(); + +/** + * @typedef {Object} AnnotationLayerParameters + * @property {PageViewport} viewport + * @property {HTMLDivElement} div + * @property {Array} annotations + * @property {PDFPage} page + * @property {IPDFLinkService} linkService + */ + +/** + * @class + * @alias AnnotationLayer + */ +var AnnotationLayer = (function AnnotationLayerClosure() { + return { + /** + * Render a new annotation layer with all annotation elements. + * + * @public + * @param {AnnotationLayerParameters} parameters + * @memberof AnnotationLayer + */ + 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 || !data.hasHtml) { + continue; + } + + var properties = { + data: data, + layer: parameters.div, + page: parameters.page, + viewport: parameters.viewport, + linkService: parameters.linkService + }; + var element = annotationElementFactory.create(properties); + parameters.div.appendChild(element.render()); + } + }, + + /** + * Update the annotation elements on existing annotation layer. + * + * @public + * @param {AnnotationLayerParameters} parameters + * @memberof AnnotationLayer + */ + 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) { + CustomStyle.setProp('transform', element, + 'matrix(' + parameters.viewport.transform.join(',') + ')'); + } + } + parameters.div.removeAttribute('hidden'); + } + }; +})(); + +PDFJS.AnnotationLayer = AnnotationLayer; + +exports.AnnotationLayer = AnnotationLayer; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayFontLoader = {}), root.pdfjsSharedUtil, + root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedUtil, sharedGlobal) { + +var assert = sharedUtil.assert; +var bytesToString = sharedUtil.bytesToString; +var string32 = sharedUtil.string32; +var shadow = sharedUtil.shadow; +var warn = sharedUtil.warn; + +var PDFJS = sharedGlobal.PDFJS; +var globalScope = sharedGlobal.globalScope; +var isWorker = sharedGlobal.isWorker; + +function FontLoader(docId) { + this.docId = docId; + this.styleElement = null; + this.nativeFontFaces = []; + this.loadTestFontId = 0; + this.loadingContext = { + requests: [], + nextRequestId: 0 + }; +} +FontLoader.prototype = { + insertRule: function fontLoaderInsertRule(rule) { + var styleElement = this.styleElement; + if (!styleElement) { + styleElement = this.styleElement = document.createElement('style'); + styleElement.id = 'PDFJS_FONT_STYLE_TAG_' + this.docId; + document.documentElement.getElementsByTagName('head')[0].appendChild( + styleElement); + } + + var styleSheet = styleElement.sheet; + styleSheet.insertRule(rule, styleSheet.cssRules.length); + }, + + clear: function fontLoaderClear() { + var styleElement = this.styleElement; + if (styleElement) { + styleElement.parentNode.removeChild(styleElement); + styleElement = this.styleElement = null; + } + this.nativeFontFaces.forEach(function(nativeFontFace) { + document.fonts.delete(nativeFontFace); + }); + this.nativeFontFaces.length = 0; + }, + get loadTestFont() { + // This is a CFF font with 1 glyph for '.' that fills its entire width and + // height. + return shadow(this, 'loadTestFont', atob( + 'T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQAFQ' + + 'AABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAAALwA' + + 'AAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgAAAAGbm' + + 'FtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1AAsD6AAA' + + 'AADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD6AAAAAAD6A' + + 'ABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACMAooCvAAAAeAA' + + 'MQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4DIP84AFoDIQAAAA' + + 'AAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAAAAEAAQAAAAEAAAAA' + + 'AAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUAAQAAAAEAAAAAAAYAAQ' + + 'AAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgABAAMAAQQJAAMAAgABAAMA' + + 'AQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABYAAAAAAAAAwAAAAMAAAAcAA' + + 'EAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAAAC7////TAAEAAAAAAAABBgAA' + + 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAA' + + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAA' + + 'AAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAAAAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgc' + + 'A/gXBIwMAYuL+nz5tQXkD5j3CBLnEQACAQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWF' + + 'hYWFhYWFhYAAABAQAADwACAQEEE/t3Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQA' + + 'AAAAAAABAAAAAMmJbzEAAAAAzgTjFQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAg' + + 'ABAAAAAAAAAAAD6AAAAAAAAA==' + )); + }, + + addNativeFontFace: function fontLoader_addNativeFontFace(nativeFontFace) { + this.nativeFontFaces.push(nativeFontFace); + document.fonts.add(nativeFontFace); + }, + + bind: function fontLoaderBind(fonts, callback) { + assert(!isWorker, 'bind() shall be called from main thread'); + + var rules = []; + var fontsToLoad = []; + var fontLoadPromises = []; + var getNativeFontPromise = function(nativeFontFace) { + // Return a promise that is always fulfilled, even when the font fails to + // load. + return nativeFontFace.loaded.catch(function(e) { + warn('Failed to load font "' + nativeFontFace.family + '": ' + e); + }); + }; + for (var i = 0, ii = fonts.length; i < ii; i++) { + var font = fonts[i]; + + // Add the font to the DOM only once or skip if the font + // is already loaded. + if (font.attached || font.loading === false) { + continue; + } + font.attached = true; + + if (FontLoader.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 (FontLoader.isFontLoadingAPISupported) { + Promise.all(fontLoadPromises).then(function() { + request.complete(); + }); + } else if (rules.length > 0 && !FontLoader.isSyncFontLoadingSupported) { + this.prepareFontLoadEvent(rules, fontsToLoad, request); + } else { + request.complete(); + } + }, + + queueLoadingCallback: function FontLoader_queueLoadingCallback(callback) { + function LoadLoader_completeRequest() { + assert(!request.end, 'completeRequest() cannot be called twice'); + request.end = Date.now(); + + // sending all completed requests in order how they were queued + 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; + }, + + prepareFontLoadEvent: function fontLoaderPrepareFontLoadEvent(rules, + fonts, + request) { + /** Hack begin */ + // There's currently no event when a font has finished downloading so the + // following code is a dirty hack to 'guess' when a font is + // ready. It's assumed fonts are loaded in order, so add a known test + // font after the desired fonts and then test for the loading of that + // test font. + + 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++; + // With setTimeout clamping this gives the font ~100ms to load. + if(called > 30) { + 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++; + // Chromium seems to cache fonts based on a hash of the actual font data, + // so the font must be modified for each load test else it will appear to + // be loaded already. + // TODO: This could maybe be made faster by avoiding the btoa of the full + // font by splitting it in chunks before hand and padding the font id. + var data = this.loadTestFont; + var COMMENT_OFFSET = 976; // has to be on 4 byte boundary (for checksum) + data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, + loadTestFontId); + // CFF checksum is important for IE, adjusting it + var CFF_CHECKSUM_OFFSET = 16; + var XXXX_VALUE = 0x58585858; // the "comment" filled with 'X' + 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) { // align to 4 bytes boundary + checksum = (checksum - XXXX_VALUE + + int32(loadTestFontId + 'XXX', i)) | 0; + } + data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, 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(); + }); + /** Hack end */ + } +}; +FontLoader.isFontLoadingAPISupported = (!isWorker && + typeof document !== 'undefined' && !!document.fonts); +Object.defineProperty(FontLoader, 'isSyncFontLoadingSupported', { + get: function () { + var supported = false; + + // User agent string sniffing is bad, but there is no reliable way to tell + // if font is fully loaded and ready to be used with canvas. + var userAgent = window.navigator.userAgent; + var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(userAgent); + if (m && m[1] >= 14) { + supported = true; + } + // TODO other browsers + if (userAgent === 'node') { + supported = true; + } + return shadow(FontLoader, 'isSyncFontLoadingSupported', supported); + }, + enumerable: true, + configurable: true +}); + +var FontFaceObject = (function FontFaceObjectClosure() { + function FontFaceObject(translatedData) { + this.compiledGlyphs = {}; + // importing translated data + for (var i in translatedData) { + this[i] = translatedData[i]; + } + } + Object.defineProperty(FontFaceObject, 'isEvalSupported', { + get: function () { + var evalSupport = false; + if (PDFJS.isEvalSupported) { + try { + /* jshint evil: true */ + new Function(''); + evalSupport = true; + } catch (e) {} + } + return shadow(this, 'isEvalSupported', evalSupport); + }, + enumerable: true, + configurable: true + }); + FontFaceObject.prototype = { + createNativeFontFace: function FontFaceObject_createNativeFontFace() { + if (!this.data) { + return null; + } + + if (PDFJS.disableFontFace) { + this.disableFontFace = true; + return null; + } + + var nativeFontFace = new FontFace(this.loadedName, this.data, {}); + + if (PDFJS.pdfBug && 'FontInspector' in globalScope && + globalScope['FontInspector'].enabled) { + globalScope['FontInspector'].fontAdded(this); + } + return nativeFontFace; + }, + + createFontFaceRule: function FontFaceObject_createFontFaceRule() { + if (!this.data) { + return null; + } + + if (PDFJS.disableFontFace) { + this.disableFontFace = true; + return null; + } + + var data = bytesToString(new Uint8Array(this.data)); + var fontName = this.loadedName; + + // Add the font-face rule to the document + var url = ('url(data:' + this.mimetype + ';base64,' + + window.btoa(data) + ');'); + var rule = '@font-face { font-family:"' + fontName + '";src:' + url + '}'; + + if (PDFJS.pdfBug && 'FontInspector' in globalScope && + globalScope['FontInspector'].enabled) { + globalScope['FontInspector'].fontAdded(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 we can, compile cmds into JS for MAXIMUM SPEED + if (FontFaceObject.isEvalSupported) { + 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'; + } + /* jshint -W054 */ + this.compiledGlyphs[character] = new Function('c', 'size', js); + } else { + // But fall back on using Function.prototype.apply() if we're + // blocked from using eval() for whatever reason (like CSP policies) + 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; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayMetadata = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var error = sharedUtil.error; + +var Metadata = PDFJS.Metadata = (function MetadataClosure() { + 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 && false ? String.fromCharCode(code) : + '&#x' + (0x10000 + code).toString(16).substring(1) + ';'; + } + return '>' + chars; + }); + } + + function Metadata(meta) { + if (typeof meta === 'string') { + // Ghostscript produces invalid metadata + meta = fixMetadata(meta); + + var parser = new DOMParser(); + meta = parser.parseFromString(meta, 'application/xml'); + } else if (!(meta instanceof Document)) { + error('Metadata: Invalid metadata object'); + } + + this.metaDocument = meta; + this.metadata = {}; + this.parse(); + } + + Metadata.prototype = { + parse: function Metadata_parse() { + var doc = this.metaDocument; + var rdf = doc.documentElement; + + if (rdf.nodeName.toLowerCase() !== 'rdf:rdf') { // Wrapped in + 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'; + } + }; + + return Metadata; +})(); + +exports.Metadata = Metadata; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplaySVG = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX; +var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX; +var ImageKind = sharedUtil.ImageKind; +var OPS = sharedUtil.OPS; +var Util = sharedUtil.Util; +var isNum = sharedUtil.isNum; +var isArray = sharedUtil.isArray; +var warn = sharedUtil.warn; + +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 encode(imgData, kind) { + var width = imgData.width; + var height = imgData.height; + var bitDepth, colorType, lineSize; + var bytes = imgData.data; + + switch (kind) { + case ImageKind.GRAYSCALE_1BPP: + colorType = 0; + bitDepth = 1; + lineSize = (width + 7) >> 3; + break; + case ImageKind.RGB_24BPP: + colorType = 2; + bitDepth = 8; + lineSize = width * 3; + break; + case ImageKind.RGBA_32BPP: + colorType = 6; + bitDepth = 8; + lineSize = width * 4; + break; + default: + throw new Error('invalid format'); + } + + // prefix every row with predictor 0 + var literals = new Uint8Array((1 + lineSize) * height); + var offsetLiterals = 0, offsetBytes = 0; + var y, i; + for (y = 0; y < height; ++y) { + literals[offsetLiterals++] = 0; // no prediction + literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), + offsetLiterals); + offsetBytes += lineSize; + offsetLiterals += lineSize; + } + + if (kind === ImageKind.GRAYSCALE_1BPP) { + // inverting for B/W + offsetLiterals = 0; + for (y = 0; y < height; y++) { + offsetLiterals++; // skipping predictor + 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, // bit depth + colorType, // color type + 0x00, // compression method + 0x00, // filter method + 0x00 // interlace method + ]); + + 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; // compression method and flags + idat[pi++] = 0x9c; // flags + + var pos = 0; + while (len > maxBlockLength) { + // writing non-final DEFLATE blocks type 0 and length of 65535 + 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; + } + + // writing non-final DEFLATE blocks type 0 + 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); // checksum + idat[pi++] = adler >> 24 & 0xff; + idat[pi++] = adler >> 16 & 0xff; + idat[pi++] = adler >> 8 & 0xff; + idat[pi++] = adler & 0xff; + + // PNG will consists: header, IHDR+data, IDAT+data, and IEND. + 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 PDFJS.createObjectURL(data, 'image/png'); + } + + return function convertImgDataToPng(imgData) { + var kind = (imgData.kind === undefined ? + ImageKind.GRAYSCALE_1BPP : imgData.kind); + return encode(imgData, kind); + }; +})(); + +var SVGExtraState = (function SVGExtraStateClosure() { + function SVGExtraState() { + this.fontSizeScale = 1; + this.fontWeight = SVG_DEFAULTS.fontWeight; + this.fontSize = 0; + + this.textMatrix = IDENTITY_MATRIX; + this.fontMatrix = FONT_IDENTITY_MATRIX; + this.leading = 0; + + // Current point (in user coordinates) + this.x = 0; + this.y = 0; + + // Start of text line (in text coordinates) + this.lineX = 0; + this.lineY = 0; + + // Character and word spacing + this.charSpacing = 0; + this.wordSpacing = 0; + this.textHScale = 1; + this.textRise = 0; + + // Default foreground and background colors + 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 = []; + + // Clipping + this.clipId = ''; + this.pendingClip = false; + + 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; +})(); + +var SVGGraphics = (function SVGGraphicsClosure() { + function createScratchSVG(width, height) { + var NS = 'http://www.w3.org/2000/svg'; + var svg = document.createElementNS(NS, 'svg:svg'); + svg.setAttributeNS(null, 'version', '1.1'); + svg.setAttributeNS(null, 'width', width + 'px'); + svg.setAttributeNS(null, 'height', height + 'px'); + svg.setAttributeNS(null, 'viewBox', '0 0 ' + width + ' ' + height); + return svg; + } + + 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; + } + + /** + * Formats float number. + * @param value {number} number to format. + * @returns {string} + */ + function pf(value) { + if (value === (value | 0)) { // integer number + return value.toString(); + } + var s = value.toFixed(10); + var i = s.length - 1; + if (s[i] !== '0') { + return s; + } + // removing trailing zeros + do { + i--; + } while (s[i] === '0'); + return s.substr(0, s[i] === '.' ? i : i + 1); + } + + /** + * Formats transform matrix. The standard rotation, scale and translate + * matrices are replaced by their shorter forms, and for identity matrix + * returns empty string to save the memory. + * @param m {Array} matrix to format. + * @returns {string} + */ + 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) { + this.current = new SVGExtraState(); + this.transformMatrix = IDENTITY_MATRIX; // Graphics state matrix + this.transformStack = []; + this.extraStack = []; + this.commonObjs = commonObjs; + this.objs = objs; + this.pendingEOFill = false; + + this.embedFonts = false; + this.embeddedFonts = {}; + this.cssStyle = null; + } + + 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.tgrp = document.createElementNS(NS, 'svg:g'); + this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + this.pgrp.appendChild(this.tgrp); + }, + + group: function SVGGraphics_group(items) { + this.save(); + this.executeOpTree(items); + this.restore(); + }, + + loadDependencies: function SVGGraphics_loadDependencies(operatorList) { + var fnArray = operatorList.fnArray; + var fnArrayLen = fnArray.length; + var argsArray = operatorList.argsArray; + + var self = this; + for (var i = 0; i < fnArrayLen; i++) { + if (OPS.dependency === fnArray[i]) { + var deps = argsArray[i]; + for (var n = 0, nn = deps.length; n < nn; n++) { + var obj = deps[n]; + var common = obj.substring(0, 2) === 'g_'; + var promise; + if (common) { + promise = new Promise(function(resolve) { + self.commonObjs.get(obj, resolve); + }); + } else { + promise = new Promise(function(resolve) { + self.objs.get(obj, resolve); + }); + } + this.current.dependencies.push(promise); + } + } + } + return Promise.all(this.current.dependencies); + }, + + transform: function SVGGraphics_transform(a, b, c, d, e, f) { + var transformMatrix = [a, b, c, d, e, f]; + this.transformMatrix = PDFJS.Util.transform(this.transformMatrix, + transformMatrix); + + this.tgrp = document.createElementNS(NS, 'svg:g'); + this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + }, + + getSVG: function SVGGraphics_getSVG(operatorList, viewport) { + this.svg = createScratchSVG(viewport.width, viewport.height); + this.viewport = viewport; + + return this.loadDependencies(operatorList).then(function () { + this.transformMatrix = IDENTITY_MATRIX; + this.pgrp = document.createElementNS(NS, 'svg:g'); // Parent group + this.pgrp.setAttributeNS(null, 'transform', pm(viewport.transform)); + this.tgrp = document.createElementNS(NS, 'svg:g'); // Transform group + this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + this.defs = document.createElementNS(NS, 'svg:defs'); + this.pgrp.appendChild(this.defs); + this.pgrp.appendChild(this.tgrp); + this.svg.appendChild(this.pgrp); + var opTree = this.convertOpList(operatorList); + this.executeOpTree(opTree); + return this.svg; + }.bind(this)); + }, + + 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 OPS) { + REVOPS[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 OPS.beginText: + this.beginText(); + break; + case OPS.setLeading: + this.setLeading(args); + break; + case OPS.setLeadingMoveText: + this.setLeadingMoveText(args[0], args[1]); + break; + case OPS.setFont: + this.setFont(args); + break; + case OPS.showText: + this.showText(args[0]); + break; + case OPS.showSpacedText: + this.showText(args[0]); + break; + case OPS.endText: + this.endText(); + break; + case OPS.moveText: + this.moveText(args[0], args[1]); + break; + case OPS.setCharSpacing: + this.setCharSpacing(args[0]); + break; + case OPS.setWordSpacing: + this.setWordSpacing(args[0]); + break; + case OPS.setHScale: + this.setHScale(args[0]); + break; + case OPS.setTextMatrix: + this.setTextMatrix(args[0], args[1], args[2], + args[3], args[4], args[5]); + break; + case OPS.setLineWidth: + this.setLineWidth(args[0]); + break; + case OPS.setLineJoin: + this.setLineJoin(args[0]); + break; + case OPS.setLineCap: + this.setLineCap(args[0]); + break; + case OPS.setMiterLimit: + this.setMiterLimit(args[0]); + break; + case OPS.setFillRGBColor: + this.setFillRGBColor(args[0], args[1], args[2]); + break; + case OPS.setStrokeRGBColor: + this.setStrokeRGBColor(args[0], args[1], args[2]); + break; + case OPS.setDash: + this.setDash(args[0], args[1]); + break; + case OPS.setGState: + this.setGState(args[0]); + break; + case OPS.fill: + this.fill(); + break; + case OPS.eoFill: + this.eoFill(); + break; + case OPS.stroke: + this.stroke(); + break; + case OPS.fillStroke: + this.fillStroke(); + break; + case OPS.eoFillStroke: + this.eoFillStroke(); + break; + case OPS.clip: + this.clip('nonzero'); + break; + case OPS.eoClip: + this.clip('evenodd'); + break; + case OPS.paintSolidColorImageMask: + this.paintSolidColorImageMask(); + break; + case OPS.paintJpegXObject: + this.paintJpegXObject(args[0], args[1], args[2]); + break; + case OPS.paintImageXObject: + this.paintImageXObject(args[0]); + break; + case OPS.paintInlineImageXObject: + this.paintInlineImageXObject(args[0]); + break; + case OPS.paintImageMaskXObject: + this.paintImageMaskXObject(args[0]); + break; + case OPS.paintFormXObjectBegin: + this.paintFormXObjectBegin(args[0], args[1]); + break; + case OPS.paintFormXObjectEnd: + this.paintFormXObjectEnd(); + break; + case OPS.closePath: + this.closePath(); + break; + case OPS.closeStroke: + this.closeStroke(); + break; + case OPS.closeFillStroke: + this.closeFillStroke(); + break; + case OPS.nextLine: + this.nextLine(); + break; + case OPS.transform: + this.transform(args[0], args[1], args[2], args[3], + args[4], args[5]); + break; + case OPS.constructPath: + this.constructPath(args[0], args[1]); + break; + case OPS.endPath: + this.endPath(); + break; + case 92: + this.group(opTree[x].items); + break; + default: + warn('Unimplemented method '+ 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 = IDENTITY_MATRIX; + this.current.lineMatrix = 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) { + // word break + x += fontDirection * wordSpacing; + continue; + } else if (isNum(glyph)) { + x += -glyph * fontSize * 0.001; + continue; + } + current.xcoords.push(current.x + x * textHScale); + + var width = glyph.width; + var character = glyph.fontChar; + var charWidth = width * widthAdvanceScale + charSpacing * 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.tgrp.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 = PDFJS.createObjectURL(fontObj.data, fontObj.mimetype); + 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 : 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() { + if (this.current.pendingClip) { + this.cgrp.appendChild(this.tgrp); + this.pgrp.appendChild(this.cgrp); + } else { + this.pgrp.appendChild(this.tgrp); + } + this.tgrp = document.createElementNS(NS, 'svg:g'); + this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + }, + + // Path properties + 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; + }, + setStrokeRGBColor: function SVGGraphics_setStrokeRGBColor(r, g, b) { + var color = Util.makeCssRgb(r, g, b); + this.current.strokeColor = color; + }, + setFillRGBColor: function SVGGraphics_setFillRGBColor(r, g, b) { + var color = 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 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 OPS.moveTo: + x = args[j++]; + y = args[j++]; + d.push('M', pf(x), pf(y)); + break; + case OPS.lineTo: + x = args[j++]; + y = args[j++]; + d.push('L', pf(x) , pf(y)); + break; + case 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 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 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 OPS.closePath: + d.push('Z'); + break; + } + } + current.path.setAttributeNS(null, 'd', d.join(' ')); + current.path.setAttributeNS(null, 'stroke-miterlimit', + pf(current.miterLimit)); + current.path.setAttributeNS(null, 'stroke-linecap', current.lineCap); + current.path.setAttributeNS(null, 'stroke-linejoin', current.lineJoin); + current.path.setAttributeNS(null, 'stroke-width', + pf(current.lineWidth) + 'px'); + current.path.setAttributeNS(null, 'stroke-dasharray', + current.dashArray.map(pf).join(' ')); + current.path.setAttributeNS(null, 'stroke-dashoffset', + pf(current.dashPhase) + 'px'); + current.path.setAttributeNS(null, 'fill', 'none'); + + this.tgrp.appendChild(current.path); + if (current.pendingClip) { + this.cgrp.appendChild(this.tgrp); + this.pgrp.appendChild(this.cgrp); + } else { + this.pgrp.appendChild(this.tgrp); + } + // Saving a reference in current.element so that it can be addressed + // in 'fill' and 'stroke' + current.element = current.path; + current.setCurrentPoint(x, y); + }, + + endPath: function SVGGraphics_endPath() { + var current = this.current; + if (current.pendingClip) { + this.cgrp.appendChild(this.tgrp); + this.pgrp.appendChild(this.cgrp); + } else { + this.pgrp.appendChild(this.tgrp); + } + this.tgrp = document.createElementNS(NS, 'svg:g'); + this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + }, + + clip: function SVGGraphics_clip(type) { + var current = this.current; + // Add current path to clipping path + current.clipId = 'clippath' + clipCount; + clipCount++; + this.clippath = document.createElementNS(NS, 'svg:clipPath'); + this.clippath.setAttributeNS(null, 'id', current.clipId); + var clipElement = current.element.cloneNode(); + if (type === 'evenodd') { + clipElement.setAttributeNS(null, 'clip-rule', 'evenodd'); + } else { + clipElement.setAttributeNS(null, 'clip-rule', 'nonzero'); + } + this.clippath.setAttributeNS(null, 'transform', pm(this.transformMatrix)); + this.clippath.appendChild(clipElement); + this.defs.appendChild(this.clippath); + + // Create a new group with that attribute + current.pendingClip = true; + this.cgrp = document.createElementNS(NS, 'svg:g'); + this.cgrp.setAttributeNS(null, 'clip-path', + 'url(#' + current.clipId + ')'); + this.pgrp.appendChild(this.cgrp); + }, + + 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 'RI': + break; + case 'FL': + break; + case 'Font': + this.setFont(value); + break; + case 'CA': + break; + case 'ca': + break; + case 'BM': + break; + case 'SMask': + break; + } + } + }, + + fill: function SVGGraphics_fill() { + var current = this.current; + current.element.setAttributeNS(null, 'fill', current.fillColor); + }, + + stroke: function SVGGraphics_stroke() { + var current = this.current; + current.element.setAttributeNS(null, 'stroke', current.strokeColor); + current.element.setAttributeNS(null, 'fill', 'none'); + }, + + eoFill: function SVGGraphics_eoFill() { + var current = this.current; + current.element.setAttributeNS(null, 'fill', current.fillColor); + current.element.setAttributeNS(null, 'fill-rule', 'evenodd'); + }, + + fillStroke: function SVGGraphics_fillStroke() { + // Order is important since stroke wants fill to be none. + // First stroke, then if fill needed, it will be overwritten. + 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.tgrp.appendChild(rect); + }, + + paintJpegXObject: function SVGGraphics_paintJpegXObject(objId, w, h) { + var current = this.current; + 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', imgObj.width + 'px'); + imgEl.setAttributeNS(null, 'height', imgObj.height + 'px'); + imgEl.setAttributeNS(null, 'x', '0'); + imgEl.setAttributeNS(null, 'y', pf(-h)); + imgEl.setAttributeNS(null, 'transform', + 'scale(' + pf(1 / w) + ' ' + pf(-1 / h) + ')'); + + this.tgrp.appendChild(imgEl); + if (current.pendingClip) { + this.cgrp.appendChild(this.tgrp); + this.pgrp.appendChild(this.cgrp); + } else { + this.pgrp.appendChild(this.tgrp); + } + }, + + paintImageXObject: function SVGGraphics_paintImageXObject(objId) { + var imgData = this.objs.get(objId); + if (!imgData) { + warn('Dependent image isn\'t ready yet'); + return; + } + this.paintInlineImageXObject(imgData); + }, + + paintInlineImageXObject: + function SVGGraphics_paintInlineImageXObject(imgData, mask) { + var current = this.current; + var width = imgData.width; + var height = imgData.height; + + var imgSrc = convertImgDataToPng(imgData); + 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)); + 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.tgrp.appendChild(imgEl); + } + if (current.pendingClip) { + this.cgrp.appendChild(this.tgrp); + this.pgrp.appendChild(this.cgrp); + } else { + this.pgrp.appendChild(this.tgrp); + } + }, + + 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.tgrp.appendChild(rect); + + this.paintInlineImageXObject(imgData, mask); + }, + + paintFormXObjectBegin: + function SVGGraphics_paintFormXObjectBegin(matrix, bbox) { + this.save(); + + if (isArray(matrix) && matrix.length === 6) { + this.transform(matrix[0], matrix[1], matrix[2], + matrix[3], matrix[4], matrix[5]); + } + + if (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() { + this.restore(); + } + }; + return SVGGraphics; +})(); + +PDFJS.SVGGraphics = SVGGraphics; + +exports.SVGGraphics = SVGGraphics; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayTextLayer = {}), root.pdfjsSharedUtil, + root.pdfjsDisplayDOMUtils, root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedUtil, displayDOMUtils, sharedGlobal) { + +var Util = sharedUtil.Util; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var CustomStyle = displayDOMUtils.CustomStyle; +var PDFJS = sharedGlobal.PDFJS; + +/** + * Text layer render parameters. + * + * @typedef {Object} TextLayerRenderParameters + * @property {TextContent} textContent - Text content to render (the object is + * returned by the page's getTextContent() method). + * @property {HTMLElement} container - HTML element that will contain text runs. + * @property {PDFJS.PageViewport} viewport - The target viewport to properly + * layout the text runs. + * @property {Array} textDivs - (optional) HTML elements that are correspond + * the text items of the textContent input. This is output and shall be + * initially be set to empty array. + * @property {number} timeout - (optional) Delay in milliseconds before + * rendering of the text runs occurs. + */ +var renderTextLayer = (function renderTextLayerClosure() { + var MAX_TEXT_DIVS_TO_RENDER = 100000; + + var NonWhitespaceRegexp = /\S/; + + function isAllWhitespace(str) { + return !NonWhitespaceRegexp.test(str); + } + + function appendText(textDivs, viewport, geom, styles) { + var style = styles[geom.fontName]; + var textDiv = document.createElement('div'); + textDivs.push(textDiv); + if (isAllWhitespace(geom.str)) { + textDiv.dataset.isWhitespace = true; + return; + } + var tx = Util.transform(viewport.transform, geom.transform); + var angle = Math.atan2(tx[1], tx[0]); + if (style.vertical) { + angle += Math.PI / 2; + } + var fontHeight = Math.sqrt((tx[2] * tx[2]) + (tx[3] * tx[3])); + var fontAscent = fontHeight; + if (style.ascent) { + fontAscent = style.ascent * fontAscent; + } else if (style.descent) { + fontAscent = (1 + style.descent) * fontAscent; + } + + var left; + var top; + if (angle === 0) { + left = tx[4]; + top = tx[5] - fontAscent; + } else { + left = tx[4] + (fontAscent * Math.sin(angle)); + top = tx[5] - (fontAscent * Math.cos(angle)); + } + textDiv.style.left = left + 'px'; + textDiv.style.top = top + 'px'; + textDiv.style.fontSize = fontHeight + 'px'; + textDiv.style.fontFamily = style.fontFamily; + + textDiv.textContent = geom.str; + // |fontName| is only used by the Font Inspector. This test will succeed + // when e.g. the Font Inspector is off but the Stepper is on, but it's + // not worth the effort to do a more accurate test. + if (PDFJS.pdfBug) { + textDiv.dataset.fontName = geom.fontName; + } + // Storing into dataset will convert number into string. + if (angle !== 0) { + textDiv.dataset.angle = angle * (180 / Math.PI); + } + // We don't bother scaling single-char text divs, because it has very + // little effect on text highlighting. This makes scrolling on docs with + // lots of such divs a lot faster. + if (geom.str.length > 1) { + if (style.vertical) { + textDiv.dataset.canvasWidth = geom.height * viewport.scale; + } else { + textDiv.dataset.canvasWidth = geom.width * viewport.scale; + } + } + } + + function render(task) { + if (task._canceled) { + return; + } + var textLayerFrag = task._container; + var textDivs = task._textDivs; + var capability = task._capability; + var textDivsLength = textDivs.length; + + // No point in rendering many divs as it would make the browser + // unusable even after the divs are rendered. + if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) { + capability.resolve(); + return; + } + + var canvas = document.createElement('canvas'); + canvas.mozOpaque = true; + var ctx = canvas.getContext('2d', {alpha: false}); + + var lastFontSize; + var lastFontFamily; + for (var i = 0; i < textDivsLength; i++) { + var textDiv = textDivs[i]; + if (textDiv.dataset.isWhitespace !== undefined) { + continue; + } + + var fontSize = textDiv.style.fontSize; + var fontFamily = textDiv.style.fontFamily; + + // Only build font string and set to context if different from last. + if (fontSize !== lastFontSize || fontFamily !== lastFontFamily) { + ctx.font = fontSize + ' ' + fontFamily; + lastFontSize = fontSize; + lastFontFamily = fontFamily; + } + + var width = ctx.measureText(textDiv.textContent).width; + if (width > 0) { + textLayerFrag.appendChild(textDiv); + var transform; + if (textDiv.dataset.canvasWidth !== undefined) { + // Dataset values come of type string. + var textScale = textDiv.dataset.canvasWidth / width; + transform = 'scaleX(' + textScale + ')'; + } else { + transform = ''; + } + var rotation = textDiv.dataset.angle; + if (rotation) { + transform = 'rotate(' + rotation + 'deg) ' + transform; + } + if (transform) { + CustomStyle.setProp('transform' , textDiv, transform); + } + } + } + capability.resolve(); + } + + /** + * Text layer rendering task. + * + * @param {TextContent} textContent + * @param {HTMLElement} container + * @param {PDFJS.PageViewport} viewport + * @param {Array} textDivs + * @private + */ + function TextLayerRenderTask(textContent, container, viewport, textDivs) { + this._textContent = textContent; + this._container = container; + this._viewport = viewport; + textDivs = textDivs || []; + this._textDivs = textDivs; + this._canceled = false; + this._capability = createPromiseCapability(); + this._renderTimer = null; + } + TextLayerRenderTask.prototype = { + get promise() { + return this._capability.promise; + }, + + cancel: function TextLayer_cancel() { + this._canceled = true; + if (this._renderTimer !== null) { + clearTimeout(this._renderTimer); + this._renderTimer = null; + } + this._capability.reject('canceled'); + }, + + _render: function TextLayer_render(timeout) { + var textItems = this._textContent.items; + var styles = this._textContent.styles; + var textDivs = this._textDivs; + var viewport = this._viewport; + for (var i = 0, len = textItems.length; i < len; i++) { + appendText(textDivs, viewport, textItems[i], styles); + } + + if (!timeout) { // Render right away + render(this); + } else { // Schedule + var self = this; + this._renderTimer = setTimeout(function() { + render(self); + self._renderTimer = null; + }, timeout); + } + } + }; + + + /** + * Starts rendering of the text layer. + * + * @param {TextLayerRenderParameters} renderParameters + * @returns {TextLayerRenderTask} + */ + function renderTextLayer(renderParameters) { + var task = new TextLayerRenderTask(renderParameters.textContent, + renderParameters.container, + renderParameters.viewport, + renderParameters.textDivs); + task._render(renderParameters.timeout); + return task; + } + + return renderTextLayer; +})(); + +PDFJS.renderTextLayer = renderTextLayer; + +exports.renderTextLayer = renderTextLayer; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayWebGL = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var shadow = sharedUtil.shadow; + +var WebGLUtils = (function WebGLUtilsClosure() { + function loadShader(gl, code, shaderType) { + var shader = gl.createShader(shaderType); + gl.shaderSource(shader, code); + gl.compileShader(shader); + var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS); + if (!compiled) { + var errorMsg = gl.getShaderInfoLog(shader); + throw new Error('Error during shader compilation: ' + errorMsg); + } + return shader; + } + function createVertexShader(gl, code) { + return loadShader(gl, code, gl.VERTEX_SHADER); + } + function createFragmentShader(gl, code) { + return loadShader(gl, code, gl.FRAGMENT_SHADER); + } + function createProgram(gl, shaders) { + var program = gl.createProgram(); + for (var i = 0, ii = shaders.length; i < ii; ++i) { + gl.attachShader(program, shaders[i]); + } + gl.linkProgram(program); + var linked = gl.getProgramParameter(program, gl.LINK_STATUS); + if (!linked) { + var errorMsg = gl.getProgramInfoLog(program); + throw new Error('Error during program linking: ' + errorMsg); + } + return program; + } + function createTexture(gl, image, textureId) { + gl.activeTexture(textureId); + var texture = gl.createTexture(); + gl.bindTexture(gl.TEXTURE_2D, texture); + + // Set the parameters so we can render any size image. + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + + // Upload the image into the texture. + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image); + return texture; + } + + var currentGL, currentCanvas; + function generateGL() { + if (currentGL) { + return; + } + currentCanvas = document.createElement('canvas'); + currentGL = currentCanvas.getContext('webgl', + { premultipliedalpha: false }); + } + + var smaskVertexShaderCode = '\ + attribute vec2 a_position; \ + attribute vec2 a_texCoord; \ + \ + uniform vec2 u_resolution; \ + \ + varying vec2 v_texCoord; \ + \ + void main() { \ + vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0; \ + gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1); \ + \ + v_texCoord = a_texCoord; \ + } '; + + var smaskFragmentShaderCode = '\ + precision mediump float; \ + \ + uniform vec4 u_backdrop; \ + uniform int u_subtype; \ + uniform sampler2D u_image; \ + uniform sampler2D u_mask; \ + \ + varying vec2 v_texCoord; \ + \ + void main() { \ + vec4 imageColor = texture2D(u_image, v_texCoord); \ + vec4 maskColor = texture2D(u_mask, v_texCoord); \ + if (u_backdrop.a > 0.0) { \ + maskColor.rgb = maskColor.rgb * maskColor.a + \ + u_backdrop.rgb * (1.0 - maskColor.a); \ + } \ + float lum; \ + if (u_subtype == 0) { \ + lum = maskColor.a; \ + } else { \ + lum = maskColor.r * 0.3 + maskColor.g * 0.59 + \ + maskColor.b * 0.11; \ + } \ + imageColor.a *= lum; \ + imageColor.rgb *= imageColor.a; \ + gl_FragColor = imageColor; \ + } '; + + var smaskCache = null; + + function initSmaskGL() { + var canvas, gl; + + generateGL(); + canvas = currentCanvas; + currentCanvas = null; + gl = currentGL; + currentGL = null; + + // setup a GLSL program + var vertexShader = createVertexShader(gl, smaskVertexShaderCode); + var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode); + var program = createProgram(gl, [vertexShader, fragmentShader]); + gl.useProgram(program); + + var cache = {}; + cache.gl = gl; + cache.canvas = canvas; + cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution'); + cache.positionLocation = gl.getAttribLocation(program, 'a_position'); + cache.backdropLocation = gl.getUniformLocation(program, 'u_backdrop'); + cache.subtypeLocation = gl.getUniformLocation(program, 'u_subtype'); + + var texCoordLocation = gl.getAttribLocation(program, 'a_texCoord'); + var texLayerLocation = gl.getUniformLocation(program, 'u_image'); + var texMaskLocation = gl.getUniformLocation(program, 'u_mask'); + + // provide texture coordinates for the rectangle. + var texCoordBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([ + 0.0, 0.0, + 1.0, 0.0, + 0.0, 1.0, + 0.0, 1.0, + 1.0, 0.0, + 1.0, 1.0]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(texCoordLocation); + gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0); + + gl.uniform1i(texLayerLocation, 0); + gl.uniform1i(texMaskLocation, 1); + + smaskCache = cache; + } + + function composeSMask(layer, mask, properties) { + var width = layer.width, height = layer.height; + + if (!smaskCache) { + initSmaskGL(); + } + var cache = smaskCache,canvas = cache.canvas, gl = cache.gl; + canvas.width = width; + canvas.height = height; + gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight); + gl.uniform2f(cache.resolutionLocation, width, height); + + if (properties.backdrop) { + gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], + properties.backdrop[1], properties.backdrop[2], 1); + } else { + gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0); + } + gl.uniform1i(cache.subtypeLocation, + properties.subtype === 'Luminosity' ? 1 : 0); + + // Create a textures + var texture = createTexture(gl, layer, gl.TEXTURE0); + var maskTexture = createTexture(gl, mask, gl.TEXTURE1); + + + // Create a buffer and put a single clipspace rectangle in + // it (2 triangles) + var buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([ + 0, 0, + width, 0, + 0, height, + 0, height, + width, 0, + width, height]), gl.STATIC_DRAW); + gl.enableVertexAttribArray(cache.positionLocation); + gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0); + + // draw + gl.clearColor(0, 0, 0, 0); + gl.enable(gl.BLEND); + gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA); + gl.clear(gl.COLOR_BUFFER_BIT); + + gl.drawArrays(gl.TRIANGLES, 0, 6); + + gl.flush(); + + gl.deleteTexture(texture); + gl.deleteTexture(maskTexture); + gl.deleteBuffer(buffer); + + return canvas; + } + + var figuresVertexShaderCode = '\ + attribute vec2 a_position; \ + attribute vec3 a_color; \ + \ + uniform vec2 u_resolution; \ + uniform vec2 u_scale; \ + uniform vec2 u_offset; \ + \ + varying vec4 v_color; \ + \ + void main() { \ + vec2 position = (a_position + u_offset) * u_scale; \ + vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0; \ + gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1); \ + \ + v_color = vec4(a_color / 255.0, 1.0); \ + } '; + + var figuresFragmentShaderCode = '\ + precision mediump float; \ + \ + varying vec4 v_color; \ + \ + void main() { \ + gl_FragColor = v_color; \ + } '; + + var figuresCache = null; + + function initFiguresGL() { + var canvas, gl; + + generateGL(); + canvas = currentCanvas; + currentCanvas = null; + gl = currentGL; + currentGL = null; + + // setup a GLSL program + var vertexShader = createVertexShader(gl, figuresVertexShaderCode); + var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode); + var program = createProgram(gl, [vertexShader, fragmentShader]); + gl.useProgram(program); + + var cache = {}; + cache.gl = gl; + cache.canvas = canvas; + cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution'); + cache.scaleLocation = gl.getUniformLocation(program, 'u_scale'); + cache.offsetLocation = gl.getUniformLocation(program, 'u_offset'); + cache.positionLocation = gl.getAttribLocation(program, 'a_position'); + cache.colorLocation = gl.getAttribLocation(program, 'a_color'); + + figuresCache = cache; + } + + function drawFigures(width, height, backgroundColor, figures, context) { + if (!figuresCache) { + initFiguresGL(); + } + var cache = figuresCache, canvas = cache.canvas, gl = cache.gl; + + canvas.width = width; + canvas.height = height; + gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight); + gl.uniform2f(cache.resolutionLocation, width, height); + + // count triangle points + var count = 0; + var i, ii, rows; + for (i = 0, ii = figures.length; i < ii; i++) { + switch (figures[i].type) { + case 'lattice': + rows = (figures[i].coords.length / figures[i].verticesPerRow) | 0; + count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6; + break; + case 'triangles': + count += figures[i].coords.length; + break; + } + } + // transfer data + var coords = new Float32Array(count * 2); + var colors = new Uint8Array(count * 3); + var coordsMap = context.coords, colorsMap = context.colors; + var pIndex = 0, cIndex = 0; + for (i = 0, ii = figures.length; i < ii; i++) { + var figure = figures[i], ps = figure.coords, cs = figure.colors; + switch (figure.type) { + case 'lattice': + var cols = figure.verticesPerRow; + rows = (ps.length / cols) | 0; + for (var row = 1; row < rows; row++) { + var offset = row * cols + 1; + for (var col = 1; col < cols; col++, offset++) { + coords[pIndex] = coordsMap[ps[offset - cols - 1]]; + coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1]; + coords[pIndex + 2] = coordsMap[ps[offset - cols]]; + coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1]; + coords[pIndex + 4] = coordsMap[ps[offset - 1]]; + coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1]; + colors[cIndex] = colorsMap[cs[offset - cols - 1]]; + colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1]; + colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2]; + colors[cIndex + 3] = colorsMap[cs[offset - cols]]; + colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1]; + colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2]; + colors[cIndex + 6] = colorsMap[cs[offset - 1]]; + colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1]; + colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2]; + + coords[pIndex + 6] = coords[pIndex + 2]; + coords[pIndex + 7] = coords[pIndex + 3]; + coords[pIndex + 8] = coords[pIndex + 4]; + coords[pIndex + 9] = coords[pIndex + 5]; + coords[pIndex + 10] = coordsMap[ps[offset]]; + coords[pIndex + 11] = coordsMap[ps[offset] + 1]; + colors[cIndex + 9] = colors[cIndex + 3]; + colors[cIndex + 10] = colors[cIndex + 4]; + colors[cIndex + 11] = colors[cIndex + 5]; + colors[cIndex + 12] = colors[cIndex + 6]; + colors[cIndex + 13] = colors[cIndex + 7]; + colors[cIndex + 14] = colors[cIndex + 8]; + colors[cIndex + 15] = colorsMap[cs[offset]]; + colors[cIndex + 16] = colorsMap[cs[offset] + 1]; + colors[cIndex + 17] = colorsMap[cs[offset] + 2]; + pIndex += 12; + cIndex += 18; + } + } + break; + case 'triangles': + for (var j = 0, jj = ps.length; j < jj; j++) { + coords[pIndex] = coordsMap[ps[j]]; + coords[pIndex + 1] = coordsMap[ps[j] + 1]; + colors[cIndex] = colorsMap[cs[j]]; + colors[cIndex + 1] = colorsMap[cs[j] + 1]; + colors[cIndex + 2] = colorsMap[cs[j] + 2]; + pIndex += 2; + cIndex += 3; + } + break; + } + } + + // draw + if (backgroundColor) { + gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, + backgroundColor[2] / 255, 1.0); + } else { + gl.clearColor(0, 0, 0, 0); + } + gl.clear(gl.COLOR_BUFFER_BIT); + + var coordsBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer); + gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW); + gl.enableVertexAttribArray(cache.positionLocation); + gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0); + + var colorsBuffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer); + gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW); + gl.enableVertexAttribArray(cache.colorLocation); + gl.vertexAttribPointer(cache.colorLocation, 3, gl.UNSIGNED_BYTE, false, + 0, 0); + + gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY); + gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY); + + gl.drawArrays(gl.TRIANGLES, 0, count); + + gl.flush(); + + gl.deleteBuffer(coordsBuffer); + gl.deleteBuffer(colorsBuffer); + + return canvas; + } + + function cleanup() { + if (smaskCache && smaskCache.canvas) { + smaskCache.canvas.width = 0; + smaskCache.canvas.height = 0; + } + if (figuresCache && figuresCache.canvas) { + figuresCache.canvas.width = 0; + figuresCache.canvas.height = 0; + } + smaskCache = null; + figuresCache = null; + } + + return { + get isEnabled() { + if (PDFJS.disableWebGL) { + return false; + } + var enabled = false; + try { + generateGL(); + enabled = !!currentGL; + } catch (e) { } + return shadow(this, 'isEnabled', enabled); + }, + composeSMask: composeSMask, + drawFigures: drawFigures, + clear: cleanup + }; +})(); + +exports.WebGLUtils = WebGLUtils; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayPatternHelper = {}), root.pdfjsSharedUtil, + root.pdfjsDisplayWebGL); + } +}(this, function (exports, sharedUtil, displayWebGL) { + +var Util = sharedUtil.Util; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var error = sharedUtil.error; +var WebGLUtils = displayWebGL.WebGLUtils; + +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) { + // Very basic Gouraud-shaded triangle rasterization algorithm. + 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: + error('illigal figure'); + break; + } + } + + function createMeshCanvas(bounds, combinesScale, coords, colors, figures, + backgroundColor, cachedCanvases) { + // we will increase scale on some weird factor to let antialiasing take + // care of "rough" edges + var EXPECTED_SCALE = 1.1; + // MAX_PATTERN_SIZE is used to avoid OOM situation. + var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough + + 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 canvas, tmpCanvas, i, ii; + if (WebGLUtils.isEnabled) { + canvas = WebGLUtils.drawFigures(width, height, backgroundColor, + figures, context); + + // https://bugzilla.mozilla.org/show_bug.cgi?id=972126 + tmpCanvas = cachedCanvases.getCanvas('mesh', width, height, false); + tmpCanvas.context.drawImage(canvas, 0, 0); + canvas = tmpCanvas.canvas; + } else { + tmpCanvas = cachedCanvases.getCanvas('mesh', width, height, 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, 0, 0); + canvas = tmpCanvas.canvas; + } + + return {canvas: canvas, offsetX: offsetX, offsetY: offsetY, + scaleX: scaleX, scaleY: scaleY}; + } + return createMeshCanvas; +})(); + +ShadingIRs.Mesh = { + fromIR: function Mesh_fromIR(raw) { + //var type = raw[1]; + var coords = raw[2]; + var colors = raw[3]; + var figures = raw[4]; + var bounds = raw[5]; + var matrix = raw[6]; + //var bbox = raw[7]; + var background = raw[8]; + return { + type: 'Pattern', + getPattern: function Mesh_getPattern(ctx, owner, shadingFill) { + var scale; + if (shadingFill) { + scale = Util.singularValueDecompose2dScale(ctx.mozCurrentTransform); + } else { + // Obtain scale from matrix and current transformation matrix. + scale = Util.singularValueDecompose2dScale(owner.baseTransform); + if (matrix) { + var matrixScale = Util.singularValueDecompose2dScale(matrix); + scale = [scale[0] * matrixScale[0], + scale[1] * matrixScale[1]]; + } + } + + + // Rasterizing on the main thread since sending/queue large canvases + // might cause OOM. + 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) { + 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; // 10in @ 300dpi shall be enough + + 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; + + info('TilingType: ' + tilingType); + + var x0 = bbox[0], y0 = bbox[1], x1 = bbox[2], y1 = bbox[3]; + + var topLeft = [x0, y0]; + // we want the canvas to be as large as the step size + var botRight = [x0 + xstep, y0 + ystep]; + + var width = botRight[0] - topLeft[0]; + var height = botRight[1] - topLeft[1]; + + // Obtain scale from matrix and current transformation matrix. + var matrixScale = Util.singularValueDecompose2dScale(this.matrix); + var curMatrixScale = Util.singularValueDecompose2dScale( + this.baseTransform); + var combinedScale = [matrixScale[0] * curMatrixScale[0], + matrixScale[1] * curMatrixScale[1]]; + + // MAX_PATTERN_SIZE is used to avoid OOM situation. + // Use width and height values that are as close as possible to the end + // result when the pattern is used. Too low value makes the pattern look + // blurry. Too large value makes it look too crispy. + 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); + + // transform coordinates to pattern space + 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 (bbox && 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.makeCssRgb(color[0], color[1], color[2]); + context.fillStyle = cssColor; + context.strokeStyle = cssColor; + break; + default: + error('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; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayCanvas = {}), root.pdfjsSharedUtil, + root.pdfjsDisplayPatternHelper, root.pdfjsDisplayWebGL); + } +}(this, function (exports, sharedUtil, displayPatternHelper, displayWebGL) { + +var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX; +var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX; +var ImageKind = sharedUtil.ImageKind; +var OPS = sharedUtil.OPS; +var TextRenderingMode = sharedUtil.TextRenderingMode; +var Uint32ArrayView = sharedUtil.Uint32ArrayView; +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var info = sharedUtil.info; +var isNum = sharedUtil.isNum; +var isArray = sharedUtil.isArray; +var error = sharedUtil.error; +var shadow = sharedUtil.shadow; +var warn = sharedUtil.warn; +var TilingPattern = displayPatternHelper.TilingPattern; +var getShadingPatternFromIR = displayPatternHelper.getShadingPatternFromIR; +var WebGLUtils = displayWebGL.WebGLUtils; + +// contexts store most of the state we need natively. +// However, PDF needs a bit more state, which we store here. + +// Minimal font size that would be used during canvas fillText operations. +var MIN_FONT_SIZE = 16; +// Maximum font size that would be used during canvas fillText operations. +var MAX_FONT_SIZE = 100; +var MAX_GROUP_SIZE = 4096; + +// Heuristic value used when enforcing minimum line widths. +var MIN_WIDTH_FACTOR = 0.65; + +var COMPILE_TYPE3_GLYPHS = true; +var MAX_SIZE_TO_COMPILE = 1000; + +var FULL_CHUNK_HEIGHT = 16; + +function createScratchCanvas(width, height) { + var canvas = document.createElement('canvas'); + canvas.width = width; + canvas.height = height; + return canvas; +} + +function addContextCurrentTransform(ctx) { + // If the context doesn't expose a `mozCurrentTransform`, add a JS based one. + if (!ctx.mozCurrentTransform) { + ctx._originalSave = ctx.save; + ctx._originalRestore = ctx.restore; + ctx._originalRotate = ctx.rotate; + ctx._originalScale = ctx.scale; + ctx._originalTranslate = ctx.translate; + ctx._originalTransform = ctx.transform; + ctx._originalSetTransform = ctx.setTransform; + + ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0]; + ctx._transformStack = []; + + Object.defineProperty(ctx, 'mozCurrentTransform', { + get: function getCurrentTransform() { + return this._transformMatrix; + } + }); + + Object.defineProperty(ctx, 'mozCurrentTransformInverse', { + get: function getCurrentTransformInverse() { + // Calculation done using WolframAlpha: + // http://www.wolframalpha.com/input/? + // i=Inverse+{{a%2C+c%2C+e}%2C+{b%2C+d%2C+f}%2C+{0%2C+0%2C+1}} + + var m = this._transformMatrix; + var a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5]; + + var ad_bc = a * d - b * c; + var bc_ad = b * c - a * d; + + return [ + d / ad_bc, + b / bc_ad, + c / bc_ad, + a / ad_bc, + (d * e - c * f) / bc_ad, + (b * e - a * f) / ad_bc + ]; + } + }); + + ctx.save = function ctxSave() { + var old = this._transformMatrix; + this._transformStack.push(old); + this._transformMatrix = old.slice(0, 6); + + this._originalSave(); + }; + + ctx.restore = function ctxRestore() { + var prev = this._transformStack.pop(); + if (prev) { + this._transformMatrix = prev; + this._originalRestore(); + } + }; + + ctx.translate = function ctxTranslate(x, y) { + var m = this._transformMatrix; + m[4] = m[0] * x + m[2] * y + m[4]; + m[5] = m[1] * x + m[3] * y + m[5]; + + this._originalTranslate(x, y); + }; + + ctx.scale = function ctxScale(x, y) { + var m = this._transformMatrix; + m[0] = m[0] * x; + m[1] = m[1] * x; + m[2] = m[2] * y; + m[3] = m[3] * y; + + this._originalScale(x, y); + }; + + ctx.transform = function ctxTransform(a, b, c, d, e, f) { + var m = this._transformMatrix; + this._transformMatrix = [ + m[0] * a + m[2] * b, + m[1] * a + m[3] * b, + m[0] * c + m[2] * d, + m[1] * c + m[3] * d, + m[0] * e + m[2] * f + m[4], + m[1] * e + m[3] * f + m[5] + ]; + + ctx._originalTransform(a, b, c, d, e, f); + }; + + ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) { + this._transformMatrix = [a, b, c, d, e, f]; + + ctx._originalSetTransform(a, b, c, d, e, f); + }; + + ctx.rotate = function ctxRotate(angle) { + var cosValue = Math.cos(angle); + var sinValue = Math.sin(angle); + + var m = this._transformMatrix; + this._transformMatrix = [ + m[0] * cosValue + m[2] * sinValue, + m[1] * cosValue + m[3] * sinValue, + m[0] * (-sinValue) + m[2] * cosValue, + m[1] * (-sinValue) + m[3] * cosValue, + m[4], + m[5] + ]; + + this._originalRotate(angle); + }; + } +} + +var CachedCanvases = (function CachedCanvasesClosure() { + function CachedCanvases() { + this.cache = Object.create(null); + } + CachedCanvases.prototype = { + getCanvas: function CachedCanvases_getCanvas(id, width, height, + trackTransform) { + var canvasEntry; + if (this.cache[id] !== undefined) { + canvasEntry = this.cache[id]; + canvasEntry.canvas.width = width; + canvasEntry.canvas.height = height; + // reset canvas transform for emulated mozCurrentTransform, if needed + canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0); + } else { + var canvas = createScratchCanvas(width, height); + var ctx = canvas.getContext('2d'); + if (trackTransform) { + addContextCurrentTransform(ctx); + } + this.cache[id] = canvasEntry = {canvas: canvas, context: ctx}; + } + return canvasEntry; + }, + clear: function () { + for (var id in this.cache) { + var canvasEntry = this.cache[id]; + // Zeroing the width and height causes Firefox to release graphics + // resources immediately, which can greatly reduce memory consumption. + canvasEntry.canvas.width = 0; + canvasEntry.canvas.height = 0; + delete this.cache[id]; + } + } + }; + return CachedCanvases; +})(); + +function compileType3Glyph(imgData) { + var POINT_TO_PROCESS_LIMIT = 1000; + + var width = imgData.width, height = imgData.height; + var i, j, j0, width1 = width + 1; + var points = new Uint8Array(width1 * (height + 1)); + var POINT_TYPES = + new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]); + + // decodes bit-packed mask data + var lineSize = (width + 7) & ~7, data0 = imgData.data; + var data = new Uint8Array(lineSize * height), pos = 0, ii; + for (i = 0, ii = data0.length; i < ii; i++) { + var mask = 128, elem = data0[i]; + while (mask > 0) { + data[pos++] = (elem & mask) ? 0 : 255; + mask >>= 1; + } + } + + // finding iteresting points: every point is located between mask pixels, + // so there will be points of the (width + 1)x(height + 1) grid. Every point + // will have flags assigned based on neighboring mask pixels: + // 4 | 8 + // --P-- + // 2 | 1 + // We are interested only in points with the flags: + // - outside corners: 1, 2, 4, 8; + // - inside corners: 7, 11, 13, 14; + // - and, intersections: 5, 10. + var count = 0; + pos = 0; + if (data[pos] !== 0) { + points[0] = 1; + ++count; + } + for (j = 1; j < width; j++) { + if (data[pos] !== data[pos + 1]) { + points[j] = data[pos] ? 2 : 1; + ++count; + } + pos++; + } + if (data[pos] !== 0) { + points[j] = 2; + ++count; + } + for (i = 1; i < height; i++) { + pos = i * lineSize; + j0 = i * width1; + if (data[pos - lineSize] !== data[pos]) { + points[j0] = data[pos] ? 1 : 8; + ++count; + } + // 'sum' is the position of the current pixel configuration in the 'TYPES' + // array (in order 8-1-2-4, so we can use '>>2' to shift the column). + var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0); + for (j = 1; j < width; j++) { + sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + + (data[pos - lineSize + 1] ? 8 : 0); + if (POINT_TYPES[sum]) { + points[j0 + j] = POINT_TYPES[sum]; + ++count; + } + pos++; + } + if (data[pos - lineSize] !== data[pos]) { + points[j0 + j] = data[pos] ? 2 : 4; + ++count; + } + + if (count > POINT_TO_PROCESS_LIMIT) { + return null; + } + } + + pos = lineSize * (height - 1); + j0 = i * width1; + if (data[pos] !== 0) { + points[j0] = 8; + ++count; + } + for (j = 1; j < width; j++) { + if (data[pos] !== data[pos + 1]) { + points[j0 + j] = data[pos] ? 4 : 8; + ++count; + } + pos++; + } + if (data[pos] !== 0) { + points[j0 + j] = 4; + ++count; + } + if (count > POINT_TO_PROCESS_LIMIT) { + return null; + } + + // building outlines + var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]); + var outlines = []; + for (i = 0; count && i <= height; i++) { + var p = i * width1; + var end = p + width; + while (p < end && !points[p]) { + p++; + } + if (p === end) { + continue; + } + var coords = [p % width1, i]; + + var type = points[p], p0 = p, pp; + do { + var step = steps[type]; + do { + p += step; + } while (!points[p]); + + pp = points[p]; + if (pp !== 5 && pp !== 10) { + // set new direction + type = pp; + // delete mark + points[p] = 0; + } else { // type is 5 or 10, ie, a crossing + // set new direction + type = pp & ((0x33 * type) >> 4); + // set new type for "future hit" + points[p] &= (type >> 2 | type << 2); + } + + coords.push(p % width1); + coords.push((p / width1) | 0); + --count; + } while (p0 !== p); + outlines.push(coords); + --i; + } + + var drawOutline = function(c) { + c.save(); + // the path shall be painted in [0..1]x[0..1] space + c.scale(1 / width, -1 / height); + c.translate(0, -height); + c.beginPath(); + for (var i = 0, ii = outlines.length; i < ii; i++) { + var o = outlines[i]; + c.moveTo(o[0], o[1]); + for (var j = 2, jj = o.length; j < jj; j += 2) { + c.lineTo(o[j], o[j+1]); + } + } + c.fill(); + c.beginPath(); + c.restore(); + }; + + return drawOutline; +} + +var CanvasExtraState = (function CanvasExtraStateClosure() { + function CanvasExtraState(old) { + // Are soft masks and alpha values shapes or opacities? + this.alphaIsShape = false; + this.fontSize = 0; + this.fontSizeScale = 1; + this.textMatrix = IDENTITY_MATRIX; + this.textMatrixScale = 1; + this.fontMatrix = FONT_IDENTITY_MATRIX; + this.leading = 0; + // Current point (in user coordinates) + this.x = 0; + this.y = 0; + // Start of text line (in text coordinates) + this.lineX = 0; + this.lineY = 0; + // Character and word spacing + this.charSpacing = 0; + this.wordSpacing = 0; + this.textHScale = 1; + this.textRenderingMode = TextRenderingMode.FILL; + this.textRise = 0; + // Default fore and background colors + this.fillColor = '#000000'; + this.strokeColor = '#000000'; + this.patternFill = false; + // Note: fill alpha applies to all non-stroking operations + this.fillAlpha = 1; + this.strokeAlpha = 1; + this.lineWidth = 1; + this.activeSMask = null; // nonclonable field (see the save method below) + + this.old = old; + } + + CanvasExtraState.prototype = { + clone: function CanvasExtraState_clone() { + return Object.create(this); + }, + setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) { + this.x = x; + this.y = y; + } + }; + return CanvasExtraState; +})(); + +var CanvasGraphics = (function CanvasGraphicsClosure() { + // Defines the time the executeOperatorList is going to be executing + // before it stops and shedules a continue of execution. + var EXECUTION_TIME = 15; + // Defines the number of steps before checking the execution time + var EXECUTION_STEPS = 10; + + function CanvasGraphics(canvasCtx, commonObjs, objs, imageLayer) { + this.ctx = canvasCtx; + this.current = new CanvasExtraState(); + this.stateStack = []; + this.pendingClip = null; + this.pendingEOFill = false; + this.res = null; + this.xobjs = null; + this.commonObjs = commonObjs; + this.objs = objs; + this.imageLayer = imageLayer; + this.groupStack = []; + this.processingType3 = null; + // Patterns are painted relative to the initial page/form transform, see pdf + // spec 8.7.2 NOTE 1. + this.baseTransform = null; + this.baseTransformStack = []; + this.groupLevel = 0; + this.smaskStack = []; + this.smaskCounter = 0; + this.tempSMask = null; + this.cachedCanvases = new CachedCanvases(); + if (canvasCtx) { + // NOTE: if mozCurrentTransform is polyfilled, then the current state of + // the transformation must already be set in canvasCtx._transformMatrix. + addContextCurrentTransform(canvasCtx); + } + this.cachedGetSinglePixelWidth = null; + } + + function putBinaryImageData(ctx, imgData) { + if (typeof ImageData !== 'undefined' && imgData instanceof ImageData) { + ctx.putImageData(imgData, 0, 0); + return; + } + + // Put the image data to the canvas in chunks, rather than putting the + // whole image at once. This saves JS memory, because the ImageData object + // is smaller. It also possibly saves C++ memory within the implementation + // of putImageData(). (E.g. in Firefox we make two short-lived copies of + // the data passed to putImageData()). |n| shouldn't be too small, however, + // because too many putImageData() calls will slow things down. + // + // Note: as written, if the last chunk is partial, the putImageData() call + // will (conceptually) put pixels past the bounds of the canvas. But + // that's ok; any such pixels are ignored. + + var height = imgData.height, width = imgData.width; + var partialChunkHeight = height % FULL_CHUNK_HEIGHT; + var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT; + var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1; + + var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT); + var srcPos = 0, destPos; + var src = imgData.data; + var dest = chunkImgData.data; + var i, j, thisChunkHeight, elemsInThisChunk; + + // There are multiple forms in which the pixel data can be passed, and + // imgData.kind tells us which one this is. + if (imgData.kind === ImageKind.GRAYSCALE_1BPP) { + // Grayscale, 1 bit per pixel (i.e. black-and-white). + var srcLength = src.byteLength; + var dest32 = PDFJS.hasCanvasTypedArrays ? new Uint32Array(dest.buffer) : + new Uint32ArrayView(dest); + var dest32DataLength = dest32.length; + var fullSrcDiff = (width + 7) >> 3; + var white = 0xFFFFFFFF; + var black = (PDFJS.isLittleEndian || !PDFJS.hasCanvasTypedArrays) ? + 0xFF000000 : 0x000000FF; + for (i = 0; i < totalChunks; i++) { + thisChunkHeight = + (i < fullChunks) ? FULL_CHUNK_HEIGHT : partialChunkHeight; + destPos = 0; + for (j = 0; j < thisChunkHeight; j++) { + var srcDiff = srcLength - srcPos; + var k = 0; + var kEnd = (srcDiff > fullSrcDiff) ? width : srcDiff * 8 - 7; + var kEndUnrolled = kEnd & ~7; + var mask = 0; + var srcByte = 0; + for (; k < kEndUnrolled; k += 8) { + srcByte = src[srcPos++]; + dest32[destPos++] = (srcByte & 128) ? white : black; + dest32[destPos++] = (srcByte & 64) ? white : black; + dest32[destPos++] = (srcByte & 32) ? white : black; + dest32[destPos++] = (srcByte & 16) ? white : black; + dest32[destPos++] = (srcByte & 8) ? white : black; + dest32[destPos++] = (srcByte & 4) ? white : black; + dest32[destPos++] = (srcByte & 2) ? white : black; + dest32[destPos++] = (srcByte & 1) ? white : black; + } + for (; k < kEnd; k++) { + if (mask === 0) { + srcByte = src[srcPos++]; + mask = 128; + } + + dest32[destPos++] = (srcByte & mask) ? white : black; + mask >>= 1; + } + } + // We ran out of input. Make all remaining pixels transparent. + while (destPos < dest32DataLength) { + dest32[destPos++] = 0; + } + + ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT); + } + } else if (imgData.kind === ImageKind.RGBA_32BPP) { + // RGBA, 32-bits per pixel. + + j = 0; + elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4; + for (i = 0; i < fullChunks; i++) { + dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk)); + srcPos += elemsInThisChunk; + + ctx.putImageData(chunkImgData, 0, j); + j += FULL_CHUNK_HEIGHT; + } + if (i < totalChunks) { + elemsInThisChunk = width * partialChunkHeight * 4; + dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk)); + ctx.putImageData(chunkImgData, 0, j); + } + + } else if (imgData.kind === ImageKind.RGB_24BPP) { + // RGB, 24-bits per pixel. + thisChunkHeight = FULL_CHUNK_HEIGHT; + elemsInThisChunk = width * thisChunkHeight; + for (i = 0; i < totalChunks; i++) { + if (i >= fullChunks) { + thisChunkHeight = partialChunkHeight; + elemsInThisChunk = width * thisChunkHeight; + } + + destPos = 0; + for (j = elemsInThisChunk; j--;) { + dest[destPos++] = src[srcPos++]; + dest[destPos++] = src[srcPos++]; + dest[destPos++] = src[srcPos++]; + dest[destPos++] = 255; + } + ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT); + } + } else { + error('bad image kind: ' + imgData.kind); + } + } + + function putBinaryImageMask(ctx, imgData) { + var height = imgData.height, width = imgData.width; + var partialChunkHeight = height % FULL_CHUNK_HEIGHT; + var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT; + var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1; + + var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT); + var srcPos = 0; + var src = imgData.data; + var dest = chunkImgData.data; + + for (var i = 0; i < totalChunks; i++) { + var thisChunkHeight = + (i < fullChunks) ? FULL_CHUNK_HEIGHT : partialChunkHeight; + + // Expand the mask so it can be used by the canvas. Any required + // inversion has already been handled. + var destPos = 3; // alpha component offset + for (var j = 0; j < thisChunkHeight; j++) { + var mask = 0; + for (var k = 0; k < width; k++) { + if (!mask) { + var elem = src[srcPos++]; + mask = 128; + } + dest[destPos] = (elem & mask) ? 0 : 255; + destPos += 4; + mask >>= 1; + } + } + ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT); + } + } + + function copyCtxState(sourceCtx, destCtx) { + var properties = ['strokeStyle', 'fillStyle', 'fillRule', 'globalAlpha', + 'lineWidth', 'lineCap', 'lineJoin', 'miterLimit', + 'globalCompositeOperation', 'font']; + for (var i = 0, ii = properties.length; i < ii; i++) { + var property = properties[i]; + if (sourceCtx[property] !== undefined) { + destCtx[property] = sourceCtx[property]; + } + } + if (sourceCtx.setLineDash !== undefined) { + destCtx.setLineDash(sourceCtx.getLineDash()); + destCtx.lineDashOffset = sourceCtx.lineDashOffset; + } else if (sourceCtx.mozDashOffset !== undefined) { + destCtx.mozDash = sourceCtx.mozDash; + destCtx.mozDashOffset = sourceCtx.mozDashOffset; + } + } + + function composeSMaskBackdrop(bytes, r0, g0, b0) { + var length = bytes.length; + for (var i = 3; i < length; i += 4) { + var alpha = bytes[i]; + if (alpha === 0) { + bytes[i - 3] = r0; + bytes[i - 2] = g0; + bytes[i - 1] = b0; + } else if (alpha < 255) { + var alpha_ = 255 - alpha; + bytes[i - 3] = (bytes[i - 3] * alpha + r0 * alpha_) >> 8; + bytes[i - 2] = (bytes[i - 2] * alpha + g0 * alpha_) >> 8; + bytes[i - 1] = (bytes[i - 1] * alpha + b0 * alpha_) >> 8; + } + } + } + + function composeSMaskAlpha(maskData, layerData, transferMap) { + var length = maskData.length; + var scale = 1 / 255; + for (var i = 3; i < length; i += 4) { + var alpha = transferMap ? transferMap[maskData[i]] : maskData[i]; + layerData[i] = (layerData[i] * alpha * scale) | 0; + } + } + + function composeSMaskLuminosity(maskData, layerData, transferMap) { + var length = maskData.length; + for (var i = 3; i < length; i += 4) { + var y = (maskData[i - 3] * 77) + // * 0.3 / 255 * 0x10000 + (maskData[i - 2] * 152) + // * 0.59 .... + (maskData[i - 1] * 28); // * 0.11 .... + layerData[i] = transferMap ? + (layerData[i] * transferMap[y >> 8]) >> 8 : + (layerData[i] * y) >> 16; + } + } + + function genericComposeSMask(maskCtx, layerCtx, width, height, + subtype, backdrop, transferMap) { + var hasBackdrop = !!backdrop; + var r0 = hasBackdrop ? backdrop[0] : 0; + var g0 = hasBackdrop ? backdrop[1] : 0; + var b0 = hasBackdrop ? backdrop[2] : 0; + + var composeFn; + if (subtype === 'Luminosity') { + composeFn = composeSMaskLuminosity; + } else { + composeFn = composeSMaskAlpha; + } + + // processing image in chunks to save memory + var PIXELS_TO_PROCESS = 1048576; + var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width)); + for (var row = 0; row < height; row += chunkSize) { + var chunkHeight = Math.min(chunkSize, height - row); + var maskData = maskCtx.getImageData(0, row, width, chunkHeight); + var layerData = layerCtx.getImageData(0, row, width, chunkHeight); + + if (hasBackdrop) { + composeSMaskBackdrop(maskData.data, r0, g0, b0); + } + composeFn(maskData.data, layerData.data, transferMap); + + maskCtx.putImageData(layerData, 0, row); + } + } + + function composeSMask(ctx, smask, layerCtx) { + var mask = smask.canvas; + var maskCtx = smask.context; + + ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, + smask.offsetX, smask.offsetY); + + var backdrop = smask.backdrop || null; + if (!smask.transferMap && WebGLUtils.isEnabled) { + var composed = WebGLUtils.composeSMask(layerCtx.canvas, mask, + {subtype: smask.subtype, backdrop: backdrop}); + ctx.setTransform(1, 0, 0, 1, 0, 0); + ctx.drawImage(composed, smask.offsetX, smask.offsetY); + return; + } + genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, + smask.subtype, backdrop, smask.transferMap); + ctx.drawImage(mask, 0, 0); + } + + var LINE_CAP_STYLES = ['butt', 'round', 'square']; + var LINE_JOIN_STYLES = ['miter', 'round', 'bevel']; + var NORMAL_CLIP = {}; + var EO_CLIP = {}; + + CanvasGraphics.prototype = { + + beginDrawing: function CanvasGraphics_beginDrawing(transform, viewport, + transparency) { + // For pdfs that use blend modes we have to clear the canvas else certain + // blend modes can look wrong since we'd be blending with a white + // backdrop. The problem with a transparent backdrop though is we then + // don't get sub pixel anti aliasing on text, creating temporary + // transparent canvas when we have blend modes. + var width = this.ctx.canvas.width; + var height = this.ctx.canvas.height; + + this.ctx.save(); + this.ctx.fillStyle = 'rgb(255, 255, 255)'; + this.ctx.fillRect(0, 0, width, height); + this.ctx.restore(); + + if (transparency) { + var transparentCanvas = this.cachedCanvases.getCanvas( + 'transparent', width, height, true); + this.compositeCtx = this.ctx; + this.transparentCanvas = transparentCanvas.canvas; + this.ctx = transparentCanvas.context; + this.ctx.save(); + // The transform can be applied before rendering, transferring it to + // the new canvas. + this.ctx.transform.apply(this.ctx, + this.compositeCtx.mozCurrentTransform); + } + + this.ctx.save(); + if (transform) { + this.ctx.transform.apply(this.ctx, transform); + } + this.ctx.transform.apply(this.ctx, viewport.transform); + + this.baseTransform = this.ctx.mozCurrentTransform.slice(); + + if (this.imageLayer) { + this.imageLayer.beginLayout(); + } + }, + + executeOperatorList: function CanvasGraphics_executeOperatorList( + operatorList, + executionStartIdx, continueCallback, + stepper) { + var argsArray = operatorList.argsArray; + var fnArray = operatorList.fnArray; + var i = executionStartIdx || 0; + var argsArrayLen = argsArray.length; + + // Sometimes the OperatorList to execute is empty. + 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 !== 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 the promise isn't resolved yet, add the continueCallback + // to the promise and bail out. + if (!objsPool.isResolved(depObjId)) { + objsPool.get(depObjId, continueCallback); + return i; + } + } + } + + i++; + + // If the entire operatorList was executed, stop as were done. + if (i === argsArrayLen) { + return i; + } + + // If the execution took longer then a certain amount of time and + // `continueCallback` is specified, interrupt the execution. + if (chunkOperations && ++steps > EXECUTION_STEPS) { + if (Date.now() > endTime) { + continueCallback(); + return i; + } + steps = 0; + } + + // If the operatorList isn't executed completely yet OR the execution + // time was short enough, do another execution round. + } + }, + + endDrawing: function CanvasGraphics_endDrawing() { + this.ctx.restore(); + + if (this.transparentCanvas) { + this.ctx = this.compositeCtx; + this.ctx.drawImage(this.transparentCanvas, 0, 0); + this.transparentCanvas = null; + } + + this.cachedCanvases.clear(); + WebGLUtils.clear(); + + if (this.imageLayer) { + this.imageLayer.endLayout(); + } + }, + + // Graphics state + 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; + } else { + ctx.mozDash = dashArray; + ctx.mozDashOffset = dashPhase; + } + }, + setRenderingIntent: function CanvasGraphics_setRenderingIntent(intent) { + // Maybe if we one day fully support color spaces this will be important + // for now we can ignore. + // TODO set rendering intent? + }, + setFlatness: function CanvasGraphics_setFlatness(flatness) { + // There's no way to control this with canvas, but we can safely ignore. + // TODO set 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': + if (value && value.name && (value.name !== 'Normal')) { + var mode = value.name.replace(/([A-Z])/g, + function(c) { + return '-' + c.toLowerCase(); + } + ).substring(1); + this.ctx.globalCompositeOperation = mode; + if (this.ctx.globalCompositeOperation !== mode) { + warn('globalCompositeOperation "' + mode + + '" is not supported'); + } + } else { + this.ctx.globalCompositeOperation = 'source-over'; + } + break; + case 'SMask': + if (this.current.activeSMask) { + 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); + + copyCtxState(currentCtx, groupCtx); + this.ctx = groupCtx; + this.setGState([ + ['BM', 'Normal'], + ['ca', 1], + ['CA', 1] + ]); + 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); + }, + save: function CanvasGraphics_save() { + this.ctx.save(); + var old = this.current; + this.stateStack.push(old); + this.current = old.clone(); + this.current.activeSMask = null; + }, + restore: function CanvasGraphics_restore() { + if (this.stateStack.length !== 0) { + if (this.current.activeSMask !== null) { + this.endSMaskGroup(); + } + + this.current = this.stateStack.pop(); + this.ctx.restore(); + + // Ensure that the clipping path is reset (fixes issue6413.pdf). + 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; + }, + + // Path + 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 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 OPS.moveTo: + x = args[j++]; + y = args[j++]; + ctx.moveTo(x, y); + break; + case OPS.lineTo: + x = args[j++]; + y = args[j++]; + ctx.lineTo(x, y); + break; + case 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 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 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 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; + // Prevent drawing too thin lines by enforcing a minimum line width. + ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, + this.current.lineWidth); + // For stroke we want to temporarily change the global alpha to the + // stroking alpha. + ctx.globalAlpha = this.current.strokeAlpha; + if (strokeColor && strokeColor.hasOwnProperty('type') && + strokeColor.type === 'Pattern') { + // for patterns, we transform to pattern space, calculate + // the pattern, call stroke, and restore to user space + ctx.save(); + ctx.strokeStyle = strokeColor.getPattern(ctx, this); + ctx.stroke(); + ctx.restore(); + } else { + ctx.stroke(); + } + if (consumePath) { + this.consumePath(); + } + // Restore the global alpha to the fill alpha + 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) { + if (ctx.mozFillRule !== undefined) { + ctx.mozFillRule = 'evenodd'; + ctx.fill(); + ctx.mozFillRule = 'nonzero'; + } else { + 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(); + }, + + // Clipping + clip: function CanvasGraphics_clip() { + this.pendingClip = NORMAL_CLIP; + }, + eoClip: function CanvasGraphics_eoClip() { + this.pendingClip = EO_CLIP; + }, + + // Text + beginText: function CanvasGraphics_beginText() { + this.current.textMatrix = 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) { + error('Can\'t find font for ' + fontRefName); + } + + current.fontMatrix = (fontObj.fontMatrix ? + fontObj.fontMatrix : FONT_IDENTITY_MATRIX); + + // A valid matrix needs all main diagonal elements to be non-zero + // This also ensures we bypass FF bugzilla bug #719844. + if (current.fontMatrix[0] === 0 || + current.fontMatrix[3] === 0) { + warn('Invalid font matrix for font ' + fontRefName); + } + + // The spec for Tf (setFont) says that 'size' specifies the font 'scale', + // and in some docs this can be negative (inverted x-y axes). + if (size < 0) { + size = -size; + current.fontDirection = -1; + } else { + current.fontDirection = 1; + } + + this.current.font = fontObj; + this.current.fontSize = size; + + if (fontObj.isType3Font) { + return; // we don't need ctx.font for Type3 fonts + } + + var name = fontObj.loadedName || 'sans-serif'; + var bold = fontObj.black ? (fontObj.bold ? '900' : 'bold') : + (fontObj.bold ? 'bold' : 'normal'); + + var italic = fontObj.italic ? 'italic' : 'normal'; + var typeface = '"' + name + '", ' + fontObj.fallbackName; + + // Some font backends cannot handle fonts below certain size. + // Keeping the font at minimal size and using the fontSizeScale to change + // the current transformation matrix before the fillText/strokeText. + // See https://bugzilla.mozilla.org/show_bug.cgi?id=726227 + 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 & + TextRenderingMode.FILL_STROKE_MASK; + var isAddToPathSet = !!(textRenderingMode & + 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 === TextRenderingMode.FILL || + fillStrokeMode === TextRenderingMode.FILL_STROKE) { + ctx.fill(); + } + if (fillStrokeMode === TextRenderingMode.STROKE || + fillStrokeMode === TextRenderingMode.FILL_STROKE) { + ctx.stroke(); + } + ctx.restore(); + } else { + if (fillStrokeMode === TextRenderingMode.FILL || + fillStrokeMode === TextRenderingMode.FILL_STROKE) { + ctx.fillText(character, x, y); + } + if (fillStrokeMode === TextRenderingMode.STROKE || + fillStrokeMode === 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() { + // Checks if anti-aliasing is enabled when scaled text is painted. + // On Windows GDI scaled fonts looks bad. + var ctx = document.createElement('canvas').getContext('2d'); + 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 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 === TextRenderingMode.FILL && + !font.disableFontFace; + + ctx.save(); + ctx.transform.apply(ctx, current.textMatrix); + ctx.translate(current.x, current.y + current.textRise); + + if (current.patternFill) { + // TODO: Some shading patterns are not applied correctly to text, + // e.g. issues 3988 and 5432, and ShowText-ShadingPattern.pdf. + 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 & + TextRenderingMode.FILL_STROKE_MASK; + if (fillStrokeMode === TextRenderingMode.STROKE || + fillStrokeMode === 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 (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) { + // Some standard fonts may not have the exact width: rescale per + // character if measured width is greater than expected glyph width + // and subpixel-aa is enabled, otherwise just center the glyph. + 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 (simpleFillText && !accent) { + // common case + 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) { + // Type3 fonts - each glyph is a "mini-PDF" + 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 || FONT_IDENTITY_MATRIX; + var glyphsLength = glyphs.length; + var isTextInvisible = + current.textRenderingMode === 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 (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) { + 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.applyTransform([glyph.width, 0], fontMatrix); + width = transformed[0] * fontSize + spacing; + + ctx.translate(width, 0); + current.x += width * textHScale; + } + ctx.restore(); + this.processingType3 = null; + }, + + // Type3 fonts + setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) { + // We can safely ignore this since the width should be the same + // as the width in the Widths array. + }, + setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, + yWidth, + llx, + lly, + urx, + ury) { + // TODO According to the spec we're also suppose to ignore any operators + // that set color or include images while processing this type3 font. + this.ctx.rect(llx, lly, urx - llx, ury - lly); + this.clip(); + this.endPath(); + }, + + // Color + getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) { + var pattern; + if (IR[0] === 'TilingPattern') { + var color = IR[1]; + var baseTransform = this.baseTransform || + this.ctx.mozCurrentTransform.slice(); + var self = this; + var canvasGraphicsFactory = { + createCanvasGraphics: function (ctx) { + return new CanvasGraphics(ctx, self.commonObjs, self.objs); + } + }; + pattern = new TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, + baseTransform); + } else { + pattern = 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.makeCssRgb(r, g, b); + this.ctx.strokeStyle = color; + this.current.strokeColor = color; + }, + setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) { + var color = 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 = 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.applyTransform([0, 0], inv); + var br = Util.applyTransform([0, height], inv); + var ul = Util.applyTransform([width, 0], inv); + var ur = 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 { + // HACK to draw the gradient onto an infinite rectangle. + // PDF gradients are drawn across the entire image while + // Canvas only allows gradients to be drawn in a rectangle + // The following bug should allow us to remove this. + // https://bugzilla.mozilla.org/show_bug.cgi?id=664884 + + this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10); + } + + this.restore(); + }, + + // Images + beginInlineImage: function CanvasGraphics_beginInlineImage() { + error('Should not call beginInlineImage'); + }, + beginImageData: function CanvasGraphics_beginImageData() { + error('Should not call beginImageData'); + }, + + paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, + bbox) { + this.save(); + this.baseTransformStack.push(this.baseTransform); + + if (isArray(matrix) && 6 === matrix.length) { + this.transform.apply(this, matrix); + } + + this.baseTransform = this.ctx.mozCurrentTransform; + + if (isArray(bbox) && 4 === bbox.length) { + 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; + // TODO non-isolated groups - according to Rik at adobe non-isolated + // group results aren't usually that different and they even have tools + // that ignore this setting. Notes from Rik on implmenting: + // - When you encounter an transparency group, create a new canvas with + // the dimensions of the bbox + // - copy the content from the previous canvas to the new canvas + // - draw as usual + // - remove the backdrop alpha: + // alphaNew = 1 - (1 - alpha)/(1 - alphaBackdrop) with 'alpha' the alpha + // value of your transparency group and 'alphaBackdrop' the alpha of the + // backdrop + // - remove background color: + // colorNew = color - alphaNew *colorBackdrop /(1 - alphaNew) + if (!group.isolated) { + info('TODO: Support non-isolated groups.'); + } + + // TODO knockout - supposedly possible with the clever use of compositing + // modes. + if (group.knockout) { + warn('Knockout groups not supported.'); + } + + var currentTransform = currentCtx.mozCurrentTransform; + if (group.matrix) { + currentCtx.transform.apply(currentCtx, group.matrix); + } + assert(group.bbox, 'Bounding box is required.'); + + // Based on the current transform figure out how big the bounding box + // will actually be. + var bounds = Util.getAxialAlignedBoundingBox( + group.bbox, + currentCtx.mozCurrentTransform); + // Clip the bounding box to the current canvas. + var canvasBounds = [0, + 0, + currentCtx.canvas.width, + currentCtx.canvas.height]; + bounds = Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0]; + // Use ceil in case we're between sizes so we don't create canvas that is + // too small and make the canvas at least 1x1 pixels. + 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) { + // Using two cache entries is case if masks are used one after another. + cacheId += '_smask_' + ((this.smaskCounter++) % 2); + } + var scratchCanvas = this.cachedCanvases.getCanvas( + cacheId, drawnWidth, drawnHeight, true); + var groupCtx = scratchCanvas.context; + + // Since we created a new canvas that is just the size of the bounding box + // we have to translate the group ctx. + groupCtx.scale(1 / scaleX, 1 / scaleY); + groupCtx.translate(-offsetX, -offsetY); + groupCtx.transform.apply(groupCtx, currentTransform); + + if (group.smask) { + // Saving state and cached mask to be used in setGState. + 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 + }); + } else { + // Setup the current ctx so when the group is popped we draw it at the + // right location. + currentCtx.setTransform(1, 0, 0, 1, 0, 0); + currentCtx.translate(offsetX, offsetY); + currentCtx.scale(scaleX, scaleY); + } + // The transparency group inherits all off the current graphics state + // except the blend mode, soft mask, and alpha constants. + copyCtxState(currentCtx, groupCtx); + this.ctx = groupCtx; + this.setGState([ + ['BM', 'Normal'], + ['ca', 1], + ['CA', 1] + ]); + this.groupStack.push(currentCtx); + this.groupLevel++; + }, + + endGroup: function CanvasGraphics_endGroup(group) { + this.groupLevel--; + var groupCtx = this.ctx; + this.ctx = this.groupStack.pop(); + // Turn off image smoothing to avoid sub pixel interpolation which can + // look kind of blurry for some pdfs. + 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(); + this.current = new CanvasExtraState(); + + 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(); + + if (isArray(rect) && 4 === rect.length) { + 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) { + warn('Dependent image isn\'t ready yet'); + return; + } + + this.save(); + + var ctx = this.ctx; + // scale the image to the unit square + 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) { + 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) { + 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(); + // scale the image to the unit square + 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; + // instanceof HTMLElement does not work in jsdom node.js module + 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'; + // Vertial or horizontal scaling shall not be more than 2 to not loose the + // pixels during drawImage operation, painting on the temporary canvas(es) + // that are twice smaller in size + 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() { + warn('Unsupported \'paintXObject\' command.'); + }, + + // Marked content + + markPoint: function CanvasGraphics_markPoint(tag) { + // TODO Marked content. + }, + markPointProps: function CanvasGraphics_markPointProps(tag, properties) { + // TODO Marked content. + }, + beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) { + // TODO Marked content. + }, + beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps( + tag, properties) { + // TODO Marked content. + }, + endMarkedContent: function CanvasGraphics_endMarkedContent() { + // TODO Marked content. + }, + + // Compatibility + + beginCompat: function CanvasGraphics_beginCompat() { + // TODO ignore undefined operators (should we do that anyway?) + }, + endCompat: function CanvasGraphics_endCompat() { + // TODO stop ignoring undefined operators + }, + + // Helper functions + + consumePath: function CanvasGraphics_consumePath() { + var ctx = this.ctx; + if (this.pendingClip) { + if (this.pendingClip === EO_CLIP) { + if (ctx.mozFillRule !== undefined) { + ctx.mozFillRule = 'evenodd'; + ctx.clip(); + ctx.mozFillRule = 'nonzero'; + } else { + ctx.clip('evenodd'); + } + } else { + ctx.clip(); + } + this.pendingClip = null; + } + ctx.beginPath(); + }, + getSinglePixelWidth: function CanvasGraphics_getSinglePixelWidth(scale) { + if (this.cachedGetSinglePixelWidth === null) { + var inverse = this.ctx.mozCurrentTransformInverse; + // max of the current horizontal and vertical scale + 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 OPS) { + CanvasGraphics.prototype[OPS[op]] = CanvasGraphics.prototype[op]; + } + + return CanvasGraphics; +})(); + +exports.CanvasGraphics = CanvasGraphics; +exports.createScratchCanvas = createScratchCanvas; +})); + + +(function (root, factory) { + { + factory((root.pdfjsDisplayAPI = {}), root.pdfjsSharedUtil, + root.pdfjsDisplayFontLoader, root.pdfjsDisplayCanvas, + root.pdfjsDisplayMetadata, root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedUtil, displayFontLoader, displayCanvas, + displayMetadata, sharedGlobal, amdRequire) { + +var InvalidPDFException = sharedUtil.InvalidPDFException; +var MessageHandler = sharedUtil.MessageHandler; +var MissingPDFException = sharedUtil.MissingPDFException; +var PasswordResponses = sharedUtil.PasswordResponses; +var PasswordException = sharedUtil.PasswordException; +var StatTimer = sharedUtil.StatTimer; +var UnexpectedResponseException = sharedUtil.UnexpectedResponseException; +var UnknownErrorException = sharedUtil.UnknownErrorException; +var Util = sharedUtil.Util; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var combineUrl = sharedUtil.combineUrl; +var error = sharedUtil.error; +var deprecated = sharedUtil.deprecated; +var info = sharedUtil.info; +var isArrayBuffer = sharedUtil.isArrayBuffer; +var loadJpegStream = sharedUtil.loadJpegStream; +var stringToBytes = sharedUtil.stringToBytes; +var warn = sharedUtil.warn; +var FontFaceObject = displayFontLoader.FontFaceObject; +var FontLoader = displayFontLoader.FontLoader; +var CanvasGraphics = displayCanvas.CanvasGraphics; +var createScratchCanvas = displayCanvas.createScratchCanvas; +var Metadata = displayMetadata.Metadata; +var PDFJS = sharedGlobal.PDFJS; +var globalScope = sharedGlobal.globalScope; + +var DEFAULT_RANGE_CHUNK_SIZE = 65536; // 2^16 = 65536 + + +var useRequireEnsure = false; +if (typeof module !== 'undefined' && module.require) { + // node.js - disable worker and set require.ensure. + PDFJS.disableWorker = true; + if (typeof require.ensure === 'undefined') { + require.ensure = require('node-ensure'); + } + useRequireEnsure = true; +} +if (typeof __webpack_require__ !== 'undefined') { + // Webpack - get/bundle pdf.worker.js as additional file. + PDFJS.workerSrc = require('entry?name=[hash]-worker.js!./pdf.worker.js'); + useRequireEnsure = true; +} +if (typeof requirejs !== 'undefined' && requirejs.toUrl) { + PDFJS.workerSrc = requirejs.toUrl('pdfjs-dist/build/pdf.worker.js'); +} +var fakeWorkerFilesLoader = useRequireEnsure ? (function (callback) { + require.ensure([], function () { + require('./pdf.worker.js'); + callback(); + }); +}) : (typeof requirejs !== 'undefined') ? (function (callback) { + requirejs(['pdfjs-dist/build/pdf.worker'], function (worker) { + callback(); + }); +}) : null; + + +/** + * The maximum allowed image size in total pixels e.g. width * height. Images + * above this value will not be drawn. Use -1 for no limit. + * @var {number} + */ +PDFJS.maxImageSize = (PDFJS.maxImageSize === undefined ? + -1 : PDFJS.maxImageSize); + +/** + * The url of where the predefined Adobe CMaps are located. Include trailing + * slash. + * @var {string} + */ +PDFJS.cMapUrl = (PDFJS.cMapUrl === undefined ? null : PDFJS.cMapUrl); + +/** + * Specifies if CMaps are binary packed. + * @var {boolean} + */ +PDFJS.cMapPacked = PDFJS.cMapPacked === undefined ? false : PDFJS.cMapPacked; + +/** + * By default fonts are converted to OpenType fonts and loaded via font face + * rules. If disabled, the font will be rendered using a built in font renderer + * that constructs the glyphs with primitive path commands. + * @var {boolean} + */ +PDFJS.disableFontFace = (PDFJS.disableFontFace === undefined ? + false : PDFJS.disableFontFace); + +/** + * Path for image resources, mainly for annotation icons. Include trailing + * slash. + * @var {string} + */ +PDFJS.imageResourcesPath = (PDFJS.imageResourcesPath === undefined ? + '' : PDFJS.imageResourcesPath); + +/** + * Disable the web worker and run all code on the main thread. This will happen + * automatically if the browser doesn't support workers or sending typed arrays + * to workers. + * @var {boolean} + */ +PDFJS.disableWorker = (PDFJS.disableWorker === undefined ? + false : PDFJS.disableWorker); + +/** + * Path and filename of the worker file. Required when the worker is enabled in + * development mode. If unspecified in the production build, the worker will be + * loaded based on the location of the pdf.js file. It is recommended that + * the workerSrc is set in a custom application to prevent issues caused by + * third-party frameworks and libraries. + * @var {string} + */ +PDFJS.workerSrc = (PDFJS.workerSrc === undefined ? null : PDFJS.workerSrc); + +/** + * Disable range request loading of PDF files. When enabled and if the server + * supports partial content requests then the PDF will be fetched in chunks. + * Enabled (false) by default. + * @var {boolean} + */ +PDFJS.disableRange = (PDFJS.disableRange === undefined ? + false : PDFJS.disableRange); + +/** + * Disable streaming of PDF file data. By default PDF.js attempts to load PDF + * in chunks. This default behavior can be disabled. + * @var {boolean} + */ +PDFJS.disableStream = (PDFJS.disableStream === undefined ? + false : PDFJS.disableStream); + +/** + * Disable pre-fetching of PDF file data. When range requests are enabled PDF.js + * will automatically keep fetching more data even if it isn't needed to display + * the current page. This default behavior can be disabled. + * + * NOTE: It is also necessary to disable streaming, see above, + * in order for disabling of pre-fetching to work correctly. + * @var {boolean} + */ +PDFJS.disableAutoFetch = (PDFJS.disableAutoFetch === undefined ? + false : PDFJS.disableAutoFetch); + +/** + * Enables special hooks for debugging PDF.js. + * @var {boolean} + */ +PDFJS.pdfBug = (PDFJS.pdfBug === undefined ? false : PDFJS.pdfBug); + +/** + * Enables transfer usage in postMessage for ArrayBuffers. + * @var {boolean} + */ +PDFJS.postMessageTransfers = (PDFJS.postMessageTransfers === undefined ? + true : PDFJS.postMessageTransfers); + +/** + * Disables URL.createObjectURL usage. + * @var {boolean} + */ +PDFJS.disableCreateObjectURL = (PDFJS.disableCreateObjectURL === undefined ? + false : PDFJS.disableCreateObjectURL); + +/** + * Disables WebGL usage. + * @var {boolean} + */ +PDFJS.disableWebGL = (PDFJS.disableWebGL === undefined ? + true : PDFJS.disableWebGL); + +/** + * Disables fullscreen support, and by extension Presentation Mode, + * in browsers which support the fullscreen API. + * @var {boolean} + */ +PDFJS.disableFullscreen = (PDFJS.disableFullscreen === undefined ? + false : PDFJS.disableFullscreen); + +/** + * Enables CSS only zooming. + * @var {boolean} + */ +PDFJS.useOnlyCssZoom = (PDFJS.useOnlyCssZoom === undefined ? + false : PDFJS.useOnlyCssZoom); + +/** + * Controls the logging level. + * The constants from PDFJS.VERBOSITY_LEVELS should be used: + * - errors + * - warnings [default] + * - infos + * @var {number} + */ +PDFJS.verbosity = (PDFJS.verbosity === undefined ? + PDFJS.VERBOSITY_LEVELS.warnings : PDFJS.verbosity); + +/** + * The maximum supported canvas size in total pixels e.g. width * height. + * The default value is 4096 * 4096. Use -1 for no limit. + * @var {number} + */ +PDFJS.maxCanvasPixels = (PDFJS.maxCanvasPixels === undefined ? + 16777216 : PDFJS.maxCanvasPixels); + +/** + * (Deprecated) Opens external links in a new window if enabled. + * The default behavior opens external links in the PDF.js window. + * + * NOTE: This property has been deprecated, please use + * `PDFJS.externalLinkTarget = PDFJS.LinkTarget.BLANK` instead. + * @var {boolean} + */ +PDFJS.openExternalLinksInNewWindow = ( + PDFJS.openExternalLinksInNewWindow === undefined ? + false : PDFJS.openExternalLinksInNewWindow); + +/** + * Specifies the |target| attribute for external links. + * The constants from PDFJS.LinkTarget should be used: + * - NONE [default] + * - SELF + * - BLANK + * - PARENT + * - TOP + * @var {number} + */ +PDFJS.externalLinkTarget = (PDFJS.externalLinkTarget === undefined ? + PDFJS.LinkTarget.NONE : PDFJS.externalLinkTarget); + +/** + * Specifies the |rel| attribute for external links. Defaults to stripping + * the referrer. + * @var {string} + */ +PDFJS.externalLinkRel = (PDFJS.externalLinkRel === undefined ? + 'noreferrer' : PDFJS.externalLinkRel); + +/** + * Determines if we can eval strings as JS. Primarily used to improve + * performance for font rendering. + * @var {boolean} + */ +PDFJS.isEvalSupported = (PDFJS.isEvalSupported === undefined ? + true : PDFJS.isEvalSupported); + +/** + * Document initialization / loading parameters object. + * + * @typedef {Object} DocumentInitParameters + * @property {string} url - The URL of the PDF. + * @property {TypedArray|Array|string} data - Binary PDF data. Use typed arrays + * (Uint8Array) to improve the memory usage. If PDF data is BASE64-encoded, + * use atob() to convert it to a binary string first. + * @property {Object} httpHeaders - Basic authentication headers. + * @property {boolean} withCredentials - Indicates whether or not cross-site + * Access-Control requests should be made using credentials such as cookies + * or authorization headers. The default is false. + * @property {string} password - For decrypting password-protected PDFs. + * @property {TypedArray} initialData - A typed array with the first portion or + * all of the pdf data. Used by the extension since some data is already + * loaded before the switch to range requests. + * @property {number} length - The PDF file length. It's used for progress + * reports and range requests operations. + * @property {PDFDataRangeTransport} range + * @property {number} rangeChunkSize - Optional parameter to specify + * maximum number of bytes fetched per range request. The default value is + * 2^16 = 65536. + * @property {PDFWorker} worker - The worker that will be used for the loading + * and parsing of the PDF data. + */ + +/** + * @typedef {Object} PDFDocumentStats + * @property {Array} streamTypes - Used stream types in the document (an item + * is set to true if specific stream ID was used in the document). + * @property {Array} fontTypes - Used font type in the document (an item is set + * to true if specific font ID was used in the document). + */ + +/** + * This is the main entry point for loading a PDF and interacting with it. + * NOTE: If a URL is used to fetch the PDF data a standard XMLHttpRequest(XHR) + * is used, which means it must follow the same origin rules that any XHR does + * e.g. No cross domain requests without CORS. + * + * @param {string|TypedArray|DocumentInitParameters|PDFDataRangeTransport} src + * Can be a url to where a PDF is located, a typed array (Uint8Array) + * already populated with data or parameter object. + * + * @param {PDFDataRangeTransport} pdfDataRangeTransport (deprecated) It is used + * if you want to manually serve range requests for data in the PDF. + * + * @param {function} passwordCallback (deprecated) It is used to request a + * password if wrong or no password was provided. The callback receives two + * parameters: function that needs to be called with new password and reason + * (see {PasswordResponses}). + * + * @param {function} progressCallback (deprecated) It is used to be able to + * monitor the loading progress of the PDF file (necessary to implement e.g. + * a loading bar). The callback receives an {Object} with the properties: + * {number} loaded and {number} total. + * + * @return {PDFDocumentLoadingTask} + */ +PDFJS.getDocument = function getDocument(src, + pdfDataRangeTransport, + passwordCallback, + progressCallback) { + var task = new PDFDocumentLoadingTask(); + + // Support of the obsolete arguments (for compatibility with API v1.0) + if (arguments.length > 1) { + deprecated('getDocument is called with pdfDataRangeTransport, ' + + 'passwordCallback or progressCallback argument'); + } + if (pdfDataRangeTransport) { + if (!(pdfDataRangeTransport instanceof PDFDataRangeTransport)) { + // Not a PDFDataRangeTransport instance, trying to add missing properties. + pdfDataRangeTransport = Object.create(pdfDataRangeTransport); + pdfDataRangeTransport.length = src.length; + pdfDataRangeTransport.initialData = src.initialData; + if (!pdfDataRangeTransport.abort) { + pdfDataRangeTransport.abort = function () {}; + } + } + src = Object.create(src); + src.range = pdfDataRangeTransport; + } + task.onPassword = passwordCallback || null; + task.onProgress = progressCallback || null; + + var source; + if (typeof src === 'string') { + source = { url: src }; + } else if (isArrayBuffer(src)) { + source = { data: src }; + } else if (src instanceof PDFDataRangeTransport) { + source = { range: src }; + } else { + if (typeof src !== 'object') { + error('Invalid parameter in getDocument, need either Uint8Array, ' + + 'string or a parameter object'); + } + if (!src.url && !src.data && !src.range) { + error('Invalid parameter object: need either .data, .range or .url'); + } + + source = src; + } + + var params = {}; + var rangeTransport = null; + var worker = null; + for (var key in source) { + if (key === 'url' && typeof window !== 'undefined') { + // The full path is required in the 'url' field. + params[key] = combineUrl(window.location.href, source[key]); + continue; + } else if (key === 'range') { + rangeTransport = source[key]; + continue; + } else if (key === 'worker') { + worker = source[key]; + continue; + } else if (key === 'data' && !(source[key] instanceof Uint8Array)) { + // Converting string or array-like data to Uint8Array. + var pdfBytes = source[key]; + if (typeof pdfBytes === 'string') { + params[key] = stringToBytes(pdfBytes); + } else if (typeof pdfBytes === 'object' && pdfBytes !== null && + !isNaN(pdfBytes.length)) { + params[key] = new Uint8Array(pdfBytes); + } else if (isArrayBuffer(pdfBytes)) { + params[key] = new Uint8Array(pdfBytes); + } else { + error('Invalid PDF binary data: either typed array, string or ' + + 'array-like object is expected in the data property.'); + } + continue; + } + params[key] = source[key]; + } + + params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE; + + if (!worker) { + // Worker was not provided -- creating and owning our own. + worker = new PDFWorker(); + task._worker = worker; + } + var docId = task.docId; + worker.promise.then(function () { + if (task.destroyed) { + throw new Error('Loading aborted'); + } + return _fetchDocument(worker, params, rangeTransport, docId).then( + function (workerId) { + if (task.destroyed) { + throw new Error('Loading aborted'); + } + var messageHandler = new MessageHandler(docId, workerId, worker.port); + messageHandler.send('Ready', null); + var transport = new WorkerTransport(messageHandler, task, rangeTransport); + task._transport = transport; + }); + }).catch(task._capability.reject); + + return task; +}; + +/** + * Starts fetching of specified PDF document/data. + * @param {PDFWorker} worker + * @param {Object} source + * @param {PDFDataRangeTransport} pdfDataRangeTransport + * @param {string} docId Unique document id, used as MessageHandler id. + * @returns {Promise} The promise, which is resolved when worker id of + * MessageHandler is known. + * @private + */ +function _fetchDocument(worker, source, pdfDataRangeTransport, docId) { + if (worker.destroyed) { + return Promise.reject(new Error('Worker was destroyed')); + } + + source.disableAutoFetch = PDFJS.disableAutoFetch; + source.disableStream = PDFJS.disableStream; + source.chunkedViewerLoading = !!pdfDataRangeTransport; + if (pdfDataRangeTransport) { + source.length = pdfDataRangeTransport.length; + source.initialData = pdfDataRangeTransport.initialData; + } + return worker.messageHandler.sendWithPromise('GetDocRequest', { + docId: docId, + source: source, + disableRange: PDFJS.disableRange, + maxImageSize: PDFJS.maxImageSize, + cMapUrl: PDFJS.cMapUrl, + cMapPacked: PDFJS.cMapPacked, + disableFontFace: PDFJS.disableFontFace, + disableCreateObjectURL: PDFJS.disableCreateObjectURL, + verbosity: PDFJS.verbosity + }).then(function (workerId) { + if (worker.destroyed) { + throw new Error('Worker was destroyed'); + } + return workerId; + }); +} + +/** + * PDF document loading operation. + * @class + * @alias PDFDocumentLoadingTask + */ +var PDFDocumentLoadingTask = (function PDFDocumentLoadingTaskClosure() { + var nextDocumentId = 0; + + /** @constructs PDFDocumentLoadingTask */ + function PDFDocumentLoadingTask() { + this._capability = createPromiseCapability(); + this._transport = null; + this._worker = null; + + /** + * Unique document loading task id -- used in MessageHandlers. + * @type {string} + */ + this.docId = 'd' + (nextDocumentId++); + + /** + * Shows if loading task is destroyed. + * @type {boolean} + */ + this.destroyed = false; + + /** + * Callback to request a password if wrong or no password was provided. + * The callback receives two parameters: function that needs to be called + * with new password and reason (see {PasswordResponses}). + */ + this.onPassword = null; + + /** + * Callback to be able to monitor the loading progress of the PDF file + * (necessary to implement e.g. a loading bar). The callback receives + * an {Object} with the properties: {number} loaded and {number} total. + */ + this.onProgress = null; + + /** + * Callback to when unsupported feature is used. The callback receives + * an {PDFJS.UNSUPPORTED_FEATURES} argument. + */ + this.onUnsupportedFeature = null; + } + + PDFDocumentLoadingTask.prototype = + /** @lends PDFDocumentLoadingTask.prototype */ { + /** + * @return {Promise} + */ + get promise() { + return this._capability.promise; + }, + + /** + * Aborts all network requests and destroys worker. + * @return {Promise} A promise that is resolved after destruction activity + * is completed. + */ + destroy: function () { + 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; + } + }.bind(this)); + }, + + /** + * Registers callbacks to indicate the document loading completion. + * + * @param {function} onFulfilled The callback for the loading completion. + * @param {function} onRejected The callback for the loading failure. + * @return {Promise} A promise that is resolved after the onFulfilled or + * onRejected callback. + */ + then: function PDFDocumentLoadingTask_then(onFulfilled, onRejected) { + return this.promise.then.apply(this.promise, arguments); + } + }; + + return PDFDocumentLoadingTask; +})(); + +/** + * Abstract class to support range requests file loading. + * @class + * @alias PDFJS.PDFDataRangeTransport + * @param {number} length + * @param {Uint8Array} initialData + */ +var PDFDataRangeTransport = (function pdfDataRangeTransportClosure() { + function PDFDataRangeTransport(length, initialData) { + this.length = length; + this.initialData = initialData; + + this._rangeListeners = []; + this._progressListeners = []; + this._progressiveReadListeners = []; + this._readyCapability = createPromiseCapability(); + } + PDFDataRangeTransport.prototype = + /** @lends 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) { + this._readyCapability.promise.then(function () { + var listeners = this._progressListeners; + for (var i = 0, n = listeners.length; i < n; ++i) { + listeners[i](loaded); + } + }.bind(this)); + }, + + onDataProgressiveRead: + function PDFDataRangeTransport_onDataProgress(chunk) { + this._readyCapability.promise.then(function () { + var listeners = this._progressiveReadListeners; + for (var i = 0, n = listeners.length; i < n; ++i) { + listeners[i](chunk); + } + }.bind(this)); + }, + + 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; +})(); + +PDFJS.PDFDataRangeTransport = PDFDataRangeTransport; + +/** + * Proxy to a PDFDocument in the worker thread. Also, contains commonly used + * properties that can be read synchronously. + * @class + * @alias PDFDocumentProxy + */ +var PDFDocumentProxy = (function PDFDocumentProxyClosure() { + function PDFDocumentProxy(pdfInfo, transport, loadingTask) { + this.pdfInfo = pdfInfo; + this.transport = transport; + this.loadingTask = loadingTask; + } + PDFDocumentProxy.prototype = /** @lends PDFDocumentProxy.prototype */ { + /** + * @return {number} Total number of pages the PDF contains. + */ + get numPages() { + return this.pdfInfo.numPages; + }, + /** + * @return {string} A unique ID to identify a PDF. Not guaranteed to be + * unique. + */ + get fingerprint() { + return this.pdfInfo.fingerprint; + }, + /** + * @param {number} pageNumber The page number to get. The first page is 1. + * @return {Promise} A promise that is resolved with a {@link PDFPageProxy} + * object. + */ + getPage: function PDFDocumentProxy_getPage(pageNumber) { + return this.transport.getPage(pageNumber); + }, + /** + * @param {{num: number, gen: number}} ref The page reference. Must have + * the 'num' and 'gen' properties. + * @return {Promise} A promise that is resolved with the page index that is + * associated with the reference. + */ + getPageIndex: function PDFDocumentProxy_getPageIndex(ref) { + return this.transport.getPageIndex(ref); + }, + /** + * @return {Promise} A promise that is resolved with a lookup table for + * mapping named destinations to reference numbers. + * + * This can be slow for large documents: use getDestination instead + */ + getDestinations: function PDFDocumentProxy_getDestinations() { + return this.transport.getDestinations(); + }, + /** + * @param {string} id The named destination to get. + * @return {Promise} A promise that is resolved with all information + * of the given named destination. + */ + getDestination: function PDFDocumentProxy_getDestination(id) { + return this.transport.getDestination(id); + }, + /** + * @return {Promise} A promise that is resolved with: + * an Array containing the pageLabels that correspond to the pageIndexes, + * or `null` when no pageLabels are present in the PDF file. + */ + getPageLabels: function PDFDocumentProxy_getPageLabels() { + return this.transport.getPageLabels(); + }, + /** + * @return {Promise} A promise that is resolved with a lookup table for + * mapping named attachments to their content. + */ + getAttachments: function PDFDocumentProxy_getAttachments() { + return this.transport.getAttachments(); + }, + /** + * @return {Promise} A promise that is resolved with an array of all the + * JavaScript strings in the name tree. + */ + getJavaScript: function PDFDocumentProxy_getJavaScript() { + return this.transport.getJavaScript(); + }, + /** + * @return {Promise} A promise that is resolved with an {Array} that is a + * tree outline (if it has one) of the PDF. The tree is in the format of: + * [ + * { + * title: string, + * bold: boolean, + * italic: boolean, + * color: rgb array, + * dest: dest obj, + * url: string, + * items: array of more items like this + * }, + * ... + * ]. + */ + getOutline: function PDFDocumentProxy_getOutline() { + return this.transport.getOutline(); + }, + /** + * @return {Promise} A promise that is resolved with an {Object} that has + * info and metadata properties. Info is an {Object} filled with anything + * available in the information dictionary and similarly metadata is a + * {Metadata} object with information from the metadata section of the PDF. + */ + getMetadata: function PDFDocumentProxy_getMetadata() { + return this.transport.getMetadata(); + }, + /** + * @return {Promise} A promise that is resolved with a TypedArray that has + * the raw data from the PDF. + */ + getData: function PDFDocumentProxy_getData() { + return this.transport.getData(); + }, + /** + * @return {Promise} A promise that is resolved when the document's data + * is loaded. It is resolved with an {Object} that contains the length + * property that indicates size of the PDF data in bytes. + */ + getDownloadInfo: function PDFDocumentProxy_getDownloadInfo() { + return this.transport.downloadInfoCapability.promise; + }, + /** + * @return {Promise} A promise this is resolved with current stats about + * document structures (see {@link PDFDocumentStats}). + */ + getStats: function PDFDocumentProxy_getStats() { + return this.transport.getStats(); + }, + /** + * Cleans up resources allocated by the document, e.g. created @font-face. + */ + cleanup: function PDFDocumentProxy_cleanup() { + this.transport.startCleanup(); + }, + /** + * Destroys current document instance and terminates worker. + */ + destroy: function PDFDocumentProxy_destroy() { + return this.loadingTask.destroy(); + } + }; + return PDFDocumentProxy; +})(); + +/** + * Page getTextContent parameters. + * + * @typedef {Object} getTextContentParameters + * @param {boolean} normalizeWhitespace - replaces all occurrences of + * whitespace with standard spaces (0x20). The default value is `false`. + */ + +/** + * Page text content. + * + * @typedef {Object} TextContent + * @property {array} items - array of {@link TextItem} + * @property {Object} styles - {@link TextStyles} objects, indexed by font + * name. + */ + +/** + * Page text content part. + * + * @typedef {Object} TextItem + * @property {string} str - text content. + * @property {string} dir - text direction: 'ttb', 'ltr' or 'rtl'. + * @property {array} transform - transformation matrix. + * @property {number} width - width in device space. + * @property {number} height - height in device space. + * @property {string} fontName - font name used by pdf.js for converted font. + */ + +/** + * Text style. + * + * @typedef {Object} TextStyle + * @property {number} ascent - font ascent. + * @property {number} descent - font descent. + * @property {boolean} vertical - text is in vertical mode. + * @property {string} fontFamily - possible font family + */ + +/** + * Page annotation parameters. + * + * @typedef {Object} GetAnnotationsParameters + * @param {string} intent - Determines the annotations that will be fetched, + * can be either 'display' (viewable annotations) or 'print' + * (printable annotations). + * If the parameter is omitted, all annotations are fetched. + */ + +/** + * Page render parameters. + * + * @typedef {Object} RenderParameters + * @property {Object} canvasContext - A 2D context of a DOM Canvas object. + * @property {PDFJS.PageViewport} viewport - Rendering viewport obtained by + * calling of PDFPage.getViewport method. + * @property {string} intent - Rendering intent, can be 'display' or 'print' + * (default value is 'display'). + * @property {Array} transform - (optional) Additional transform, applied + * just before viewport transform. + * @property {Object} imageLayer - (optional) An object that has beginLayout, + * endLayout and appendImage functions. + * @property {function} continueCallback - (deprecated) A function that will be + * called each time the rendering is paused. To continue + * rendering call the function that is the first argument + * to the callback. + */ + +/** + * PDF page operator list. + * + * @typedef {Object} PDFOperatorList + * @property {Array} fnArray - Array containing the operator functions. + * @property {Array} argsArray - Array containing the arguments of the + * functions. + */ + +/** + * Proxy to a PDFPage in the worker thread. + * @class + * @alias PDFPageProxy + */ +var PDFPageProxy = (function PDFPageProxyClosure() { + function PDFPageProxy(pageIndex, pageInfo, transport) { + this.pageIndex = pageIndex; + this.pageInfo = pageInfo; + this.transport = transport; + this.stats = new StatTimer(); + this.stats.enabled = !!globalScope.PDFJS.enableStats; + this.commonObjs = transport.commonObjs; + this.objs = new PDFObjects(); + this.cleanupAfterRender = false; + this.pendingCleanup = false; + this.intentStates = {}; + this.destroyed = false; + } + PDFPageProxy.prototype = /** @lends PDFPageProxy.prototype */ { + /** + * @return {number} Page number of the page. First page is 1. + */ + get pageNumber() { + return this.pageIndex + 1; + }, + /** + * @return {number} The number of degrees the page is rotated clockwise. + */ + get rotate() { + return this.pageInfo.rotate; + }, + /** + * @return {Object} The reference that points to this page. It has 'num' and + * 'gen' properties. + */ + get ref() { + return this.pageInfo.ref; + }, + /** + * @return {Array} An array of the visible portion of the PDF page in the + * user space units - [x1, y1, x2, y2]. + */ + get view() { + return this.pageInfo.view; + }, + /** + * @param {number} scale The desired scale of the viewport. + * @param {number} rotate Degrees to rotate the viewport. If omitted this + * defaults to the page rotation. + * @return {PDFJS.PageViewport} Contains 'width' and 'height' properties + * along with transforms required for rendering. + */ + getViewport: function PDFPageProxy_getViewport(scale, rotate) { + if (arguments.length < 2) { + rotate = this.rotate; + } + return new PDFJS.PageViewport(this.view, scale, rotate, 0, 0); + }, + /** + * @param {GetAnnotationsParameters} params - Annotation parameters. + * @return {Promise} A promise that is resolved with an {Array} of the + * annotation objects. + */ + 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; + }, + /** + * Begins the process of rendering a page to the desired context. + * @param {RenderParameters} params Page render parameters. + * @return {RenderTask} An object that contains the promise, which + * is resolved when the page finishes rendering. + */ + render: function PDFPageProxy_render(params) { + var stats = this.stats; + stats.time('Overall'); + + // If there was a pending destroy cancel it so no cleanup happens during + // this call to render. + this.pendingCleanup = false; + + var renderingIntent = (params.intent === 'print' ? 'print' : 'display'); + + if (!this.intentStates[renderingIntent]) { + this.intentStates[renderingIntent] = {}; + } + var intentState = this.intentStates[renderingIntent]; + + // If there's no displayReadyCapability yet, then the operatorList + // was never requested before. Make the request and create the promise. + if (!intentState.displayReadyCapability) { + intentState.receivingOperatorList = true; + intentState.displayReadyCapability = createPromiseCapability(); + intentState.operatorList = { + fnArray: [], + argsArray: [], + lastChunk: false + }; + + this.stats.time('Page Request'); + this.transport.messageHandler.send('RenderPageRequest', { + pageIndex: this.pageNumber - 1, + intent: renderingIntent + }); + } + + var internalRenderTask = new InternalRenderTask(complete, params, + this.objs, + this.commonObjs, + intentState.operatorList, + this.pageNumber); + internalRenderTask.useRequestAnimationFrame = renderingIntent !== 'print'; + if (!intentState.renderTasks) { + intentState.renderTasks = []; + } + intentState.renderTasks.push(internalRenderTask); + var renderTask = internalRenderTask.task; + + // Obsolete parameter support + if (params.continueCallback) { + deprecated('render is used with continueCallback parameter'); + renderTask.onContinue = params.continueCallback; + } + + var self = this; + intentState.displayReadyCapability.promise.then( + function pageDisplayReadyPromise(transparency) { + if (self.pendingCleanup) { + complete(); + return; + } + stats.time('Rendering'); + internalRenderTask.initalizeGraphics(transparency); + internalRenderTask.operatorListChanged(); + }, + function pageDisplayReadPromiseError(reason) { + complete(reason); + } + ); + + function complete(error) { + var i = intentState.renderTasks.indexOf(internalRenderTask); + if (i >= 0) { + intentState.renderTasks.splice(i, 1); + } + + if (self.cleanupAfterRender) { + self.pendingCleanup = true; + } + self._tryCleanup(); + + if (error) { + internalRenderTask.capability.reject(error); + } else { + internalRenderTask.capability.resolve(); + } + stats.timeEnd('Rendering'); + stats.timeEnd('Overall'); + } + + return renderTask; + }, + + /** + * @return {Promise} A promise resolved with an {@link PDFOperatorList} + * object that represents page's operator list. + */ + getOperatorList: function PDFPageProxy_getOperatorList() { + function operatorListChanged() { + if (intentState.operatorList.lastChunk) { + intentState.opListReadCapability.resolve(intentState.operatorList); + } + } + + var renderingIntent = 'oplist'; + if (!this.intentStates[renderingIntent]) { + this.intentStates[renderingIntent] = {}; + } + var intentState = this.intentStates[renderingIntent]; + + if (!intentState.opListReadCapability) { + var opListTask = {}; + opListTask.operatorListChanged = operatorListChanged; + intentState.receivingOperatorList = true; + intentState.opListReadCapability = 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; + }, + + /** + * @param {getTextContentParameters} params - getTextContent parameters. + * @return {Promise} That is resolved a {@link TextContent} + * object that represent the page text content. + */ + getTextContent: function PDFPageProxy_getTextContent(params) { + var normalizeWhitespace = (params && params.normalizeWhitespace) || false; + + return this.transport.messageHandler.sendWithPromise('GetTextContent', { + pageIndex: this.pageNumber - 1, + normalizeWhitespace: normalizeWhitespace, + }); + }, + + /** + * Destroys page object. + */ + _destroy: function PDFPageProxy_destroy() { + this.destroyed = true; + this.transport.pageCache[this.pageIndex] = null; + + var waitOn = []; + Object.keys(this.intentStates).forEach(function(intent) { + var intentState = this.intentStates[intent]; + intentState.renderTasks.forEach(function(renderTask) { + var renderCompleted = renderTask.capability.promise. + catch(function () {}); // ignoring failures + waitOn.push(renderCompleted); + renderTask.cancel(); + }); + }, this); + this.objs.clear(); + this.annotationsPromise = null; + this.pendingCleanup = false; + return Promise.all(waitOn); + }, + + /** + * Cleans up resources allocated by the page. (deprecated) + */ + destroy: function() { + deprecated('page destroy method, use cleanup() instead'); + this.cleanup(); + }, + + /** + * Cleans up resources allocated by the page. + */ + cleanup: function PDFPageProxy_cleanup() { + this.pendingCleanup = true; + this._tryCleanup(); + }, + /** + * For internal use only. Attempts to clean up if rendering is in a state + * where that's possible. + * @ignore + */ + _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; + }, + /** + * For internal use only. + * @ignore + */ + _startRenderPage: function PDFPageProxy_startRenderPage(transparency, + intent) { + var intentState = this.intentStates[intent]; + // TODO Refactor RenderPageRequest to separate rendering + // and operator list logic + if (intentState.displayReadyCapability) { + intentState.displayReadyCapability.resolve(transparency); + } + }, + /** + * For internal use only. + * @ignore + */ + _renderPageChunk: function PDFPageProxy_renderPageChunk(operatorListChunk, + intent) { + var intentState = this.intentStates[intent]; + var i, ii; + // Add the new chunk to the current operator list. + 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; + + // Notify all the rendering tasks there are more operators to be consumed. + for (i = 0; i < intentState.renderTasks.length; i++) { + intentState.renderTasks[i].operatorListChanged(); + } + + if (operatorListChunk.lastChunk) { + intentState.receivingOperatorList = false; + this._tryCleanup(); + } + } + }; + return PDFPageProxy; +})(); + +/** + * PDF.js web worker abstraction, it controls instantiation of PDF documents and + * WorkerTransport for them. If creation of a web worker is not possible, + * a "fake" worker will be used instead. + * @class + */ +var PDFWorker = (function PDFWorkerClosure() { + var nextFakeWorkerId = 0; + + function getWorkerSrc() { + if (PDFJS.workerSrc) { + return PDFJS.workerSrc; + } + if (pdfjsFilePath) { + return pdfjsFilePath.replace(/\.js$/i, '.worker.js'); + } + error('No PDFJS.workerSrc specified'); + } + + // Loads worker code into main thread. + function setupFakeWorkerGlobal() { + if (!PDFJS.fakeWorkerFilesLoadedCapability) { + PDFJS.fakeWorkerFilesLoadedCapability = createPromiseCapability(); + // In the developer build load worker_loader which in turn loads all the + // other files and resolves the promise. In production only the + // pdf.worker.js file is needed. + var loader = fakeWorkerFilesLoader || function (callback) { + Util.loadScript(getWorkerSrc(), callback); + }; + loader(function () { + PDFJS.fakeWorkerFilesLoadedCapability.resolve(); + }); + } + return PDFJS.fakeWorkerFilesLoadedCapability.promise; + } + + function PDFWorker(name) { + this.name = name; + this.destroyed = false; + + this._readyCapability = createPromiseCapability(); + this._port = null; + this._webWorker = null; + this._messageHandler = null; + this._initialize(); + } + + PDFWorker.prototype = /** @lends PDFWorker.prototype */ { + get promise() { + return this._readyCapability.promise; + }, + + get port() { + return this._port; + }, + + get messageHandler() { + return this._messageHandler; + }, + + _initialize: function PDFWorker_initialize() { + // If worker support isn't disabled explicit and the browser has worker + // support, create a new web worker and test if it/the browser fullfills + // all requirements to run parts of pdf.js in a web worker. + // Right now, the requirement is, that an Uint8Array is still an + // Uint8Array as it arrives on the worker. (Chrome added this with v.15.) + if (!globalScope.PDFJS.disableWorker && typeof Worker !== 'undefined') { + var workerSrc = getWorkerSrc(); + + try { + // Some versions of FF can't create a worker on localhost, see: + // https://bugzilla.mozilla.org/show_bug.cgi?id=683280 + var worker = new Worker(workerSrc); + var messageHandler = new MessageHandler('main', 'worker', worker); + messageHandler.on('test', function PDFWorker_test(data) { + if (this.destroyed) { + this._readyCapability.reject(new Error('Worker was destroyed')); + messageHandler.destroy(); + worker.terminate(); + return; // worker was destroyed + } + var supportTypedArray = data && data.supportTypedArray; + if (supportTypedArray) { + this._messageHandler = messageHandler; + this._port = worker; + this._webWorker = worker; + if (!data.supportTransfers) { + PDFJS.postMessageTransfers = false; + } + this._readyCapability.resolve(); + } else { + this._setupFakeWorker(); + messageHandler.destroy(); + worker.terminate(); + } + }.bind(this)); + + 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) { + if (this.destroyed) { + this._readyCapability.reject(new Error('Worker was destroyed')); + messageHandler.destroy(); + worker.terminate(); + return; // worker was destroyed + } + try { + sendTest(); + } catch (e) { + // We need fallback to a faked worker. + this._setupFakeWorker(); + } + }.bind(this)); + + var sendTest = function () { + var testObj = new Uint8Array( + [PDFJS.postMessageTransfers ? 255 : 0]); + // Some versions of Opera throw a DATA_CLONE_ERR on serializing the + // typed array. Also, checking if we can use transfers. + try { + messageHandler.send('test', testObj, [testObj.buffer]); + } catch (ex) { + info('Cannot use postMessage transfers'); + testObj[0] = 0; + messageHandler.send('test', testObj); + } + }; + + // It might take time for worker to initialize (especially when AMD + // loader is used). We will try to send test immediately, and then + // when 'ready' message will arrive. The worker shall process only + // first received 'test'. + sendTest(); + return; + } catch (e) { + info('The worker has been disabled.'); + } + } + // Either workers are disabled, not supported or have thrown an exception. + // Thus, we fallback to a faked worker. + this._setupFakeWorker(); + }, + + _setupFakeWorker: function PDFWorker_setupFakeWorker() { + if (!globalScope.PDFJS.disableWorker) { + warn('Setting up fake worker.'); + globalScope.PDFJS.disableWorker = true; + } + + setupFakeWorkerGlobal().then(function () { + if (this.destroyed) { + this._readyCapability.reject(new Error('Worker was destroyed')); + return; + } + + // If we don't use a worker, just post/sendMessage to the main thread. + var port = { + _listeners: [], + postMessage: function (obj) { + var e = {data: obj}; + this._listeners.forEach(function (listener) { + listener.call(this, e); + }, this); + }, + addEventListener: function (name, listener) { + this._listeners.push(listener); + }, + removeEventListener: function (name, listener) { + var i = this._listeners.indexOf(listener); + this._listeners.splice(i, 1); + }, + terminate: function () {} + }; + this._port = port; + + // All fake workers use the same port, making id unique. + var id = 'fake' + (nextFakeWorkerId++); + + // If the main thread is our worker, setup the handling for the + // messages -- the main thread sends to it self. + var workerHandler = new MessageHandler(id + '_worker', id, port); + PDFJS.WorkerMessageHandler.setup(workerHandler, port); + + var messageHandler = new MessageHandler(id, id + '_worker', port); + this._messageHandler = messageHandler; + this._readyCapability.resolve(); + }.bind(this)); + }, + + /** + * Destroys the worker instance. + */ + destroy: function PDFWorker_destroy() { + this.destroyed = true; + if (this._webWorker) { + // We need to terminate only web worker created resource. + this._webWorker.terminate(); + this._webWorker = null; + } + this._port = null; + if (this._messageHandler) { + this._messageHandler.destroy(); + this._messageHandler = null; + } + } + }; + + return PDFWorker; +})(); +PDFJS.PDFWorker = PDFWorker; + +/** + * For internal use only. + * @ignore + */ +var WorkerTransport = (function WorkerTransportClosure() { + function WorkerTransport(messageHandler, loadingTask, pdfDataRangeTransport) { + this.messageHandler = messageHandler; + this.loadingTask = loadingTask; + this.pdfDataRangeTransport = pdfDataRangeTransport; + this.commonObjs = new PDFObjects(); + this.fontLoader = new FontLoader(loadingTask.docId); + + this.destroyed = false; + this.destroyCapability = null; + + this.pageCache = []; + this.pagePromises = []; + this.downloadInfoCapability = createPromiseCapability(); + + this.setupMessageHandler(); + } + WorkerTransport.prototype = { + destroy: function WorkerTransport_destroy() { + if (this.destroyCapability) { + return this.destroyCapability.promise; + } + + this.destroyed = true; + this.destroyCapability = createPromiseCapability(); + + var waitOn = []; + // We need to wait for all renderings to be completed, e.g. + // timeout/rAF can take a long time. + this.pageCache.forEach(function (page) { + if (page) { + waitOn.push(page._destroy()); + } + }); + this.pageCache = []; + this.pagePromises = []; + var self = this; + // We also need to wait for the worker to finish its long running tasks. + var terminated = this.messageHandler.sendWithPromise('Terminate', null); + waitOn.push(terminated); + Promise.all(waitOn).then(function () { + self.fontLoader.clear(); + if (self.pdfDataRangeTransport) { + self.pdfDataRangeTransport.abort(); + self.pdfDataRangeTransport = null; + } + if (self.messageHandler) { + self.messageHandler.destroy(); + self.messageHandler = null; + } + self.destroyCapability.resolve(); + }, this.destroyCapability.reject); + return this.destroyCapability.promise; + }, + + setupMessageHandler: + function WorkerTransport_setupMessageHandler() { + var messageHandler = this.messageHandler; + + function updatePassword(password) { + messageHandler.send('UpdatePassword', password); + } + + var pdfDataRangeTransport = this.pdfDataRangeTransport; + if (pdfDataRangeTransport) { + pdfDataRangeTransport.addRangeListener(function(begin, chunk) { + messageHandler.send('OnDataRange', { + begin: begin, + chunk: chunk + }); + }); + + pdfDataRangeTransport.addProgressListener(function(loaded) { + messageHandler.send('OnDataProgress', { + loaded: loaded + }); + }); + + pdfDataRangeTransport.addProgressiveReadListener(function(chunk) { + messageHandler.send('OnDataRange', { + chunk: chunk + }); + }); + + messageHandler.on('RequestDataRange', + function transportDataRange(data) { + pdfDataRangeTransport.requestDataRange(data.begin, data.end); + }, 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('NeedPassword', + function transportNeedPassword(exception) { + var loadingTask = this.loadingTask; + if (loadingTask.onPassword) { + return loadingTask.onPassword(updatePassword, + PasswordResponses.NEED_PASSWORD); + } + loadingTask._capability.reject( + new PasswordException(exception.message, exception.code)); + }, this); + + messageHandler.on('IncorrectPassword', + function transportIncorrectPassword(exception) { + var loadingTask = this.loadingTask; + if (loadingTask.onPassword) { + return loadingTask.onPassword(updatePassword, + PasswordResponses.INCORRECT_PASSWORD); + } + loadingTask._capability.reject( + new PasswordException(exception.message, exception.code)); + }, this); + + messageHandler.on('InvalidPDF', function transportInvalidPDF(exception) { + this.loadingTask._capability.reject( + new InvalidPDFException(exception.message)); + }, this); + + messageHandler.on('MissingPDF', function transportMissingPDF(exception) { + this.loadingTask._capability.reject( + new MissingPDFException(exception.message)); + }, this); + + messageHandler.on('UnexpectedResponse', + function transportUnexpectedResponse(exception) { + this.loadingTask._capability.reject( + new UnexpectedResponseException(exception.message, exception.status)); + }, this); + + messageHandler.on('UnknownError', + function transportUnknownError(exception) { + this.loadingTask._capability.reject( + new UnknownErrorException(exception.message, exception.details)); + }, this); + + messageHandler.on('DataLoaded', function transportPage(data) { + this.downloadInfoCapability.resolve(data); + }, this); + + messageHandler.on('PDFManagerReady', function transportPage(data) { + if (this.pdfDataRangeTransport) { + this.pdfDataRangeTransport.transportReady(); + } + }, this); + + messageHandler.on('StartRenderPage', function transportRender(data) { + if (this.destroyed) { + return; // Ignore any pending requests if the worker was terminated. + } + 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; // Ignore any pending requests if the worker was terminated. + } + var page = this.pageCache[data.pageIndex]; + + page._renderPageChunk(data.operatorList, data.intent); + }, this); + + messageHandler.on('commonobj', function transportObj(data) { + if (this.destroyed) { + return; // Ignore any pending requests if the worker was terminated. + } + + var id = data[0]; + var type = data[1]; + if (this.commonObjs.hasData(id)) { + return; + } + + switch (type) { + case 'Font': + var exportedData = data[2]; + + var font; + if ('error' in exportedData) { + var error = exportedData.error; + warn('Error during font loading: ' + error); + this.commonObjs.resolve(id, error); + break; + } else { + font = new FontFaceObject(exportedData); + } + + this.fontLoader.bind( + [font], + function fontReady(fontObjs) { + this.commonObjs.resolve(id, font); + }.bind(this) + ); + break; + case 'FontPath': + this.commonObjs.resolve(id, data[2]); + break; + default: + error('Got unknown common object type ' + type); + } + }, this); + + messageHandler.on('obj', function transportObj(data) { + if (this.destroyed) { + return; // Ignore any pending requests if the worker was terminated. + } + + 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]; + loadJpegStream(id, imageData, pageProxy.objs); + break; + case 'Image': + imageData = data[3]; + pageProxy.objs.resolve(id, imageData); + + // heuristics that will allow not to store large data + 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: + error('Got unknown object type ' + type); + } + }, this); + + messageHandler.on('DocProgress', function transportDocProgress(data) { + if (this.destroyed) { + return; // Ignore any pending requests if the worker was terminated. + } + + 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; // Ignore any pending requests if the worker was terminated. + } + + var page = this.pageCache[data.pageNum - 1]; + var intentState = page.intentStates[data.intent]; + if (intentState.displayReadyCapability) { + intentState.displayReadyCapability.reject(data.error); + } else { + error(data.error); + } + }, this); + + messageHandler.on('UnsupportedFeature', + function transportUnsupportedFeature(data) { + if (this.destroyed) { + return; // Ignore any pending requests if the worker was terminated. + } + var featureId = data.featureId; + var loadingTask = this.loadingTask; + if (loadingTask.onUnsupportedFeature) { + loadingTask.onUnsupportedFeature(featureId); + } + PDFJS.UnsupportedManager.notify(featureId); + }, this); + + messageHandler.on('JpegDecode', function(data) { + if (this.destroyed) { + return Promise.reject('Worker was terminated'); + } + + 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 = createScratchCanvas(width, 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); + }, + + getData: function WorkerTransport_getData() { + return this.messageHandler.sendWithPromise('GetData', null); + }, + + getPage: function WorkerTransport_getPage(pageNumber, capability) { + if (pageNumber <= 0 || pageNumber > this.numPages || + (pageNumber|0) !== pageNumber) { + 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 (this.destroyed) { + throw new Error('Transport destroyed'); + } + var page = new PDFPageProxy(pageIndex, pageInfo, this); + this.pageCache[pageIndex] = page; + return page; + }.bind(this)); + this.pagePromises[pageIndex] = promise; + return promise; + }, + + getPageIndex: function WorkerTransport_getPageIndexByRef(ref) { + return this.messageHandler.sendWithPromise('GetPageIndex', { ref: ref }); + }, + + 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); + }, + + 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(results[1]) : null) + }; + }); + }, + + getStats: function WorkerTransport_getStats() { + return this.messageHandler.sendWithPromise('GetStats', null); + }, + + startCleanup: function WorkerTransport_startCleanup() { + this.messageHandler.sendWithPromise('Cleanup', null). + then(function endCleanup() { + for (var i = 0, ii = this.pageCache.length; i < ii; i++) { + var page = this.pageCache[i]; + if (page) { + page.cleanup(); + } + } + this.commonObjs.clear(); + this.fontLoader.clear(); + }.bind(this)); + } + }; + return WorkerTransport; + +})(); + +/** + * A PDF document and page is built of many objects. E.g. there are objects + * for fonts, images, rendering code and such. These objects might get processed + * inside of a worker. The `PDFObjects` implements some basic functions to + * manage these objects. + * @ignore + */ +var PDFObjects = (function PDFObjectsClosure() { + function PDFObjects() { + this.objs = {}; + } + + PDFObjects.prototype = { + /** + * Internal function. + * Ensures there is an object defined for `objId`. + */ + ensureObj: function PDFObjects_ensureObj(objId) { + if (this.objs[objId]) { + return this.objs[objId]; + } + + var obj = { + capability: createPromiseCapability(), + data: null, + resolved: false + }; + this.objs[objId] = obj; + + return obj; + }, + + /** + * If called *without* callback, this returns the data of `objId` but the + * object needs to be resolved. If it isn't, this function throws. + * + * If called *with* a callback, the callback is called with the data of the + * object once the object is resolved. That means, if you call this + * function and the object is already resolved, the callback gets called + * right away. + */ + get: function PDFObjects_get(objId, callback) { + // If there is a callback, then the get can be async and the object is + // not required to be resolved right now + if (callback) { + this.ensureObj(objId).capability.promise.then(callback); + return null; + } + + // If there isn't a callback, the user expects to get the resolved data + // directly. + var obj = this.objs[objId]; + + // If there isn't an object yet or the object isn't resolved, then the + // data isn't ready yet! + if (!obj || !obj.resolved) { + error('Requesting object that isn\'t resolved yet ' + objId); + } + + return obj.data; + }, + + /** + * Resolves the object `objId` with optional `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; + } else { + return objs[objId].resolved; + } + }, + + hasData: function PDFObjects_hasData(objId) { + return this.isResolved(objId); + }, + + /** + * Returns the data of `objId` if object exists, null otherwise. + */ + getData: function PDFObjects_getData(objId) { + var objs = this.objs; + if (!objs[objId] || !objs[objId].resolved) { + return null; + } else { + return objs[objId].data; + } + }, + + clear: function PDFObjects_clear() { + this.objs = {}; + } + }; + return PDFObjects; +})(); + +/** + * Allows controlling of the rendering tasks. + * @class + * @alias RenderTask + */ +var RenderTask = (function RenderTaskClosure() { + function RenderTask(internalRenderTask) { + this._internalRenderTask = internalRenderTask; + + /** + * Callback for incremental rendering -- a function that will be called + * each time the rendering is paused. To continue rendering call the + * function that is the first argument to the callback. + * @type {function} + */ + this.onContinue = null; + } + + RenderTask.prototype = /** @lends RenderTask.prototype */ { + /** + * Promise for rendering task completion. + * @return {Promise} + */ + get promise() { + return this._internalRenderTask.capability.promise; + }, + + /** + * Cancels the rendering task. If the task is currently rendering it will + * not be cancelled until graphics pauses with a timeout. The promise that + * this object extends will resolved when cancelled. + */ + cancel: function RenderTask_cancel() { + this._internalRenderTask.cancel(); + }, + + /** + * Registers callbacks to indicate the rendering task completion. + * + * @param {function} onFulfilled The callback for the rendering completion. + * @param {function} onRejected The callback for the rendering failure. + * @return {Promise} A promise that is resolved after the onFulfilled or + * onRejected callback. + */ + then: function RenderTask_then(onFulfilled, onRejected) { + return this.promise.then.apply(this.promise, arguments); + } + }; + + return RenderTask; +})(); + +/** + * For internal use only. + * @ignore + */ +var InternalRenderTask = (function InternalRenderTaskClosure() { + + function InternalRenderTask(callback, params, objs, commonObjs, operatorList, + pageNumber) { + this.callback = callback; + this.params = params; + this.objs = objs; + this.commonObjs = commonObjs; + this.operatorListIdx = null; + this.operatorList = operatorList; + this.pageNumber = pageNumber; + this.running = false; + this.graphicsReadyCallback = null; + this.graphicsReady = false; + this.useRequestAnimationFrame = false; + this.cancelled = false; + this.capability = createPromiseCapability(); + this.task = new RenderTask(this); + // caching this-bound methods + this._continueBound = this._continue.bind(this); + this._scheduleNextBound = this._scheduleNext.bind(this); + this._nextBound = this._next.bind(this); + } + + InternalRenderTask.prototype = { + + initalizeGraphics: + function InternalRenderTask_initalizeGraphics(transparency) { + + if (this.cancelled) { + return; + } + if (PDFJS.pdfBug && 'StepperManager' in globalScope && + globalScope.StepperManager.enabled) { + this.stepper = globalScope.StepperManager.create(this.pageNumber - 1); + this.stepper.init(this.operatorList); + this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint(); + } + + var params = this.params; + this.gfx = new CanvasGraphics(params.canvasContext, this.commonObjs, + this.objs, params.imageLayer); + + this.gfx.beginDrawing(params.transform, params.viewport, transparency); + this.operatorListIdx = 0; + this.graphicsReady = true; + if (this.graphicsReadyCallback) { + this.graphicsReadyCallback(); + } + }, + + cancel: function InternalRenderTask_cancel() { + this.running = false; + this.cancelled = true; + 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.call(this.task, this._scheduleNextBound); + } else { + this._scheduleNext(); + } + }, + + _scheduleNext: function InternalRenderTask__scheduleNext() { + if (this.useRequestAnimationFrame) { + 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(); + this.callback(); + } + } + } + + }; + + return InternalRenderTask; +})(); + +/** + * (Deprecated) Global observer of unsupported feature usages. Use + * onUnsupportedFeature callback of the {PDFDocumentLoadingTask} instance. + */ +PDFJS.UnsupportedManager = (function UnsupportedManagerClosure() { + var listeners = []; + return { + listen: function (cb) { + deprecated('Global UnsupportedManager.listen is used: ' + + ' use PDFDocumentLoadingTask.onUnsupportedFeature instead'); + listeners.push(cb); + }, + notify: function (featureId) { + for (var i = 0, ii = listeners.length; i < ii; i++) { + listeners[i](featureId); + } + } + }; +})(); + +exports.getDocument = PDFJS.getDocument; +exports.PDFDataRangeTransport = PDFDataRangeTransport; +exports.PDFDocumentProxy = PDFDocumentProxy; +exports.PDFPageProxy = PDFPageProxy; +})); + + + }).call(pdfjsLibs); + + exports.PDFJS = pdfjsLibs.pdfjsSharedGlobal.PDFJS; + + exports.getDocument = pdfjsLibs.pdfjsDisplayAPI.getDocument; + exports.PDFDataRangeTransport = + pdfjsLibs.pdfjsDisplayAPI.PDFDataRangeTransport; + exports.renderTextLayer = pdfjsLibs.pdfjsDisplayTextLayer.renderTextLayer; + exports.AnnotationLayer = + pdfjsLibs.pdfjsDisplayAnnotationLayer.AnnotationLayer; + exports.CustomStyle = pdfjsLibs.pdfjsDisplayDOMUtils.CustomStyle; + exports.PasswordResponses = pdfjsLibs.pdfjsSharedUtil.PasswordResponses; + exports.InvalidPDFException = pdfjsLibs.pdfjsSharedUtil.InvalidPDFException; + exports.MissingPDFException = pdfjsLibs.pdfjsSharedUtil.MissingPDFException; + exports.UnexpectedResponseException = + pdfjsLibs.pdfjsSharedUtil.UnexpectedResponseException; +})); + + diff --git a/static/js/pdf.worker.js b/static/js/pdf.worker.js new file mode 100644 index 0000000..821ceac --- /dev/null +++ b/static/js/pdf.worker.js @@ -0,0 +1,42034 @@ +/* Copyright 2012 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. + */ +/* jshint globalstrict: false */ +/* umdutils ignore */ + +(function (root, factory) { + 'use strict'; + if (typeof define === 'function' && define.amd) { +define('pdfjs-dist/build/pdf.worker', ['exports'], factory); + } else if (typeof exports !== 'undefined') { + factory(exports); + } else { +factory((root.pdfjsDistBuildPdfWorker = {})); + } +}(this, function (exports) { + // Use strict in our context only - users might not want it + 'use strict'; + +var pdfjsVersion = '1.4.20'; +var pdfjsBuild = 'b15f335'; + + var pdfjsFilePath = + typeof document !== 'undefined' && document.currentScript ? + document.currentScript.src : null; + + var pdfjsLibs = {}; + + (function pdfjsWrapper() { + + + +(function (root, factory) { + { + factory((root.pdfjsCoreArithmeticDecoder = {})); + } +}(this, function (exports) { + +/* This class implements the QM Coder decoding as defined in + * JPEG 2000 Part I Final Committee Draft Version 1.0 + * Annex C.3 Arithmetic decoding procedure + * available at http://www.jpeg.org/public/fcd15444-1.pdf + * + * The arithmetic decoder is used in conjunction with context models to decode + * JPEG2000 and JBIG2 streams. + */ +var ArithmeticDecoder = (function ArithmeticDecoderClosure() { + // Table C-2 + var QeTable = [ + {qe: 0x5601, nmps: 1, nlps: 1, switchFlag: 1}, + {qe: 0x3401, nmps: 2, nlps: 6, switchFlag: 0}, + {qe: 0x1801, nmps: 3, nlps: 9, switchFlag: 0}, + {qe: 0x0AC1, nmps: 4, nlps: 12, switchFlag: 0}, + {qe: 0x0521, nmps: 5, nlps: 29, switchFlag: 0}, + {qe: 0x0221, nmps: 38, nlps: 33, switchFlag: 0}, + {qe: 0x5601, nmps: 7, nlps: 6, switchFlag: 1}, + {qe: 0x5401, nmps: 8, nlps: 14, switchFlag: 0}, + {qe: 0x4801, nmps: 9, nlps: 14, switchFlag: 0}, + {qe: 0x3801, nmps: 10, nlps: 14, switchFlag: 0}, + {qe: 0x3001, nmps: 11, nlps: 17, switchFlag: 0}, + {qe: 0x2401, nmps: 12, nlps: 18, switchFlag: 0}, + {qe: 0x1C01, nmps: 13, nlps: 20, switchFlag: 0}, + {qe: 0x1601, nmps: 29, nlps: 21, switchFlag: 0}, + {qe: 0x5601, nmps: 15, nlps: 14, switchFlag: 1}, + {qe: 0x5401, nmps: 16, nlps: 14, switchFlag: 0}, + {qe: 0x5101, nmps: 17, nlps: 15, switchFlag: 0}, + {qe: 0x4801, nmps: 18, nlps: 16, switchFlag: 0}, + {qe: 0x3801, nmps: 19, nlps: 17, switchFlag: 0}, + {qe: 0x3401, nmps: 20, nlps: 18, switchFlag: 0}, + {qe: 0x3001, nmps: 21, nlps: 19, switchFlag: 0}, + {qe: 0x2801, nmps: 22, nlps: 19, switchFlag: 0}, + {qe: 0x2401, nmps: 23, nlps: 20, switchFlag: 0}, + {qe: 0x2201, nmps: 24, nlps: 21, switchFlag: 0}, + {qe: 0x1C01, nmps: 25, nlps: 22, switchFlag: 0}, + {qe: 0x1801, nmps: 26, nlps: 23, switchFlag: 0}, + {qe: 0x1601, nmps: 27, nlps: 24, switchFlag: 0}, + {qe: 0x1401, nmps: 28, nlps: 25, switchFlag: 0}, + {qe: 0x1201, nmps: 29, nlps: 26, switchFlag: 0}, + {qe: 0x1101, nmps: 30, nlps: 27, switchFlag: 0}, + {qe: 0x0AC1, nmps: 31, nlps: 28, switchFlag: 0}, + {qe: 0x09C1, nmps: 32, nlps: 29, switchFlag: 0}, + {qe: 0x08A1, nmps: 33, nlps: 30, switchFlag: 0}, + {qe: 0x0521, nmps: 34, nlps: 31, switchFlag: 0}, + {qe: 0x0441, nmps: 35, nlps: 32, switchFlag: 0}, + {qe: 0x02A1, nmps: 36, nlps: 33, switchFlag: 0}, + {qe: 0x0221, nmps: 37, nlps: 34, switchFlag: 0}, + {qe: 0x0141, nmps: 38, nlps: 35, switchFlag: 0}, + {qe: 0x0111, nmps: 39, nlps: 36, switchFlag: 0}, + {qe: 0x0085, nmps: 40, nlps: 37, switchFlag: 0}, + {qe: 0x0049, nmps: 41, nlps: 38, switchFlag: 0}, + {qe: 0x0025, nmps: 42, nlps: 39, switchFlag: 0}, + {qe: 0x0015, nmps: 43, nlps: 40, switchFlag: 0}, + {qe: 0x0009, nmps: 44, nlps: 41, switchFlag: 0}, + {qe: 0x0005, nmps: 45, nlps: 42, switchFlag: 0}, + {qe: 0x0001, nmps: 45, nlps: 43, switchFlag: 0}, + {qe: 0x5601, nmps: 46, nlps: 46, switchFlag: 0} + ]; + + // C.3.5 Initialisation of the decoder (INITDEC) + function ArithmeticDecoder(data, start, end) { + this.data = data; + this.bp = start; + this.dataEnd = end; + + this.chigh = data[start]; + this.clow = 0; + + this.byteIn(); + + this.chigh = ((this.chigh << 7) & 0xFFFF) | ((this.clow >> 9) & 0x7F); + this.clow = (this.clow << 7) & 0xFFFF; + this.ct -= 7; + this.a = 0x8000; + } + + ArithmeticDecoder.prototype = { + // C.3.4 Compressed data input (BYTEIN) + byteIn: function ArithmeticDecoder_byteIn() { + var data = this.data; + var bp = this.bp; + if (data[bp] === 0xFF) { + var b1 = data[bp + 1]; + if (b1 > 0x8F) { + this.clow += 0xFF00; + this.ct = 8; + } else { + bp++; + this.clow += (data[bp] << 9); + this.ct = 7; + this.bp = bp; + } + } else { + bp++; + this.clow += bp < this.dataEnd ? (data[bp] << 8) : 0xFF00; + this.ct = 8; + this.bp = bp; + } + if (this.clow > 0xFFFF) { + this.chigh += (this.clow >> 16); + this.clow &= 0xFFFF; + } + }, + // C.3.2 Decoding a decision (DECODE) + readBit: function ArithmeticDecoder_readBit(contexts, pos) { + // contexts are packed into 1 byte: + // highest 7 bits carry cx.index, lowest bit carries cx.mps + var cx_index = contexts[pos] >> 1, cx_mps = contexts[pos] & 1; + var qeTableIcx = QeTable[cx_index]; + var qeIcx = qeTableIcx.qe; + var d; + var a = this.a - qeIcx; + + if (this.chigh < qeIcx) { + // exchangeLps + if (a < qeIcx) { + a = qeIcx; + d = cx_mps; + cx_index = qeTableIcx.nmps; + } else { + a = qeIcx; + d = 1 ^ cx_mps; + if (qeTableIcx.switchFlag === 1) { + cx_mps = d; + } + cx_index = qeTableIcx.nlps; + } + } else { + this.chigh -= qeIcx; + if ((a & 0x8000) !== 0) { + this.a = a; + return cx_mps; + } + // exchangeMps + if (a < qeIcx) { + d = 1 ^ cx_mps; + if (qeTableIcx.switchFlag === 1) { + cx_mps = d; + } + cx_index = qeTableIcx.nlps; + } else { + d = cx_mps; + cx_index = qeTableIcx.nmps; + } + } + // C.3.3 renormD; + do { + if (this.ct === 0) { + this.byteIn(); + } + + a <<= 1; + this.chigh = ((this.chigh << 1) & 0xFFFF) | ((this.clow >> 15) & 1); + this.clow = (this.clow << 1) & 0xFFFF; + this.ct--; + } while ((a & 0x8000) === 0); + this.a = a; + + contexts[pos] = cx_index << 1 | cx_mps; + return d; + } + }; + + return ArithmeticDecoder; +})(); + +exports.ArithmeticDecoder = ArithmeticDecoder; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreCharsets = {})); + } +}(this, function (exports) { + +var ISOAdobeCharset = [ + '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', + 'percent', 'ampersand', 'quoteright', 'parenleft', 'parenright', + 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash', 'zero', + 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', + 'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question', + 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore', + 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', + 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + 'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent', + 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency', + 'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft', + 'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl', + 'periodcentered', 'paragraph', 'bullet', 'quotesinglbase', + 'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis', + 'perthousand', 'questiondown', 'grave', 'acute', 'circumflex', 'tilde', + 'macron', 'breve', 'dotaccent', 'dieresis', 'ring', 'cedilla', + 'hungarumlaut', 'ogonek', 'caron', 'emdash', 'AE', 'ordfeminine', + 'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae', 'dotlessi', 'lslash', + 'oslash', 'oe', 'germandbls', 'onesuperior', 'logicalnot', 'mu', + 'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn', 'onequarter', + 'divide', 'brokenbar', 'degree', 'thorn', 'threequarters', 'twosuperior', + 'registered', 'minus', 'eth', 'multiply', 'threesuperior', 'copyright', + 'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring', 'Atilde', + 'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave', 'Iacute', + 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute', 'Ocircumflex', + 'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute', 'Ucircumflex', + 'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron', 'aacute', + 'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde', 'ccedilla', + 'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute', 'icircumflex', + 'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex', 'odieresis', + 'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex', 'udieresis', + 'ugrave', 'yacute', 'ydieresis', 'zcaron' +]; + +var ExpertCharset = [ + '.notdef', 'space', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle', + 'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior', + 'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'comma', + 'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle', + 'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', + 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', + 'colon', 'semicolon', 'commasuperior', 'threequartersemdash', + 'periodsuperior', 'questionsmall', 'asuperior', 'bsuperior', + 'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior', + 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', + 'tsuperior', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', + 'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall', + 'Asmall', 'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', + 'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', + 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', + 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', + 'onefitted', 'rupiah', 'Tildesmall', 'exclamdownsmall', 'centoldstyle', + 'Lslashsmall', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', + 'Brevesmall', 'Caronsmall', 'Dotaccentsmall', 'Macronsmall', + 'figuredash', 'hypheninferior', 'Ogoneksmall', 'Ringsmall', + 'Cedillasmall', 'onequarter', 'onehalf', 'threequarters', + 'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths', + 'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior', + 'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior', + 'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior', + 'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior', + 'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior', + 'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior', + 'periodinferior', 'commainferior', 'Agravesmall', 'Aacutesmall', + 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall', 'Aringsmall', + 'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall', + 'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall', + 'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall', + 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall', + 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall', + 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall', + 'Ydieresissmall' +]; + +var ExpertSubsetCharset = [ + '.notdef', 'space', 'dollaroldstyle', 'dollarsuperior', + 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader', + 'onedotenleader', 'comma', 'hyphen', 'period', 'fraction', + 'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle', + 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle', + 'eightoldstyle', 'nineoldstyle', 'colon', 'semicolon', 'commasuperior', + 'threequartersemdash', 'periodsuperior', 'asuperior', 'bsuperior', + 'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior', + 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', + 'tsuperior', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', + 'parenrightinferior', 'hyphensuperior', 'colonmonetary', 'onefitted', + 'rupiah', 'centoldstyle', 'figuredash', 'hypheninferior', 'onequarter', + 'onehalf', 'threequarters', 'oneeighth', 'threeeighths', 'fiveeighths', + 'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior', + 'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior', + 'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior', + 'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior', + 'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior', + 'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior', + 'periodinferior', 'commainferior' +]; + +exports.ISOAdobeCharset = ISOAdobeCharset; +exports.ExpertCharset = ExpertCharset; +exports.ExpertSubsetCharset = ExpertSubsetCharset; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreGlyphList = {})); + } +}(this, function (exports) { + +var GlyphsUnicode = { + A: 0x0041, + AE: 0x00C6, + AEacute: 0x01FC, + AEmacron: 0x01E2, + AEsmall: 0xF7E6, + Aacute: 0x00C1, + Aacutesmall: 0xF7E1, + Abreve: 0x0102, + Abreveacute: 0x1EAE, + Abrevecyrillic: 0x04D0, + Abrevedotbelow: 0x1EB6, + Abrevegrave: 0x1EB0, + Abrevehookabove: 0x1EB2, + Abrevetilde: 0x1EB4, + Acaron: 0x01CD, + Acircle: 0x24B6, + Acircumflex: 0x00C2, + Acircumflexacute: 0x1EA4, + Acircumflexdotbelow: 0x1EAC, + Acircumflexgrave: 0x1EA6, + Acircumflexhookabove: 0x1EA8, + Acircumflexsmall: 0xF7E2, + Acircumflextilde: 0x1EAA, + Acute: 0xF6C9, + Acutesmall: 0xF7B4, + Acyrillic: 0x0410, + Adblgrave: 0x0200, + Adieresis: 0x00C4, + Adieresiscyrillic: 0x04D2, + Adieresismacron: 0x01DE, + Adieresissmall: 0xF7E4, + Adotbelow: 0x1EA0, + Adotmacron: 0x01E0, + Agrave: 0x00C0, + Agravesmall: 0xF7E0, + Ahookabove: 0x1EA2, + Aiecyrillic: 0x04D4, + Ainvertedbreve: 0x0202, + Alpha: 0x0391, + Alphatonos: 0x0386, + Amacron: 0x0100, + Amonospace: 0xFF21, + Aogonek: 0x0104, + Aring: 0x00C5, + Aringacute: 0x01FA, + Aringbelow: 0x1E00, + Aringsmall: 0xF7E5, + Asmall: 0xF761, + Atilde: 0x00C3, + Atildesmall: 0xF7E3, + Aybarmenian: 0x0531, + B: 0x0042, + Bcircle: 0x24B7, + Bdotaccent: 0x1E02, + Bdotbelow: 0x1E04, + Becyrillic: 0x0411, + Benarmenian: 0x0532, + Beta: 0x0392, + Bhook: 0x0181, + Blinebelow: 0x1E06, + Bmonospace: 0xFF22, + Brevesmall: 0xF6F4, + Bsmall: 0xF762, + Btopbar: 0x0182, + C: 0x0043, + Caarmenian: 0x053E, + Cacute: 0x0106, + Caron: 0xF6CA, + Caronsmall: 0xF6F5, + Ccaron: 0x010C, + Ccedilla: 0x00C7, + Ccedillaacute: 0x1E08, + Ccedillasmall: 0xF7E7, + Ccircle: 0x24B8, + Ccircumflex: 0x0108, + Cdot: 0x010A, + Cdotaccent: 0x010A, + Cedillasmall: 0xF7B8, + Chaarmenian: 0x0549, + Cheabkhasiancyrillic: 0x04BC, + Checyrillic: 0x0427, + Chedescenderabkhasiancyrillic: 0x04BE, + Chedescendercyrillic: 0x04B6, + Chedieresiscyrillic: 0x04F4, + Cheharmenian: 0x0543, + Chekhakassiancyrillic: 0x04CB, + Cheverticalstrokecyrillic: 0x04B8, + Chi: 0x03A7, + Chook: 0x0187, + Circumflexsmall: 0xF6F6, + Cmonospace: 0xFF23, + Coarmenian: 0x0551, + Csmall: 0xF763, + D: 0x0044, + DZ: 0x01F1, + DZcaron: 0x01C4, + Daarmenian: 0x0534, + Dafrican: 0x0189, + Dcaron: 0x010E, + Dcedilla: 0x1E10, + Dcircle: 0x24B9, + Dcircumflexbelow: 0x1E12, + Dcroat: 0x0110, + Ddotaccent: 0x1E0A, + Ddotbelow: 0x1E0C, + Decyrillic: 0x0414, + Deicoptic: 0x03EE, + Delta: 0x2206, + Deltagreek: 0x0394, + Dhook: 0x018A, + Dieresis: 0xF6CB, + DieresisAcute: 0xF6CC, + DieresisGrave: 0xF6CD, + Dieresissmall: 0xF7A8, + Digammagreek: 0x03DC, + Djecyrillic: 0x0402, + Dlinebelow: 0x1E0E, + Dmonospace: 0xFF24, + Dotaccentsmall: 0xF6F7, + Dslash: 0x0110, + Dsmall: 0xF764, + Dtopbar: 0x018B, + Dz: 0x01F2, + Dzcaron: 0x01C5, + Dzeabkhasiancyrillic: 0x04E0, + Dzecyrillic: 0x0405, + Dzhecyrillic: 0x040F, + E: 0x0045, + Eacute: 0x00C9, + Eacutesmall: 0xF7E9, + Ebreve: 0x0114, + Ecaron: 0x011A, + Ecedillabreve: 0x1E1C, + Echarmenian: 0x0535, + Ecircle: 0x24BA, + Ecircumflex: 0x00CA, + Ecircumflexacute: 0x1EBE, + Ecircumflexbelow: 0x1E18, + Ecircumflexdotbelow: 0x1EC6, + Ecircumflexgrave: 0x1EC0, + Ecircumflexhookabove: 0x1EC2, + Ecircumflexsmall: 0xF7EA, + Ecircumflextilde: 0x1EC4, + Ecyrillic: 0x0404, + Edblgrave: 0x0204, + Edieresis: 0x00CB, + Edieresissmall: 0xF7EB, + Edot: 0x0116, + Edotaccent: 0x0116, + Edotbelow: 0x1EB8, + Efcyrillic: 0x0424, + Egrave: 0x00C8, + Egravesmall: 0xF7E8, + Eharmenian: 0x0537, + Ehookabove: 0x1EBA, + Eightroman: 0x2167, + Einvertedbreve: 0x0206, + Eiotifiedcyrillic: 0x0464, + Elcyrillic: 0x041B, + Elevenroman: 0x216A, + Emacron: 0x0112, + Emacronacute: 0x1E16, + Emacrongrave: 0x1E14, + Emcyrillic: 0x041C, + Emonospace: 0xFF25, + Encyrillic: 0x041D, + Endescendercyrillic: 0x04A2, + Eng: 0x014A, + Enghecyrillic: 0x04A4, + Enhookcyrillic: 0x04C7, + Eogonek: 0x0118, + Eopen: 0x0190, + Epsilon: 0x0395, + Epsilontonos: 0x0388, + Ercyrillic: 0x0420, + Ereversed: 0x018E, + Ereversedcyrillic: 0x042D, + Escyrillic: 0x0421, + Esdescendercyrillic: 0x04AA, + Esh: 0x01A9, + Esmall: 0xF765, + Eta: 0x0397, + Etarmenian: 0x0538, + Etatonos: 0x0389, + Eth: 0x00D0, + Ethsmall: 0xF7F0, + Etilde: 0x1EBC, + Etildebelow: 0x1E1A, + Euro: 0x20AC, + Ezh: 0x01B7, + Ezhcaron: 0x01EE, + Ezhreversed: 0x01B8, + F: 0x0046, + Fcircle: 0x24BB, + Fdotaccent: 0x1E1E, + Feharmenian: 0x0556, + Feicoptic: 0x03E4, + Fhook: 0x0191, + Fitacyrillic: 0x0472, + Fiveroman: 0x2164, + Fmonospace: 0xFF26, + Fourroman: 0x2163, + Fsmall: 0xF766, + G: 0x0047, + GBsquare: 0x3387, + Gacute: 0x01F4, + Gamma: 0x0393, + Gammaafrican: 0x0194, + Gangiacoptic: 0x03EA, + Gbreve: 0x011E, + Gcaron: 0x01E6, + Gcedilla: 0x0122, + Gcircle: 0x24BC, + Gcircumflex: 0x011C, + Gcommaaccent: 0x0122, + Gdot: 0x0120, + Gdotaccent: 0x0120, + Gecyrillic: 0x0413, + Ghadarmenian: 0x0542, + Ghemiddlehookcyrillic: 0x0494, + Ghestrokecyrillic: 0x0492, + Gheupturncyrillic: 0x0490, + Ghook: 0x0193, + Gimarmenian: 0x0533, + Gjecyrillic: 0x0403, + Gmacron: 0x1E20, + Gmonospace: 0xFF27, + Grave: 0xF6CE, + Gravesmall: 0xF760, + Gsmall: 0xF767, + Gsmallhook: 0x029B, + Gstroke: 0x01E4, + H: 0x0048, + H18533: 0x25CF, + H18543: 0x25AA, + H18551: 0x25AB, + H22073: 0x25A1, + HPsquare: 0x33CB, + Haabkhasiancyrillic: 0x04A8, + Hadescendercyrillic: 0x04B2, + Hardsigncyrillic: 0x042A, + Hbar: 0x0126, + Hbrevebelow: 0x1E2A, + Hcedilla: 0x1E28, + Hcircle: 0x24BD, + Hcircumflex: 0x0124, + Hdieresis: 0x1E26, + Hdotaccent: 0x1E22, + Hdotbelow: 0x1E24, + Hmonospace: 0xFF28, + Hoarmenian: 0x0540, + Horicoptic: 0x03E8, + Hsmall: 0xF768, + Hungarumlaut: 0xF6CF, + Hungarumlautsmall: 0xF6F8, + Hzsquare: 0x3390, + I: 0x0049, + IAcyrillic: 0x042F, + IJ: 0x0132, + IUcyrillic: 0x042E, + Iacute: 0x00CD, + Iacutesmall: 0xF7ED, + Ibreve: 0x012C, + Icaron: 0x01CF, + Icircle: 0x24BE, + Icircumflex: 0x00CE, + Icircumflexsmall: 0xF7EE, + Icyrillic: 0x0406, + Idblgrave: 0x0208, + Idieresis: 0x00CF, + Idieresisacute: 0x1E2E, + Idieresiscyrillic: 0x04E4, + Idieresissmall: 0xF7EF, + Idot: 0x0130, + Idotaccent: 0x0130, + Idotbelow: 0x1ECA, + Iebrevecyrillic: 0x04D6, + Iecyrillic: 0x0415, + Ifraktur: 0x2111, + Igrave: 0x00CC, + Igravesmall: 0xF7EC, + Ihookabove: 0x1EC8, + Iicyrillic: 0x0418, + Iinvertedbreve: 0x020A, + Iishortcyrillic: 0x0419, + Imacron: 0x012A, + Imacroncyrillic: 0x04E2, + Imonospace: 0xFF29, + Iniarmenian: 0x053B, + Iocyrillic: 0x0401, + Iogonek: 0x012E, + Iota: 0x0399, + Iotaafrican: 0x0196, + Iotadieresis: 0x03AA, + Iotatonos: 0x038A, + Ismall: 0xF769, + Istroke: 0x0197, + Itilde: 0x0128, + Itildebelow: 0x1E2C, + Izhitsacyrillic: 0x0474, + Izhitsadblgravecyrillic: 0x0476, + J: 0x004A, + Jaarmenian: 0x0541, + Jcircle: 0x24BF, + Jcircumflex: 0x0134, + Jecyrillic: 0x0408, + Jheharmenian: 0x054B, + Jmonospace: 0xFF2A, + Jsmall: 0xF76A, + K: 0x004B, + KBsquare: 0x3385, + KKsquare: 0x33CD, + Kabashkircyrillic: 0x04A0, + Kacute: 0x1E30, + Kacyrillic: 0x041A, + Kadescendercyrillic: 0x049A, + Kahookcyrillic: 0x04C3, + Kappa: 0x039A, + Kastrokecyrillic: 0x049E, + Kaverticalstrokecyrillic: 0x049C, + Kcaron: 0x01E8, + Kcedilla: 0x0136, + Kcircle: 0x24C0, + Kcommaaccent: 0x0136, + Kdotbelow: 0x1E32, + Keharmenian: 0x0554, + Kenarmenian: 0x053F, + Khacyrillic: 0x0425, + Kheicoptic: 0x03E6, + Khook: 0x0198, + Kjecyrillic: 0x040C, + Klinebelow: 0x1E34, + Kmonospace: 0xFF2B, + Koppacyrillic: 0x0480, + Koppagreek: 0x03DE, + Ksicyrillic: 0x046E, + Ksmall: 0xF76B, + L: 0x004C, + LJ: 0x01C7, + LL: 0xF6BF, + Lacute: 0x0139, + Lambda: 0x039B, + Lcaron: 0x013D, + Lcedilla: 0x013B, + Lcircle: 0x24C1, + Lcircumflexbelow: 0x1E3C, + Lcommaaccent: 0x013B, + Ldot: 0x013F, + Ldotaccent: 0x013F, + Ldotbelow: 0x1E36, + Ldotbelowmacron: 0x1E38, + Liwnarmenian: 0x053C, + Lj: 0x01C8, + Ljecyrillic: 0x0409, + Llinebelow: 0x1E3A, + Lmonospace: 0xFF2C, + Lslash: 0x0141, + Lslashsmall: 0xF6F9, + Lsmall: 0xF76C, + M: 0x004D, + MBsquare: 0x3386, + Macron: 0xF6D0, + Macronsmall: 0xF7AF, + Macute: 0x1E3E, + Mcircle: 0x24C2, + Mdotaccent: 0x1E40, + Mdotbelow: 0x1E42, + Menarmenian: 0x0544, + Mmonospace: 0xFF2D, + Msmall: 0xF76D, + Mturned: 0x019C, + Mu: 0x039C, + N: 0x004E, + NJ: 0x01CA, + Nacute: 0x0143, + Ncaron: 0x0147, + Ncedilla: 0x0145, + Ncircle: 0x24C3, + Ncircumflexbelow: 0x1E4A, + Ncommaaccent: 0x0145, + Ndotaccent: 0x1E44, + Ndotbelow: 0x1E46, + Nhookleft: 0x019D, + Nineroman: 0x2168, + Nj: 0x01CB, + Njecyrillic: 0x040A, + Nlinebelow: 0x1E48, + Nmonospace: 0xFF2E, + Nowarmenian: 0x0546, + Nsmall: 0xF76E, + Ntilde: 0x00D1, + Ntildesmall: 0xF7F1, + Nu: 0x039D, + O: 0x004F, + OE: 0x0152, + OEsmall: 0xF6FA, + Oacute: 0x00D3, + Oacutesmall: 0xF7F3, + Obarredcyrillic: 0x04E8, + Obarreddieresiscyrillic: 0x04EA, + Obreve: 0x014E, + Ocaron: 0x01D1, + Ocenteredtilde: 0x019F, + Ocircle: 0x24C4, + Ocircumflex: 0x00D4, + Ocircumflexacute: 0x1ED0, + Ocircumflexdotbelow: 0x1ED8, + Ocircumflexgrave: 0x1ED2, + Ocircumflexhookabove: 0x1ED4, + Ocircumflexsmall: 0xF7F4, + Ocircumflextilde: 0x1ED6, + Ocyrillic: 0x041E, + Odblacute: 0x0150, + Odblgrave: 0x020C, + Odieresis: 0x00D6, + Odieresiscyrillic: 0x04E6, + Odieresissmall: 0xF7F6, + Odotbelow: 0x1ECC, + Ogoneksmall: 0xF6FB, + Ograve: 0x00D2, + Ogravesmall: 0xF7F2, + Oharmenian: 0x0555, + Ohm: 0x2126, + Ohookabove: 0x1ECE, + Ohorn: 0x01A0, + Ohornacute: 0x1EDA, + Ohorndotbelow: 0x1EE2, + Ohorngrave: 0x1EDC, + Ohornhookabove: 0x1EDE, + Ohorntilde: 0x1EE0, + Ohungarumlaut: 0x0150, + Oi: 0x01A2, + Oinvertedbreve: 0x020E, + Omacron: 0x014C, + Omacronacute: 0x1E52, + Omacrongrave: 0x1E50, + Omega: 0x2126, + Omegacyrillic: 0x0460, + Omegagreek: 0x03A9, + Omegaroundcyrillic: 0x047A, + Omegatitlocyrillic: 0x047C, + Omegatonos: 0x038F, + Omicron: 0x039F, + Omicrontonos: 0x038C, + Omonospace: 0xFF2F, + Oneroman: 0x2160, + Oogonek: 0x01EA, + Oogonekmacron: 0x01EC, + Oopen: 0x0186, + Oslash: 0x00D8, + Oslashacute: 0x01FE, + Oslashsmall: 0xF7F8, + Osmall: 0xF76F, + Ostrokeacute: 0x01FE, + Otcyrillic: 0x047E, + Otilde: 0x00D5, + Otildeacute: 0x1E4C, + Otildedieresis: 0x1E4E, + Otildesmall: 0xF7F5, + P: 0x0050, + Pacute: 0x1E54, + Pcircle: 0x24C5, + Pdotaccent: 0x1E56, + Pecyrillic: 0x041F, + Peharmenian: 0x054A, + Pemiddlehookcyrillic: 0x04A6, + Phi: 0x03A6, + Phook: 0x01A4, + Pi: 0x03A0, + Piwrarmenian: 0x0553, + Pmonospace: 0xFF30, + Psi: 0x03A8, + Psicyrillic: 0x0470, + Psmall: 0xF770, + Q: 0x0051, + Qcircle: 0x24C6, + Qmonospace: 0xFF31, + Qsmall: 0xF771, + R: 0x0052, + Raarmenian: 0x054C, + Racute: 0x0154, + Rcaron: 0x0158, + Rcedilla: 0x0156, + Rcircle: 0x24C7, + Rcommaaccent: 0x0156, + Rdblgrave: 0x0210, + Rdotaccent: 0x1E58, + Rdotbelow: 0x1E5A, + Rdotbelowmacron: 0x1E5C, + Reharmenian: 0x0550, + Rfraktur: 0x211C, + Rho: 0x03A1, + Ringsmall: 0xF6FC, + Rinvertedbreve: 0x0212, + Rlinebelow: 0x1E5E, + Rmonospace: 0xFF32, + Rsmall: 0xF772, + Rsmallinverted: 0x0281, + Rsmallinvertedsuperior: 0x02B6, + S: 0x0053, + SF010000: 0x250C, + SF020000: 0x2514, + SF030000: 0x2510, + SF040000: 0x2518, + SF050000: 0x253C, + SF060000: 0x252C, + SF070000: 0x2534, + SF080000: 0x251C, + SF090000: 0x2524, + SF100000: 0x2500, + SF110000: 0x2502, + SF190000: 0x2561, + SF200000: 0x2562, + SF210000: 0x2556, + SF220000: 0x2555, + SF230000: 0x2563, + SF240000: 0x2551, + SF250000: 0x2557, + SF260000: 0x255D, + SF270000: 0x255C, + SF280000: 0x255B, + SF360000: 0x255E, + SF370000: 0x255F, + SF380000: 0x255A, + SF390000: 0x2554, + SF400000: 0x2569, + SF410000: 0x2566, + SF420000: 0x2560, + SF430000: 0x2550, + SF440000: 0x256C, + SF450000: 0x2567, + SF460000: 0x2568, + SF470000: 0x2564, + SF480000: 0x2565, + SF490000: 0x2559, + SF500000: 0x2558, + SF510000: 0x2552, + SF520000: 0x2553, + SF530000: 0x256B, + SF540000: 0x256A, + Sacute: 0x015A, + Sacutedotaccent: 0x1E64, + Sampigreek: 0x03E0, + Scaron: 0x0160, + Scarondotaccent: 0x1E66, + Scaronsmall: 0xF6FD, + Scedilla: 0x015E, + Schwa: 0x018F, + Schwacyrillic: 0x04D8, + Schwadieresiscyrillic: 0x04DA, + Scircle: 0x24C8, + Scircumflex: 0x015C, + Scommaaccent: 0x0218, + Sdotaccent: 0x1E60, + Sdotbelow: 0x1E62, + Sdotbelowdotaccent: 0x1E68, + Seharmenian: 0x054D, + Sevenroman: 0x2166, + Shaarmenian: 0x0547, + Shacyrillic: 0x0428, + Shchacyrillic: 0x0429, + Sheicoptic: 0x03E2, + Shhacyrillic: 0x04BA, + Shimacoptic: 0x03EC, + Sigma: 0x03A3, + Sixroman: 0x2165, + Smonospace: 0xFF33, + Softsigncyrillic: 0x042C, + Ssmall: 0xF773, + Stigmagreek: 0x03DA, + T: 0x0054, + Tau: 0x03A4, + Tbar: 0x0166, + Tcaron: 0x0164, + Tcedilla: 0x0162, + Tcircle: 0x24C9, + Tcircumflexbelow: 0x1E70, + Tcommaaccent: 0x0162, + Tdotaccent: 0x1E6A, + Tdotbelow: 0x1E6C, + Tecyrillic: 0x0422, + Tedescendercyrillic: 0x04AC, + Tenroman: 0x2169, + Tetsecyrillic: 0x04B4, + Theta: 0x0398, + Thook: 0x01AC, + Thorn: 0x00DE, + Thornsmall: 0xF7FE, + Threeroman: 0x2162, + Tildesmall: 0xF6FE, + Tiwnarmenian: 0x054F, + Tlinebelow: 0x1E6E, + Tmonospace: 0xFF34, + Toarmenian: 0x0539, + Tonefive: 0x01BC, + Tonesix: 0x0184, + Tonetwo: 0x01A7, + Tretroflexhook: 0x01AE, + Tsecyrillic: 0x0426, + Tshecyrillic: 0x040B, + Tsmall: 0xF774, + Twelveroman: 0x216B, + Tworoman: 0x2161, + U: 0x0055, + Uacute: 0x00DA, + Uacutesmall: 0xF7FA, + Ubreve: 0x016C, + Ucaron: 0x01D3, + Ucircle: 0x24CA, + Ucircumflex: 0x00DB, + Ucircumflexbelow: 0x1E76, + Ucircumflexsmall: 0xF7FB, + Ucyrillic: 0x0423, + Udblacute: 0x0170, + Udblgrave: 0x0214, + Udieresis: 0x00DC, + Udieresisacute: 0x01D7, + Udieresisbelow: 0x1E72, + Udieresiscaron: 0x01D9, + Udieresiscyrillic: 0x04F0, + Udieresisgrave: 0x01DB, + Udieresismacron: 0x01D5, + Udieresissmall: 0xF7FC, + Udotbelow: 0x1EE4, + Ugrave: 0x00D9, + Ugravesmall: 0xF7F9, + Uhookabove: 0x1EE6, + Uhorn: 0x01AF, + Uhornacute: 0x1EE8, + Uhorndotbelow: 0x1EF0, + Uhorngrave: 0x1EEA, + Uhornhookabove: 0x1EEC, + Uhorntilde: 0x1EEE, + Uhungarumlaut: 0x0170, + Uhungarumlautcyrillic: 0x04F2, + Uinvertedbreve: 0x0216, + Ukcyrillic: 0x0478, + Umacron: 0x016A, + Umacroncyrillic: 0x04EE, + Umacrondieresis: 0x1E7A, + Umonospace: 0xFF35, + Uogonek: 0x0172, + Upsilon: 0x03A5, + Upsilon1: 0x03D2, + Upsilonacutehooksymbolgreek: 0x03D3, + Upsilonafrican: 0x01B1, + Upsilondieresis: 0x03AB, + Upsilondieresishooksymbolgreek: 0x03D4, + Upsilonhooksymbol: 0x03D2, + Upsilontonos: 0x038E, + Uring: 0x016E, + Ushortcyrillic: 0x040E, + Usmall: 0xF775, + Ustraightcyrillic: 0x04AE, + Ustraightstrokecyrillic: 0x04B0, + Utilde: 0x0168, + Utildeacute: 0x1E78, + Utildebelow: 0x1E74, + V: 0x0056, + Vcircle: 0x24CB, + Vdotbelow: 0x1E7E, + Vecyrillic: 0x0412, + Vewarmenian: 0x054E, + Vhook: 0x01B2, + Vmonospace: 0xFF36, + Voarmenian: 0x0548, + Vsmall: 0xF776, + Vtilde: 0x1E7C, + W: 0x0057, + Wacute: 0x1E82, + Wcircle: 0x24CC, + Wcircumflex: 0x0174, + Wdieresis: 0x1E84, + Wdotaccent: 0x1E86, + Wdotbelow: 0x1E88, + Wgrave: 0x1E80, + Wmonospace: 0xFF37, + Wsmall: 0xF777, + X: 0x0058, + Xcircle: 0x24CD, + Xdieresis: 0x1E8C, + Xdotaccent: 0x1E8A, + Xeharmenian: 0x053D, + Xi: 0x039E, + Xmonospace: 0xFF38, + Xsmall: 0xF778, + Y: 0x0059, + Yacute: 0x00DD, + Yacutesmall: 0xF7FD, + Yatcyrillic: 0x0462, + Ycircle: 0x24CE, + Ycircumflex: 0x0176, + Ydieresis: 0x0178, + Ydieresissmall: 0xF7FF, + Ydotaccent: 0x1E8E, + Ydotbelow: 0x1EF4, + Yericyrillic: 0x042B, + Yerudieresiscyrillic: 0x04F8, + Ygrave: 0x1EF2, + Yhook: 0x01B3, + Yhookabove: 0x1EF6, + Yiarmenian: 0x0545, + Yicyrillic: 0x0407, + Yiwnarmenian: 0x0552, + Ymonospace: 0xFF39, + Ysmall: 0xF779, + Ytilde: 0x1EF8, + Yusbigcyrillic: 0x046A, + Yusbigiotifiedcyrillic: 0x046C, + Yuslittlecyrillic: 0x0466, + Yuslittleiotifiedcyrillic: 0x0468, + Z: 0x005A, + Zaarmenian: 0x0536, + Zacute: 0x0179, + Zcaron: 0x017D, + Zcaronsmall: 0xF6FF, + Zcircle: 0x24CF, + Zcircumflex: 0x1E90, + Zdot: 0x017B, + Zdotaccent: 0x017B, + Zdotbelow: 0x1E92, + Zecyrillic: 0x0417, + Zedescendercyrillic: 0x0498, + Zedieresiscyrillic: 0x04DE, + Zeta: 0x0396, + Zhearmenian: 0x053A, + Zhebrevecyrillic: 0x04C1, + Zhecyrillic: 0x0416, + Zhedescendercyrillic: 0x0496, + Zhedieresiscyrillic: 0x04DC, + Zlinebelow: 0x1E94, + Zmonospace: 0xFF3A, + Zsmall: 0xF77A, + Zstroke: 0x01B5, + a: 0x0061, + aabengali: 0x0986, + aacute: 0x00E1, + aadeva: 0x0906, + aagujarati: 0x0A86, + aagurmukhi: 0x0A06, + aamatragurmukhi: 0x0A3E, + aarusquare: 0x3303, + aavowelsignbengali: 0x09BE, + aavowelsigndeva: 0x093E, + aavowelsigngujarati: 0x0ABE, + abbreviationmarkarmenian: 0x055F, + abbreviationsigndeva: 0x0970, + abengali: 0x0985, + abopomofo: 0x311A, + abreve: 0x0103, + abreveacute: 0x1EAF, + abrevecyrillic: 0x04D1, + abrevedotbelow: 0x1EB7, + abrevegrave: 0x1EB1, + abrevehookabove: 0x1EB3, + abrevetilde: 0x1EB5, + acaron: 0x01CE, + acircle: 0x24D0, + acircumflex: 0x00E2, + acircumflexacute: 0x1EA5, + acircumflexdotbelow: 0x1EAD, + acircumflexgrave: 0x1EA7, + acircumflexhookabove: 0x1EA9, + acircumflextilde: 0x1EAB, + acute: 0x00B4, + acutebelowcmb: 0x0317, + acutecmb: 0x0301, + acutecomb: 0x0301, + acutedeva: 0x0954, + acutelowmod: 0x02CF, + acutetonecmb: 0x0341, + acyrillic: 0x0430, + adblgrave: 0x0201, + addakgurmukhi: 0x0A71, + adeva: 0x0905, + adieresis: 0x00E4, + adieresiscyrillic: 0x04D3, + adieresismacron: 0x01DF, + adotbelow: 0x1EA1, + adotmacron: 0x01E1, + ae: 0x00E6, + aeacute: 0x01FD, + aekorean: 0x3150, + aemacron: 0x01E3, + afii00208: 0x2015, + afii08941: 0x20A4, + afii10017: 0x0410, + afii10018: 0x0411, + afii10019: 0x0412, + afii10020: 0x0413, + afii10021: 0x0414, + afii10022: 0x0415, + afii10023: 0x0401, + afii10024: 0x0416, + afii10025: 0x0417, + afii10026: 0x0418, + afii10027: 0x0419, + afii10028: 0x041A, + afii10029: 0x041B, + afii10030: 0x041C, + afii10031: 0x041D, + afii10032: 0x041E, + afii10033: 0x041F, + afii10034: 0x0420, + afii10035: 0x0421, + afii10036: 0x0422, + afii10037: 0x0423, + afii10038: 0x0424, + afii10039: 0x0425, + afii10040: 0x0426, + afii10041: 0x0427, + afii10042: 0x0428, + afii10043: 0x0429, + afii10044: 0x042A, + afii10045: 0x042B, + afii10046: 0x042C, + afii10047: 0x042D, + afii10048: 0x042E, + afii10049: 0x042F, + afii10050: 0x0490, + afii10051: 0x0402, + afii10052: 0x0403, + afii10053: 0x0404, + afii10054: 0x0405, + afii10055: 0x0406, + afii10056: 0x0407, + afii10057: 0x0408, + afii10058: 0x0409, + afii10059: 0x040A, + afii10060: 0x040B, + afii10061: 0x040C, + afii10062: 0x040E, + afii10063: 0xF6C4, + afii10064: 0xF6C5, + afii10065: 0x0430, + afii10066: 0x0431, + afii10067: 0x0432, + afii10068: 0x0433, + afii10069: 0x0434, + afii10070: 0x0435, + afii10071: 0x0451, + afii10072: 0x0436, + afii10073: 0x0437, + afii10074: 0x0438, + afii10075: 0x0439, + afii10076: 0x043A, + afii10077: 0x043B, + afii10078: 0x043C, + afii10079: 0x043D, + afii10080: 0x043E, + afii10081: 0x043F, + afii10082: 0x0440, + afii10083: 0x0441, + afii10084: 0x0442, + afii10085: 0x0443, + afii10086: 0x0444, + afii10087: 0x0445, + afii10088: 0x0446, + afii10089: 0x0447, + afii10090: 0x0448, + afii10091: 0x0449, + afii10092: 0x044A, + afii10093: 0x044B, + afii10094: 0x044C, + afii10095: 0x044D, + afii10096: 0x044E, + afii10097: 0x044F, + afii10098: 0x0491, + afii10099: 0x0452, + afii10100: 0x0453, + afii10101: 0x0454, + afii10102: 0x0455, + afii10103: 0x0456, + afii10104: 0x0457, + afii10105: 0x0458, + afii10106: 0x0459, + afii10107: 0x045A, + afii10108: 0x045B, + afii10109: 0x045C, + afii10110: 0x045E, + afii10145: 0x040F, + afii10146: 0x0462, + afii10147: 0x0472, + afii10148: 0x0474, + afii10192: 0xF6C6, + afii10193: 0x045F, + afii10194: 0x0463, + afii10195: 0x0473, + afii10196: 0x0475, + afii10831: 0xF6C7, + afii10832: 0xF6C8, + afii10846: 0x04D9, + afii299: 0x200E, + afii300: 0x200F, + afii301: 0x200D, + afii57381: 0x066A, + afii57388: 0x060C, + afii57392: 0x0660, + afii57393: 0x0661, + afii57394: 0x0662, + afii57395: 0x0663, + afii57396: 0x0664, + afii57397: 0x0665, + afii57398: 0x0666, + afii57399: 0x0667, + afii57400: 0x0668, + afii57401: 0x0669, + afii57403: 0x061B, + afii57407: 0x061F, + afii57409: 0x0621, + afii57410: 0x0622, + afii57411: 0x0623, + afii57412: 0x0624, + afii57413: 0x0625, + afii57414: 0x0626, + afii57415: 0x0627, + afii57416: 0x0628, + afii57417: 0x0629, + afii57418: 0x062A, + afii57419: 0x062B, + afii57420: 0x062C, + afii57421: 0x062D, + afii57422: 0x062E, + afii57423: 0x062F, + afii57424: 0x0630, + afii57425: 0x0631, + afii57426: 0x0632, + afii57427: 0x0633, + afii57428: 0x0634, + afii57429: 0x0635, + afii57430: 0x0636, + afii57431: 0x0637, + afii57432: 0x0638, + afii57433: 0x0639, + afii57434: 0x063A, + afii57440: 0x0640, + afii57441: 0x0641, + afii57442: 0x0642, + afii57443: 0x0643, + afii57444: 0x0644, + afii57445: 0x0645, + afii57446: 0x0646, + afii57448: 0x0648, + afii57449: 0x0649, + afii57450: 0x064A, + afii57451: 0x064B, + afii57452: 0x064C, + afii57453: 0x064D, + afii57454: 0x064E, + afii57455: 0x064F, + afii57456: 0x0650, + afii57457: 0x0651, + afii57458: 0x0652, + afii57470: 0x0647, + afii57505: 0x06A4, + afii57506: 0x067E, + afii57507: 0x0686, + afii57508: 0x0698, + afii57509: 0x06AF, + afii57511: 0x0679, + afii57512: 0x0688, + afii57513: 0x0691, + afii57514: 0x06BA, + afii57519: 0x06D2, + afii57534: 0x06D5, + afii57636: 0x20AA, + afii57645: 0x05BE, + afii57658: 0x05C3, + afii57664: 0x05D0, + afii57665: 0x05D1, + afii57666: 0x05D2, + afii57667: 0x05D3, + afii57668: 0x05D4, + afii57669: 0x05D5, + afii57670: 0x05D6, + afii57671: 0x05D7, + afii57672: 0x05D8, + afii57673: 0x05D9, + afii57674: 0x05DA, + afii57675: 0x05DB, + afii57676: 0x05DC, + afii57677: 0x05DD, + afii57678: 0x05DE, + afii57679: 0x05DF, + afii57680: 0x05E0, + afii57681: 0x05E1, + afii57682: 0x05E2, + afii57683: 0x05E3, + afii57684: 0x05E4, + afii57685: 0x05E5, + afii57686: 0x05E6, + afii57687: 0x05E7, + afii57688: 0x05E8, + afii57689: 0x05E9, + afii57690: 0x05EA, + afii57694: 0xFB2A, + afii57695: 0xFB2B, + afii57700: 0xFB4B, + afii57705: 0xFB1F, + afii57716: 0x05F0, + afii57717: 0x05F1, + afii57718: 0x05F2, + afii57723: 0xFB35, + afii57793: 0x05B4, + afii57794: 0x05B5, + afii57795: 0x05B6, + afii57796: 0x05BB, + afii57797: 0x05B8, + afii57798: 0x05B7, + afii57799: 0x05B0, + afii57800: 0x05B2, + afii57801: 0x05B1, + afii57802: 0x05B3, + afii57803: 0x05C2, + afii57804: 0x05C1, + afii57806: 0x05B9, + afii57807: 0x05BC, + afii57839: 0x05BD, + afii57841: 0x05BF, + afii57842: 0x05C0, + afii57929: 0x02BC, + afii61248: 0x2105, + afii61289: 0x2113, + afii61352: 0x2116, + afii61573: 0x202C, + afii61574: 0x202D, + afii61575: 0x202E, + afii61664: 0x200C, + afii63167: 0x066D, + afii64937: 0x02BD, + agrave: 0x00E0, + agujarati: 0x0A85, + agurmukhi: 0x0A05, + ahiragana: 0x3042, + ahookabove: 0x1EA3, + aibengali: 0x0990, + aibopomofo: 0x311E, + aideva: 0x0910, + aiecyrillic: 0x04D5, + aigujarati: 0x0A90, + aigurmukhi: 0x0A10, + aimatragurmukhi: 0x0A48, + ainarabic: 0x0639, + ainfinalarabic: 0xFECA, + aininitialarabic: 0xFECB, + ainmedialarabic: 0xFECC, + ainvertedbreve: 0x0203, + aivowelsignbengali: 0x09C8, + aivowelsigndeva: 0x0948, + aivowelsigngujarati: 0x0AC8, + akatakana: 0x30A2, + akatakanahalfwidth: 0xFF71, + akorean: 0x314F, + alef: 0x05D0, + alefarabic: 0x0627, + alefdageshhebrew: 0xFB30, + aleffinalarabic: 0xFE8E, + alefhamzaabovearabic: 0x0623, + alefhamzaabovefinalarabic: 0xFE84, + alefhamzabelowarabic: 0x0625, + alefhamzabelowfinalarabic: 0xFE88, + alefhebrew: 0x05D0, + aleflamedhebrew: 0xFB4F, + alefmaddaabovearabic: 0x0622, + alefmaddaabovefinalarabic: 0xFE82, + alefmaksuraarabic: 0x0649, + alefmaksurafinalarabic: 0xFEF0, + alefmaksurainitialarabic: 0xFEF3, + alefmaksuramedialarabic: 0xFEF4, + alefpatahhebrew: 0xFB2E, + alefqamatshebrew: 0xFB2F, + aleph: 0x2135, + allequal: 0x224C, + alpha: 0x03B1, + alphatonos: 0x03AC, + amacron: 0x0101, + amonospace: 0xFF41, + ampersand: 0x0026, + ampersandmonospace: 0xFF06, + ampersandsmall: 0xF726, + amsquare: 0x33C2, + anbopomofo: 0x3122, + angbopomofo: 0x3124, + angbracketleft: 0x3008, // This glyph is missing from Adobe's original list. + angbracketright: 0x3009, // This glyph is missing from Adobe's original list. + angkhankhuthai: 0x0E5A, + angle: 0x2220, + anglebracketleft: 0x3008, + anglebracketleftvertical: 0xFE3F, + anglebracketright: 0x3009, + anglebracketrightvertical: 0xFE40, + angleleft: 0x2329, + angleright: 0x232A, + angstrom: 0x212B, + anoteleia: 0x0387, + anudattadeva: 0x0952, + anusvarabengali: 0x0982, + anusvaradeva: 0x0902, + anusvaragujarati: 0x0A82, + aogonek: 0x0105, + apaatosquare: 0x3300, + aparen: 0x249C, + apostrophearmenian: 0x055A, + apostrophemod: 0x02BC, + apple: 0xF8FF, + approaches: 0x2250, + approxequal: 0x2248, + approxequalorimage: 0x2252, + approximatelyequal: 0x2245, + araeaekorean: 0x318E, + araeakorean: 0x318D, + arc: 0x2312, + arighthalfring: 0x1E9A, + aring: 0x00E5, + aringacute: 0x01FB, + aringbelow: 0x1E01, + arrowboth: 0x2194, + arrowdashdown: 0x21E3, + arrowdashleft: 0x21E0, + arrowdashright: 0x21E2, + arrowdashup: 0x21E1, + arrowdblboth: 0x21D4, + arrowdbldown: 0x21D3, + arrowdblleft: 0x21D0, + arrowdblright: 0x21D2, + arrowdblup: 0x21D1, + arrowdown: 0x2193, + arrowdownleft: 0x2199, + arrowdownright: 0x2198, + arrowdownwhite: 0x21E9, + arrowheaddownmod: 0x02C5, + arrowheadleftmod: 0x02C2, + arrowheadrightmod: 0x02C3, + arrowheadupmod: 0x02C4, + arrowhorizex: 0xF8E7, + arrowleft: 0x2190, + arrowleftdbl: 0x21D0, + arrowleftdblstroke: 0x21CD, + arrowleftoverright: 0x21C6, + arrowleftwhite: 0x21E6, + arrowright: 0x2192, + arrowrightdblstroke: 0x21CF, + arrowrightheavy: 0x279E, + arrowrightoverleft: 0x21C4, + arrowrightwhite: 0x21E8, + arrowtableft: 0x21E4, + arrowtabright: 0x21E5, + arrowup: 0x2191, + arrowupdn: 0x2195, + arrowupdnbse: 0x21A8, + arrowupdownbase: 0x21A8, + arrowupleft: 0x2196, + arrowupleftofdown: 0x21C5, + arrowupright: 0x2197, + arrowupwhite: 0x21E7, + arrowvertex: 0xF8E6, + asciicircum: 0x005E, + asciicircummonospace: 0xFF3E, + asciitilde: 0x007E, + asciitildemonospace: 0xFF5E, + ascript: 0x0251, + ascriptturned: 0x0252, + asmallhiragana: 0x3041, + asmallkatakana: 0x30A1, + asmallkatakanahalfwidth: 0xFF67, + asterisk: 0x002A, + asteriskaltonearabic: 0x066D, + asteriskarabic: 0x066D, + asteriskmath: 0x2217, + asteriskmonospace: 0xFF0A, + asterisksmall: 0xFE61, + asterism: 0x2042, + asuperior: 0xF6E9, + asymptoticallyequal: 0x2243, + at: 0x0040, + atilde: 0x00E3, + atmonospace: 0xFF20, + atsmall: 0xFE6B, + aturned: 0x0250, + aubengali: 0x0994, + aubopomofo: 0x3120, + audeva: 0x0914, + augujarati: 0x0A94, + augurmukhi: 0x0A14, + aulengthmarkbengali: 0x09D7, + aumatragurmukhi: 0x0A4C, + auvowelsignbengali: 0x09CC, + auvowelsigndeva: 0x094C, + auvowelsigngujarati: 0x0ACC, + avagrahadeva: 0x093D, + aybarmenian: 0x0561, + ayin: 0x05E2, + ayinaltonehebrew: 0xFB20, + ayinhebrew: 0x05E2, + b: 0x0062, + babengali: 0x09AC, + backslash: 0x005C, + backslashmonospace: 0xFF3C, + badeva: 0x092C, + bagujarati: 0x0AAC, + bagurmukhi: 0x0A2C, + bahiragana: 0x3070, + bahtthai: 0x0E3F, + bakatakana: 0x30D0, + bar: 0x007C, + barmonospace: 0xFF5C, + bbopomofo: 0x3105, + bcircle: 0x24D1, + bdotaccent: 0x1E03, + bdotbelow: 0x1E05, + beamedsixteenthnotes: 0x266C, + because: 0x2235, + becyrillic: 0x0431, + beharabic: 0x0628, + behfinalarabic: 0xFE90, + behinitialarabic: 0xFE91, + behiragana: 0x3079, + behmedialarabic: 0xFE92, + behmeeminitialarabic: 0xFC9F, + behmeemisolatedarabic: 0xFC08, + behnoonfinalarabic: 0xFC6D, + bekatakana: 0x30D9, + benarmenian: 0x0562, + bet: 0x05D1, + beta: 0x03B2, + betasymbolgreek: 0x03D0, + betdagesh: 0xFB31, + betdageshhebrew: 0xFB31, + bethebrew: 0x05D1, + betrafehebrew: 0xFB4C, + bhabengali: 0x09AD, + bhadeva: 0x092D, + bhagujarati: 0x0AAD, + bhagurmukhi: 0x0A2D, + bhook: 0x0253, + bihiragana: 0x3073, + bikatakana: 0x30D3, + bilabialclick: 0x0298, + bindigurmukhi: 0x0A02, + birusquare: 0x3331, + blackcircle: 0x25CF, + blackdiamond: 0x25C6, + blackdownpointingtriangle: 0x25BC, + blackleftpointingpointer: 0x25C4, + blackleftpointingtriangle: 0x25C0, + blacklenticularbracketleft: 0x3010, + blacklenticularbracketleftvertical: 0xFE3B, + blacklenticularbracketright: 0x3011, + blacklenticularbracketrightvertical: 0xFE3C, + blacklowerlefttriangle: 0x25E3, + blacklowerrighttriangle: 0x25E2, + blackrectangle: 0x25AC, + blackrightpointingpointer: 0x25BA, + blackrightpointingtriangle: 0x25B6, + blacksmallsquare: 0x25AA, + blacksmilingface: 0x263B, + blacksquare: 0x25A0, + blackstar: 0x2605, + blackupperlefttriangle: 0x25E4, + blackupperrighttriangle: 0x25E5, + blackuppointingsmalltriangle: 0x25B4, + blackuppointingtriangle: 0x25B2, + blank: 0x2423, + blinebelow: 0x1E07, + block: 0x2588, + bmonospace: 0xFF42, + bobaimaithai: 0x0E1A, + bohiragana: 0x307C, + bokatakana: 0x30DC, + bparen: 0x249D, + bqsquare: 0x33C3, + braceex: 0xF8F4, + braceleft: 0x007B, + braceleftbt: 0xF8F3, + braceleftmid: 0xF8F2, + braceleftmonospace: 0xFF5B, + braceleftsmall: 0xFE5B, + bracelefttp: 0xF8F1, + braceleftvertical: 0xFE37, + braceright: 0x007D, + bracerightbt: 0xF8FE, + bracerightmid: 0xF8FD, + bracerightmonospace: 0xFF5D, + bracerightsmall: 0xFE5C, + bracerighttp: 0xF8FC, + bracerightvertical: 0xFE38, + bracketleft: 0x005B, + bracketleftbt: 0xF8F0, + bracketleftex: 0xF8EF, + bracketleftmonospace: 0xFF3B, + bracketlefttp: 0xF8EE, + bracketright: 0x005D, + bracketrightbt: 0xF8FB, + bracketrightex: 0xF8FA, + bracketrightmonospace: 0xFF3D, + bracketrighttp: 0xF8F9, + breve: 0x02D8, + brevebelowcmb: 0x032E, + brevecmb: 0x0306, + breveinvertedbelowcmb: 0x032F, + breveinvertedcmb: 0x0311, + breveinverteddoublecmb: 0x0361, + bridgebelowcmb: 0x032A, + bridgeinvertedbelowcmb: 0x033A, + brokenbar: 0x00A6, + bstroke: 0x0180, + bsuperior: 0xF6EA, + btopbar: 0x0183, + buhiragana: 0x3076, + bukatakana: 0x30D6, + bullet: 0x2022, + bulletinverse: 0x25D8, + bulletoperator: 0x2219, + bullseye: 0x25CE, + c: 0x0063, + caarmenian: 0x056E, + cabengali: 0x099A, + cacute: 0x0107, + cadeva: 0x091A, + cagujarati: 0x0A9A, + cagurmukhi: 0x0A1A, + calsquare: 0x3388, + candrabindubengali: 0x0981, + candrabinducmb: 0x0310, + candrabindudeva: 0x0901, + candrabindugujarati: 0x0A81, + capslock: 0x21EA, + careof: 0x2105, + caron: 0x02C7, + caronbelowcmb: 0x032C, + caroncmb: 0x030C, + carriagereturn: 0x21B5, + cbopomofo: 0x3118, + ccaron: 0x010D, + ccedilla: 0x00E7, + ccedillaacute: 0x1E09, + ccircle: 0x24D2, + ccircumflex: 0x0109, + ccurl: 0x0255, + cdot: 0x010B, + cdotaccent: 0x010B, + cdsquare: 0x33C5, + cedilla: 0x00B8, + cedillacmb: 0x0327, + cent: 0x00A2, + centigrade: 0x2103, + centinferior: 0xF6DF, + centmonospace: 0xFFE0, + centoldstyle: 0xF7A2, + centsuperior: 0xF6E0, + chaarmenian: 0x0579, + chabengali: 0x099B, + chadeva: 0x091B, + chagujarati: 0x0A9B, + chagurmukhi: 0x0A1B, + chbopomofo: 0x3114, + cheabkhasiancyrillic: 0x04BD, + checkmark: 0x2713, + checyrillic: 0x0447, + chedescenderabkhasiancyrillic: 0x04BF, + chedescendercyrillic: 0x04B7, + chedieresiscyrillic: 0x04F5, + cheharmenian: 0x0573, + chekhakassiancyrillic: 0x04CC, + cheverticalstrokecyrillic: 0x04B9, + chi: 0x03C7, + chieuchacirclekorean: 0x3277, + chieuchaparenkorean: 0x3217, + chieuchcirclekorean: 0x3269, + chieuchkorean: 0x314A, + chieuchparenkorean: 0x3209, + chochangthai: 0x0E0A, + chochanthai: 0x0E08, + chochingthai: 0x0E09, + chochoethai: 0x0E0C, + chook: 0x0188, + cieucacirclekorean: 0x3276, + cieucaparenkorean: 0x3216, + cieuccirclekorean: 0x3268, + cieuckorean: 0x3148, + cieucparenkorean: 0x3208, + cieucuparenkorean: 0x321C, + circle: 0x25CB, + circlecopyrt: 0x00A9, // This glyph is missing from Adobe's original list. + circlemultiply: 0x2297, + circleot: 0x2299, + circleplus: 0x2295, + circlepostalmark: 0x3036, + circlewithlefthalfblack: 0x25D0, + circlewithrighthalfblack: 0x25D1, + circumflex: 0x02C6, + circumflexbelowcmb: 0x032D, + circumflexcmb: 0x0302, + clear: 0x2327, + clickalveolar: 0x01C2, + clickdental: 0x01C0, + clicklateral: 0x01C1, + clickretroflex: 0x01C3, + club: 0x2663, + clubsuitblack: 0x2663, + clubsuitwhite: 0x2667, + cmcubedsquare: 0x33A4, + cmonospace: 0xFF43, + cmsquaredsquare: 0x33A0, + coarmenian: 0x0581, + colon: 0x003A, + colonmonetary: 0x20A1, + colonmonospace: 0xFF1A, + colonsign: 0x20A1, + colonsmall: 0xFE55, + colontriangularhalfmod: 0x02D1, + colontriangularmod: 0x02D0, + comma: 0x002C, + commaabovecmb: 0x0313, + commaaboverightcmb: 0x0315, + commaaccent: 0xF6C3, + commaarabic: 0x060C, + commaarmenian: 0x055D, + commainferior: 0xF6E1, + commamonospace: 0xFF0C, + commareversedabovecmb: 0x0314, + commareversedmod: 0x02BD, + commasmall: 0xFE50, + commasuperior: 0xF6E2, + commaturnedabovecmb: 0x0312, + commaturnedmod: 0x02BB, + compass: 0x263C, + congruent: 0x2245, + contourintegral: 0x222E, + control: 0x2303, + controlACK: 0x0006, + controlBEL: 0x0007, + controlBS: 0x0008, + controlCAN: 0x0018, + controlCR: 0x000D, + controlDC1: 0x0011, + controlDC2: 0x0012, + controlDC3: 0x0013, + controlDC4: 0x0014, + controlDEL: 0x007F, + controlDLE: 0x0010, + controlEM: 0x0019, + controlENQ: 0x0005, + controlEOT: 0x0004, + controlESC: 0x001B, + controlETB: 0x0017, + controlETX: 0x0003, + controlFF: 0x000C, + controlFS: 0x001C, + controlGS: 0x001D, + controlHT: 0x0009, + controlLF: 0x000A, + controlNAK: 0x0015, + controlRS: 0x001E, + controlSI: 0x000F, + controlSO: 0x000E, + controlSOT: 0x0002, + controlSTX: 0x0001, + controlSUB: 0x001A, + controlSYN: 0x0016, + controlUS: 0x001F, + controlVT: 0x000B, + copyright: 0x00A9, + copyrightsans: 0xF8E9, + copyrightserif: 0xF6D9, + cornerbracketleft: 0x300C, + cornerbracketlefthalfwidth: 0xFF62, + cornerbracketleftvertical: 0xFE41, + cornerbracketright: 0x300D, + cornerbracketrighthalfwidth: 0xFF63, + cornerbracketrightvertical: 0xFE42, + corporationsquare: 0x337F, + cosquare: 0x33C7, + coverkgsquare: 0x33C6, + cparen: 0x249E, + cruzeiro: 0x20A2, + cstretched: 0x0297, + curlyand: 0x22CF, + curlyor: 0x22CE, + currency: 0x00A4, + cyrBreve: 0xF6D1, + cyrFlex: 0xF6D2, + cyrbreve: 0xF6D4, + cyrflex: 0xF6D5, + d: 0x0064, + daarmenian: 0x0564, + dabengali: 0x09A6, + dadarabic: 0x0636, + dadeva: 0x0926, + dadfinalarabic: 0xFEBE, + dadinitialarabic: 0xFEBF, + dadmedialarabic: 0xFEC0, + dagesh: 0x05BC, + dageshhebrew: 0x05BC, + dagger: 0x2020, + daggerdbl: 0x2021, + dagujarati: 0x0AA6, + dagurmukhi: 0x0A26, + dahiragana: 0x3060, + dakatakana: 0x30C0, + dalarabic: 0x062F, + dalet: 0x05D3, + daletdagesh: 0xFB33, + daletdageshhebrew: 0xFB33, + dalethebrew: 0x05D3, + dalfinalarabic: 0xFEAA, + dammaarabic: 0x064F, + dammalowarabic: 0x064F, + dammatanaltonearabic: 0x064C, + dammatanarabic: 0x064C, + danda: 0x0964, + dargahebrew: 0x05A7, + dargalefthebrew: 0x05A7, + dasiapneumatacyrilliccmb: 0x0485, + dblGrave: 0xF6D3, + dblanglebracketleft: 0x300A, + dblanglebracketleftvertical: 0xFE3D, + dblanglebracketright: 0x300B, + dblanglebracketrightvertical: 0xFE3E, + dblarchinvertedbelowcmb: 0x032B, + dblarrowleft: 0x21D4, + dblarrowright: 0x21D2, + dbldanda: 0x0965, + dblgrave: 0xF6D6, + dblgravecmb: 0x030F, + dblintegral: 0x222C, + dbllowline: 0x2017, + dbllowlinecmb: 0x0333, + dbloverlinecmb: 0x033F, + dblprimemod: 0x02BA, + dblverticalbar: 0x2016, + dblverticallineabovecmb: 0x030E, + dbopomofo: 0x3109, + dbsquare: 0x33C8, + dcaron: 0x010F, + dcedilla: 0x1E11, + dcircle: 0x24D3, + dcircumflexbelow: 0x1E13, + dcroat: 0x0111, + ddabengali: 0x09A1, + ddadeva: 0x0921, + ddagujarati: 0x0AA1, + ddagurmukhi: 0x0A21, + ddalarabic: 0x0688, + ddalfinalarabic: 0xFB89, + dddhadeva: 0x095C, + ddhabengali: 0x09A2, + ddhadeva: 0x0922, + ddhagujarati: 0x0AA2, + ddhagurmukhi: 0x0A22, + ddotaccent: 0x1E0B, + ddotbelow: 0x1E0D, + decimalseparatorarabic: 0x066B, + decimalseparatorpersian: 0x066B, + decyrillic: 0x0434, + degree: 0x00B0, + dehihebrew: 0x05AD, + dehiragana: 0x3067, + deicoptic: 0x03EF, + dekatakana: 0x30C7, + deleteleft: 0x232B, + deleteright: 0x2326, + delta: 0x03B4, + deltaturned: 0x018D, + denominatorminusonenumeratorbengali: 0x09F8, + dezh: 0x02A4, + dhabengali: 0x09A7, + dhadeva: 0x0927, + dhagujarati: 0x0AA7, + dhagurmukhi: 0x0A27, + dhook: 0x0257, + dialytikatonos: 0x0385, + dialytikatonoscmb: 0x0344, + diamond: 0x2666, + diamondsuitwhite: 0x2662, + dieresis: 0x00A8, + dieresisacute: 0xF6D7, + dieresisbelowcmb: 0x0324, + dieresiscmb: 0x0308, + dieresisgrave: 0xF6D8, + dieresistonos: 0x0385, + dihiragana: 0x3062, + dikatakana: 0x30C2, + dittomark: 0x3003, + divide: 0x00F7, + divides: 0x2223, + divisionslash: 0x2215, + djecyrillic: 0x0452, + dkshade: 0x2593, + dlinebelow: 0x1E0F, + dlsquare: 0x3397, + dmacron: 0x0111, + dmonospace: 0xFF44, + dnblock: 0x2584, + dochadathai: 0x0E0E, + dodekthai: 0x0E14, + dohiragana: 0x3069, + dokatakana: 0x30C9, + dollar: 0x0024, + dollarinferior: 0xF6E3, + dollarmonospace: 0xFF04, + dollaroldstyle: 0xF724, + dollarsmall: 0xFE69, + dollarsuperior: 0xF6E4, + dong: 0x20AB, + dorusquare: 0x3326, + dotaccent: 0x02D9, + dotaccentcmb: 0x0307, + dotbelowcmb: 0x0323, + dotbelowcomb: 0x0323, + dotkatakana: 0x30FB, + dotlessi: 0x0131, + dotlessj: 0xF6BE, + dotlessjstrokehook: 0x0284, + dotmath: 0x22C5, + dottedcircle: 0x25CC, + doubleyodpatah: 0xFB1F, + doubleyodpatahhebrew: 0xFB1F, + downtackbelowcmb: 0x031E, + downtackmod: 0x02D5, + dparen: 0x249F, + dsuperior: 0xF6EB, + dtail: 0x0256, + dtopbar: 0x018C, + duhiragana: 0x3065, + dukatakana: 0x30C5, + dz: 0x01F3, + dzaltone: 0x02A3, + dzcaron: 0x01C6, + dzcurl: 0x02A5, + dzeabkhasiancyrillic: 0x04E1, + dzecyrillic: 0x0455, + dzhecyrillic: 0x045F, + e: 0x0065, + eacute: 0x00E9, + earth: 0x2641, + ebengali: 0x098F, + ebopomofo: 0x311C, + ebreve: 0x0115, + ecandradeva: 0x090D, + ecandragujarati: 0x0A8D, + ecandravowelsigndeva: 0x0945, + ecandravowelsigngujarati: 0x0AC5, + ecaron: 0x011B, + ecedillabreve: 0x1E1D, + echarmenian: 0x0565, + echyiwnarmenian: 0x0587, + ecircle: 0x24D4, + ecircumflex: 0x00EA, + ecircumflexacute: 0x1EBF, + ecircumflexbelow: 0x1E19, + ecircumflexdotbelow: 0x1EC7, + ecircumflexgrave: 0x1EC1, + ecircumflexhookabove: 0x1EC3, + ecircumflextilde: 0x1EC5, + ecyrillic: 0x0454, + edblgrave: 0x0205, + edeva: 0x090F, + edieresis: 0x00EB, + edot: 0x0117, + edotaccent: 0x0117, + edotbelow: 0x1EB9, + eegurmukhi: 0x0A0F, + eematragurmukhi: 0x0A47, + efcyrillic: 0x0444, + egrave: 0x00E8, + egujarati: 0x0A8F, + eharmenian: 0x0567, + ehbopomofo: 0x311D, + ehiragana: 0x3048, + ehookabove: 0x1EBB, + eibopomofo: 0x311F, + eight: 0x0038, + eightarabic: 0x0668, + eightbengali: 0x09EE, + eightcircle: 0x2467, + eightcircleinversesansserif: 0x2791, + eightdeva: 0x096E, + eighteencircle: 0x2471, + eighteenparen: 0x2485, + eighteenperiod: 0x2499, + eightgujarati: 0x0AEE, + eightgurmukhi: 0x0A6E, + eighthackarabic: 0x0668, + eighthangzhou: 0x3028, + eighthnotebeamed: 0x266B, + eightideographicparen: 0x3227, + eightinferior: 0x2088, + eightmonospace: 0xFF18, + eightoldstyle: 0xF738, + eightparen: 0x247B, + eightperiod: 0x248F, + eightpersian: 0x06F8, + eightroman: 0x2177, + eightsuperior: 0x2078, + eightthai: 0x0E58, + einvertedbreve: 0x0207, + eiotifiedcyrillic: 0x0465, + ekatakana: 0x30A8, + ekatakanahalfwidth: 0xFF74, + ekonkargurmukhi: 0x0A74, + ekorean: 0x3154, + elcyrillic: 0x043B, + element: 0x2208, + elevencircle: 0x246A, + elevenparen: 0x247E, + elevenperiod: 0x2492, + elevenroman: 0x217A, + ellipsis: 0x2026, + ellipsisvertical: 0x22EE, + emacron: 0x0113, + emacronacute: 0x1E17, + emacrongrave: 0x1E15, + emcyrillic: 0x043C, + emdash: 0x2014, + emdashvertical: 0xFE31, + emonospace: 0xFF45, + emphasismarkarmenian: 0x055B, + emptyset: 0x2205, + enbopomofo: 0x3123, + encyrillic: 0x043D, + endash: 0x2013, + endashvertical: 0xFE32, + endescendercyrillic: 0x04A3, + eng: 0x014B, + engbopomofo: 0x3125, + enghecyrillic: 0x04A5, + enhookcyrillic: 0x04C8, + enspace: 0x2002, + eogonek: 0x0119, + eokorean: 0x3153, + eopen: 0x025B, + eopenclosed: 0x029A, + eopenreversed: 0x025C, + eopenreversedclosed: 0x025E, + eopenreversedhook: 0x025D, + eparen: 0x24A0, + epsilon: 0x03B5, + epsilontonos: 0x03AD, + equal: 0x003D, + equalmonospace: 0xFF1D, + equalsmall: 0xFE66, + equalsuperior: 0x207C, + equivalence: 0x2261, + erbopomofo: 0x3126, + ercyrillic: 0x0440, + ereversed: 0x0258, + ereversedcyrillic: 0x044D, + escyrillic: 0x0441, + esdescendercyrillic: 0x04AB, + esh: 0x0283, + eshcurl: 0x0286, + eshortdeva: 0x090E, + eshortvowelsigndeva: 0x0946, + eshreversedloop: 0x01AA, + eshsquatreversed: 0x0285, + esmallhiragana: 0x3047, + esmallkatakana: 0x30A7, + esmallkatakanahalfwidth: 0xFF6A, + estimated: 0x212E, + esuperior: 0xF6EC, + eta: 0x03B7, + etarmenian: 0x0568, + etatonos: 0x03AE, + eth: 0x00F0, + etilde: 0x1EBD, + etildebelow: 0x1E1B, + etnahtafoukhhebrew: 0x0591, + etnahtafoukhlefthebrew: 0x0591, + etnahtahebrew: 0x0591, + etnahtalefthebrew: 0x0591, + eturned: 0x01DD, + eukorean: 0x3161, + euro: 0x20AC, + evowelsignbengali: 0x09C7, + evowelsigndeva: 0x0947, + evowelsigngujarati: 0x0AC7, + exclam: 0x0021, + exclamarmenian: 0x055C, + exclamdbl: 0x203C, + exclamdown: 0x00A1, + exclamdownsmall: 0xF7A1, + exclammonospace: 0xFF01, + exclamsmall: 0xF721, + existential: 0x2203, + ezh: 0x0292, + ezhcaron: 0x01EF, + ezhcurl: 0x0293, + ezhreversed: 0x01B9, + ezhtail: 0x01BA, + f: 0x0066, + fadeva: 0x095E, + fagurmukhi: 0x0A5E, + fahrenheit: 0x2109, + fathaarabic: 0x064E, + fathalowarabic: 0x064E, + fathatanarabic: 0x064B, + fbopomofo: 0x3108, + fcircle: 0x24D5, + fdotaccent: 0x1E1F, + feharabic: 0x0641, + feharmenian: 0x0586, + fehfinalarabic: 0xFED2, + fehinitialarabic: 0xFED3, + fehmedialarabic: 0xFED4, + feicoptic: 0x03E5, + female: 0x2640, + ff: 0xFB00, + ffi: 0xFB03, + ffl: 0xFB04, + fi: 0xFB01, + fifteencircle: 0x246E, + fifteenparen: 0x2482, + fifteenperiod: 0x2496, + figuredash: 0x2012, + filledbox: 0x25A0, + filledrect: 0x25AC, + finalkaf: 0x05DA, + finalkafdagesh: 0xFB3A, + finalkafdageshhebrew: 0xFB3A, + finalkafhebrew: 0x05DA, + finalmem: 0x05DD, + finalmemhebrew: 0x05DD, + finalnun: 0x05DF, + finalnunhebrew: 0x05DF, + finalpe: 0x05E3, + finalpehebrew: 0x05E3, + finaltsadi: 0x05E5, + finaltsadihebrew: 0x05E5, + firsttonechinese: 0x02C9, + fisheye: 0x25C9, + fitacyrillic: 0x0473, + five: 0x0035, + fivearabic: 0x0665, + fivebengali: 0x09EB, + fivecircle: 0x2464, + fivecircleinversesansserif: 0x278E, + fivedeva: 0x096B, + fiveeighths: 0x215D, + fivegujarati: 0x0AEB, + fivegurmukhi: 0x0A6B, + fivehackarabic: 0x0665, + fivehangzhou: 0x3025, + fiveideographicparen: 0x3224, + fiveinferior: 0x2085, + fivemonospace: 0xFF15, + fiveoldstyle: 0xF735, + fiveparen: 0x2478, + fiveperiod: 0x248C, + fivepersian: 0x06F5, + fiveroman: 0x2174, + fivesuperior: 0x2075, + fivethai: 0x0E55, + fl: 0xFB02, + florin: 0x0192, + fmonospace: 0xFF46, + fmsquare: 0x3399, + fofanthai: 0x0E1F, + fofathai: 0x0E1D, + fongmanthai: 0x0E4F, + forall: 0x2200, + four: 0x0034, + fourarabic: 0x0664, + fourbengali: 0x09EA, + fourcircle: 0x2463, + fourcircleinversesansserif: 0x278D, + fourdeva: 0x096A, + fourgujarati: 0x0AEA, + fourgurmukhi: 0x0A6A, + fourhackarabic: 0x0664, + fourhangzhou: 0x3024, + fourideographicparen: 0x3223, + fourinferior: 0x2084, + fourmonospace: 0xFF14, + fournumeratorbengali: 0x09F7, + fouroldstyle: 0xF734, + fourparen: 0x2477, + fourperiod: 0x248B, + fourpersian: 0x06F4, + fourroman: 0x2173, + foursuperior: 0x2074, + fourteencircle: 0x246D, + fourteenparen: 0x2481, + fourteenperiod: 0x2495, + fourthai: 0x0E54, + fourthtonechinese: 0x02CB, + fparen: 0x24A1, + fraction: 0x2044, + franc: 0x20A3, + g: 0x0067, + gabengali: 0x0997, + gacute: 0x01F5, + gadeva: 0x0917, + gafarabic: 0x06AF, + gaffinalarabic: 0xFB93, + gafinitialarabic: 0xFB94, + gafmedialarabic: 0xFB95, + gagujarati: 0x0A97, + gagurmukhi: 0x0A17, + gahiragana: 0x304C, + gakatakana: 0x30AC, + gamma: 0x03B3, + gammalatinsmall: 0x0263, + gammasuperior: 0x02E0, + gangiacoptic: 0x03EB, + gbopomofo: 0x310D, + gbreve: 0x011F, + gcaron: 0x01E7, + gcedilla: 0x0123, + gcircle: 0x24D6, + gcircumflex: 0x011D, + gcommaaccent: 0x0123, + gdot: 0x0121, + gdotaccent: 0x0121, + gecyrillic: 0x0433, + gehiragana: 0x3052, + gekatakana: 0x30B2, + geometricallyequal: 0x2251, + gereshaccenthebrew: 0x059C, + gereshhebrew: 0x05F3, + gereshmuqdamhebrew: 0x059D, + germandbls: 0x00DF, + gershayimaccenthebrew: 0x059E, + gershayimhebrew: 0x05F4, + getamark: 0x3013, + ghabengali: 0x0998, + ghadarmenian: 0x0572, + ghadeva: 0x0918, + ghagujarati: 0x0A98, + ghagurmukhi: 0x0A18, + ghainarabic: 0x063A, + ghainfinalarabic: 0xFECE, + ghaininitialarabic: 0xFECF, + ghainmedialarabic: 0xFED0, + ghemiddlehookcyrillic: 0x0495, + ghestrokecyrillic: 0x0493, + gheupturncyrillic: 0x0491, + ghhadeva: 0x095A, + ghhagurmukhi: 0x0A5A, + ghook: 0x0260, + ghzsquare: 0x3393, + gihiragana: 0x304E, + gikatakana: 0x30AE, + gimarmenian: 0x0563, + gimel: 0x05D2, + gimeldagesh: 0xFB32, + gimeldageshhebrew: 0xFB32, + gimelhebrew: 0x05D2, + gjecyrillic: 0x0453, + glottalinvertedstroke: 0x01BE, + glottalstop: 0x0294, + glottalstopinverted: 0x0296, + glottalstopmod: 0x02C0, + glottalstopreversed: 0x0295, + glottalstopreversedmod: 0x02C1, + glottalstopreversedsuperior: 0x02E4, + glottalstopstroke: 0x02A1, + glottalstopstrokereversed: 0x02A2, + gmacron: 0x1E21, + gmonospace: 0xFF47, + gohiragana: 0x3054, + gokatakana: 0x30B4, + gparen: 0x24A2, + gpasquare: 0x33AC, + gradient: 0x2207, + grave: 0x0060, + gravebelowcmb: 0x0316, + gravecmb: 0x0300, + gravecomb: 0x0300, + gravedeva: 0x0953, + gravelowmod: 0x02CE, + gravemonospace: 0xFF40, + gravetonecmb: 0x0340, + greater: 0x003E, + greaterequal: 0x2265, + greaterequalorless: 0x22DB, + greatermonospace: 0xFF1E, + greaterorequivalent: 0x2273, + greaterorless: 0x2277, + greateroverequal: 0x2267, + greatersmall: 0xFE65, + gscript: 0x0261, + gstroke: 0x01E5, + guhiragana: 0x3050, + guillemotleft: 0x00AB, + guillemotright: 0x00BB, + guilsinglleft: 0x2039, + guilsinglright: 0x203A, + gukatakana: 0x30B0, + guramusquare: 0x3318, + gysquare: 0x33C9, + h: 0x0068, + haabkhasiancyrillic: 0x04A9, + haaltonearabic: 0x06C1, + habengali: 0x09B9, + hadescendercyrillic: 0x04B3, + hadeva: 0x0939, + hagujarati: 0x0AB9, + hagurmukhi: 0x0A39, + haharabic: 0x062D, + hahfinalarabic: 0xFEA2, + hahinitialarabic: 0xFEA3, + hahiragana: 0x306F, + hahmedialarabic: 0xFEA4, + haitusquare: 0x332A, + hakatakana: 0x30CF, + hakatakanahalfwidth: 0xFF8A, + halantgurmukhi: 0x0A4D, + hamzaarabic: 0x0621, + hamzalowarabic: 0x0621, + hangulfiller: 0x3164, + hardsigncyrillic: 0x044A, + harpoonleftbarbup: 0x21BC, + harpoonrightbarbup: 0x21C0, + hasquare: 0x33CA, + hatafpatah: 0x05B2, + hatafpatah16: 0x05B2, + hatafpatah23: 0x05B2, + hatafpatah2f: 0x05B2, + hatafpatahhebrew: 0x05B2, + hatafpatahnarrowhebrew: 0x05B2, + hatafpatahquarterhebrew: 0x05B2, + hatafpatahwidehebrew: 0x05B2, + hatafqamats: 0x05B3, + hatafqamats1b: 0x05B3, + hatafqamats28: 0x05B3, + hatafqamats34: 0x05B3, + hatafqamatshebrew: 0x05B3, + hatafqamatsnarrowhebrew: 0x05B3, + hatafqamatsquarterhebrew: 0x05B3, + hatafqamatswidehebrew: 0x05B3, + hatafsegol: 0x05B1, + hatafsegol17: 0x05B1, + hatafsegol24: 0x05B1, + hatafsegol30: 0x05B1, + hatafsegolhebrew: 0x05B1, + hatafsegolnarrowhebrew: 0x05B1, + hatafsegolquarterhebrew: 0x05B1, + hatafsegolwidehebrew: 0x05B1, + hbar: 0x0127, + hbopomofo: 0x310F, + hbrevebelow: 0x1E2B, + hcedilla: 0x1E29, + hcircle: 0x24D7, + hcircumflex: 0x0125, + hdieresis: 0x1E27, + hdotaccent: 0x1E23, + hdotbelow: 0x1E25, + he: 0x05D4, + heart: 0x2665, + heartsuitblack: 0x2665, + heartsuitwhite: 0x2661, + hedagesh: 0xFB34, + hedageshhebrew: 0xFB34, + hehaltonearabic: 0x06C1, + heharabic: 0x0647, + hehebrew: 0x05D4, + hehfinalaltonearabic: 0xFBA7, + hehfinalalttwoarabic: 0xFEEA, + hehfinalarabic: 0xFEEA, + hehhamzaabovefinalarabic: 0xFBA5, + hehhamzaaboveisolatedarabic: 0xFBA4, + hehinitialaltonearabic: 0xFBA8, + hehinitialarabic: 0xFEEB, + hehiragana: 0x3078, + hehmedialaltonearabic: 0xFBA9, + hehmedialarabic: 0xFEEC, + heiseierasquare: 0x337B, + hekatakana: 0x30D8, + hekatakanahalfwidth: 0xFF8D, + hekutaarusquare: 0x3336, + henghook: 0x0267, + herutusquare: 0x3339, + het: 0x05D7, + hethebrew: 0x05D7, + hhook: 0x0266, + hhooksuperior: 0x02B1, + hieuhacirclekorean: 0x327B, + hieuhaparenkorean: 0x321B, + hieuhcirclekorean: 0x326D, + hieuhkorean: 0x314E, + hieuhparenkorean: 0x320D, + hihiragana: 0x3072, + hikatakana: 0x30D2, + hikatakanahalfwidth: 0xFF8B, + hiriq: 0x05B4, + hiriq14: 0x05B4, + hiriq21: 0x05B4, + hiriq2d: 0x05B4, + hiriqhebrew: 0x05B4, + hiriqnarrowhebrew: 0x05B4, + hiriqquarterhebrew: 0x05B4, + hiriqwidehebrew: 0x05B4, + hlinebelow: 0x1E96, + hmonospace: 0xFF48, + hoarmenian: 0x0570, + hohipthai: 0x0E2B, + hohiragana: 0x307B, + hokatakana: 0x30DB, + hokatakanahalfwidth: 0xFF8E, + holam: 0x05B9, + holam19: 0x05B9, + holam26: 0x05B9, + holam32: 0x05B9, + holamhebrew: 0x05B9, + holamnarrowhebrew: 0x05B9, + holamquarterhebrew: 0x05B9, + holamwidehebrew: 0x05B9, + honokhukthai: 0x0E2E, + hookabovecomb: 0x0309, + hookcmb: 0x0309, + hookpalatalizedbelowcmb: 0x0321, + hookretroflexbelowcmb: 0x0322, + hoonsquare: 0x3342, + horicoptic: 0x03E9, + horizontalbar: 0x2015, + horncmb: 0x031B, + hotsprings: 0x2668, + house: 0x2302, + hparen: 0x24A3, + hsuperior: 0x02B0, + hturned: 0x0265, + huhiragana: 0x3075, + huiitosquare: 0x3333, + hukatakana: 0x30D5, + hukatakanahalfwidth: 0xFF8C, + hungarumlaut: 0x02DD, + hungarumlautcmb: 0x030B, + hv: 0x0195, + hyphen: 0x002D, + hypheninferior: 0xF6E5, + hyphenmonospace: 0xFF0D, + hyphensmall: 0xFE63, + hyphensuperior: 0xF6E6, + hyphentwo: 0x2010, + i: 0x0069, + iacute: 0x00ED, + iacyrillic: 0x044F, + ibengali: 0x0987, + ibopomofo: 0x3127, + ibreve: 0x012D, + icaron: 0x01D0, + icircle: 0x24D8, + icircumflex: 0x00EE, + icyrillic: 0x0456, + idblgrave: 0x0209, + ideographearthcircle: 0x328F, + ideographfirecircle: 0x328B, + ideographicallianceparen: 0x323F, + ideographiccallparen: 0x323A, + ideographiccentrecircle: 0x32A5, + ideographicclose: 0x3006, + ideographiccomma: 0x3001, + ideographiccommaleft: 0xFF64, + ideographiccongratulationparen: 0x3237, + ideographiccorrectcircle: 0x32A3, + ideographicearthparen: 0x322F, + ideographicenterpriseparen: 0x323D, + ideographicexcellentcircle: 0x329D, + ideographicfestivalparen: 0x3240, + ideographicfinancialcircle: 0x3296, + ideographicfinancialparen: 0x3236, + ideographicfireparen: 0x322B, + ideographichaveparen: 0x3232, + ideographichighcircle: 0x32A4, + ideographiciterationmark: 0x3005, + ideographiclaborcircle: 0x3298, + ideographiclaborparen: 0x3238, + ideographicleftcircle: 0x32A7, + ideographiclowcircle: 0x32A6, + ideographicmedicinecircle: 0x32A9, + ideographicmetalparen: 0x322E, + ideographicmoonparen: 0x322A, + ideographicnameparen: 0x3234, + ideographicperiod: 0x3002, + ideographicprintcircle: 0x329E, + ideographicreachparen: 0x3243, + ideographicrepresentparen: 0x3239, + ideographicresourceparen: 0x323E, + ideographicrightcircle: 0x32A8, + ideographicsecretcircle: 0x3299, + ideographicselfparen: 0x3242, + ideographicsocietyparen: 0x3233, + ideographicspace: 0x3000, + ideographicspecialparen: 0x3235, + ideographicstockparen: 0x3231, + ideographicstudyparen: 0x323B, + ideographicsunparen: 0x3230, + ideographicsuperviseparen: 0x323C, + ideographicwaterparen: 0x322C, + ideographicwoodparen: 0x322D, + ideographiczero: 0x3007, + ideographmetalcircle: 0x328E, + ideographmooncircle: 0x328A, + ideographnamecircle: 0x3294, + ideographsuncircle: 0x3290, + ideographwatercircle: 0x328C, + ideographwoodcircle: 0x328D, + ideva: 0x0907, + idieresis: 0x00EF, + idieresisacute: 0x1E2F, + idieresiscyrillic: 0x04E5, + idotbelow: 0x1ECB, + iebrevecyrillic: 0x04D7, + iecyrillic: 0x0435, + ieungacirclekorean: 0x3275, + ieungaparenkorean: 0x3215, + ieungcirclekorean: 0x3267, + ieungkorean: 0x3147, + ieungparenkorean: 0x3207, + igrave: 0x00EC, + igujarati: 0x0A87, + igurmukhi: 0x0A07, + ihiragana: 0x3044, + ihookabove: 0x1EC9, + iibengali: 0x0988, + iicyrillic: 0x0438, + iideva: 0x0908, + iigujarati: 0x0A88, + iigurmukhi: 0x0A08, + iimatragurmukhi: 0x0A40, + iinvertedbreve: 0x020B, + iishortcyrillic: 0x0439, + iivowelsignbengali: 0x09C0, + iivowelsigndeva: 0x0940, + iivowelsigngujarati: 0x0AC0, + ij: 0x0133, + ikatakana: 0x30A4, + ikatakanahalfwidth: 0xFF72, + ikorean: 0x3163, + ilde: 0x02DC, + iluyhebrew: 0x05AC, + imacron: 0x012B, + imacroncyrillic: 0x04E3, + imageorapproximatelyequal: 0x2253, + imatragurmukhi: 0x0A3F, + imonospace: 0xFF49, + increment: 0x2206, + infinity: 0x221E, + iniarmenian: 0x056B, + integral: 0x222B, + integralbottom: 0x2321, + integralbt: 0x2321, + integralex: 0xF8F5, + integraltop: 0x2320, + integraltp: 0x2320, + intersection: 0x2229, + intisquare: 0x3305, + invbullet: 0x25D8, + invcircle: 0x25D9, + invsmileface: 0x263B, + iocyrillic: 0x0451, + iogonek: 0x012F, + iota: 0x03B9, + iotadieresis: 0x03CA, + iotadieresistonos: 0x0390, + iotalatin: 0x0269, + iotatonos: 0x03AF, + iparen: 0x24A4, + irigurmukhi: 0x0A72, + ismallhiragana: 0x3043, + ismallkatakana: 0x30A3, + ismallkatakanahalfwidth: 0xFF68, + issharbengali: 0x09FA, + istroke: 0x0268, + isuperior: 0xF6ED, + iterationhiragana: 0x309D, + iterationkatakana: 0x30FD, + itilde: 0x0129, + itildebelow: 0x1E2D, + iubopomofo: 0x3129, + iucyrillic: 0x044E, + ivowelsignbengali: 0x09BF, + ivowelsigndeva: 0x093F, + ivowelsigngujarati: 0x0ABF, + izhitsacyrillic: 0x0475, + izhitsadblgravecyrillic: 0x0477, + j: 0x006A, + jaarmenian: 0x0571, + jabengali: 0x099C, + jadeva: 0x091C, + jagujarati: 0x0A9C, + jagurmukhi: 0x0A1C, + jbopomofo: 0x3110, + jcaron: 0x01F0, + jcircle: 0x24D9, + jcircumflex: 0x0135, + jcrossedtail: 0x029D, + jdotlessstroke: 0x025F, + jecyrillic: 0x0458, + jeemarabic: 0x062C, + jeemfinalarabic: 0xFE9E, + jeeminitialarabic: 0xFE9F, + jeemmedialarabic: 0xFEA0, + jeharabic: 0x0698, + jehfinalarabic: 0xFB8B, + jhabengali: 0x099D, + jhadeva: 0x091D, + jhagujarati: 0x0A9D, + jhagurmukhi: 0x0A1D, + jheharmenian: 0x057B, + jis: 0x3004, + jmonospace: 0xFF4A, + jparen: 0x24A5, + jsuperior: 0x02B2, + k: 0x006B, + kabashkircyrillic: 0x04A1, + kabengali: 0x0995, + kacute: 0x1E31, + kacyrillic: 0x043A, + kadescendercyrillic: 0x049B, + kadeva: 0x0915, + kaf: 0x05DB, + kafarabic: 0x0643, + kafdagesh: 0xFB3B, + kafdageshhebrew: 0xFB3B, + kaffinalarabic: 0xFEDA, + kafhebrew: 0x05DB, + kafinitialarabic: 0xFEDB, + kafmedialarabic: 0xFEDC, + kafrafehebrew: 0xFB4D, + kagujarati: 0x0A95, + kagurmukhi: 0x0A15, + kahiragana: 0x304B, + kahookcyrillic: 0x04C4, + kakatakana: 0x30AB, + kakatakanahalfwidth: 0xFF76, + kappa: 0x03BA, + kappasymbolgreek: 0x03F0, + kapyeounmieumkorean: 0x3171, + kapyeounphieuphkorean: 0x3184, + kapyeounpieupkorean: 0x3178, + kapyeounssangpieupkorean: 0x3179, + karoriisquare: 0x330D, + kashidaautoarabic: 0x0640, + kashidaautonosidebearingarabic: 0x0640, + kasmallkatakana: 0x30F5, + kasquare: 0x3384, + kasraarabic: 0x0650, + kasratanarabic: 0x064D, + kastrokecyrillic: 0x049F, + katahiraprolongmarkhalfwidth: 0xFF70, + kaverticalstrokecyrillic: 0x049D, + kbopomofo: 0x310E, + kcalsquare: 0x3389, + kcaron: 0x01E9, + kcedilla: 0x0137, + kcircle: 0x24DA, + kcommaaccent: 0x0137, + kdotbelow: 0x1E33, + keharmenian: 0x0584, + kehiragana: 0x3051, + kekatakana: 0x30B1, + kekatakanahalfwidth: 0xFF79, + kenarmenian: 0x056F, + kesmallkatakana: 0x30F6, + kgreenlandic: 0x0138, + khabengali: 0x0996, + khacyrillic: 0x0445, + khadeva: 0x0916, + khagujarati: 0x0A96, + khagurmukhi: 0x0A16, + khaharabic: 0x062E, + khahfinalarabic: 0xFEA6, + khahinitialarabic: 0xFEA7, + khahmedialarabic: 0xFEA8, + kheicoptic: 0x03E7, + khhadeva: 0x0959, + khhagurmukhi: 0x0A59, + khieukhacirclekorean: 0x3278, + khieukhaparenkorean: 0x3218, + khieukhcirclekorean: 0x326A, + khieukhkorean: 0x314B, + khieukhparenkorean: 0x320A, + khokhaithai: 0x0E02, + khokhonthai: 0x0E05, + khokhuatthai: 0x0E03, + khokhwaithai: 0x0E04, + khomutthai: 0x0E5B, + khook: 0x0199, + khorakhangthai: 0x0E06, + khzsquare: 0x3391, + kihiragana: 0x304D, + kikatakana: 0x30AD, + kikatakanahalfwidth: 0xFF77, + kiroguramusquare: 0x3315, + kiromeetorusquare: 0x3316, + kirosquare: 0x3314, + kiyeokacirclekorean: 0x326E, + kiyeokaparenkorean: 0x320E, + kiyeokcirclekorean: 0x3260, + kiyeokkorean: 0x3131, + kiyeokparenkorean: 0x3200, + kiyeoksioskorean: 0x3133, + kjecyrillic: 0x045C, + klinebelow: 0x1E35, + klsquare: 0x3398, + kmcubedsquare: 0x33A6, + kmonospace: 0xFF4B, + kmsquaredsquare: 0x33A2, + kohiragana: 0x3053, + kohmsquare: 0x33C0, + kokaithai: 0x0E01, + kokatakana: 0x30B3, + kokatakanahalfwidth: 0xFF7A, + kooposquare: 0x331E, + koppacyrillic: 0x0481, + koreanstandardsymbol: 0x327F, + koroniscmb: 0x0343, + kparen: 0x24A6, + kpasquare: 0x33AA, + ksicyrillic: 0x046F, + ktsquare: 0x33CF, + kturned: 0x029E, + kuhiragana: 0x304F, + kukatakana: 0x30AF, + kukatakanahalfwidth: 0xFF78, + kvsquare: 0x33B8, + kwsquare: 0x33BE, + l: 0x006C, + labengali: 0x09B2, + lacute: 0x013A, + ladeva: 0x0932, + lagujarati: 0x0AB2, + lagurmukhi: 0x0A32, + lakkhangyaothai: 0x0E45, + lamaleffinalarabic: 0xFEFC, + lamalefhamzaabovefinalarabic: 0xFEF8, + lamalefhamzaaboveisolatedarabic: 0xFEF7, + lamalefhamzabelowfinalarabic: 0xFEFA, + lamalefhamzabelowisolatedarabic: 0xFEF9, + lamalefisolatedarabic: 0xFEFB, + lamalefmaddaabovefinalarabic: 0xFEF6, + lamalefmaddaaboveisolatedarabic: 0xFEF5, + lamarabic: 0x0644, + lambda: 0x03BB, + lambdastroke: 0x019B, + lamed: 0x05DC, + lameddagesh: 0xFB3C, + lameddageshhebrew: 0xFB3C, + lamedhebrew: 0x05DC, + lamfinalarabic: 0xFEDE, + lamhahinitialarabic: 0xFCCA, + laminitialarabic: 0xFEDF, + lamjeeminitialarabic: 0xFCC9, + lamkhahinitialarabic: 0xFCCB, + lamlamhehisolatedarabic: 0xFDF2, + lammedialarabic: 0xFEE0, + lammeemhahinitialarabic: 0xFD88, + lammeeminitialarabic: 0xFCCC, + largecircle: 0x25EF, + lbar: 0x019A, + lbelt: 0x026C, + lbopomofo: 0x310C, + lcaron: 0x013E, + lcedilla: 0x013C, + lcircle: 0x24DB, + lcircumflexbelow: 0x1E3D, + lcommaaccent: 0x013C, + ldot: 0x0140, + ldotaccent: 0x0140, + ldotbelow: 0x1E37, + ldotbelowmacron: 0x1E39, + leftangleabovecmb: 0x031A, + lefttackbelowcmb: 0x0318, + less: 0x003C, + lessequal: 0x2264, + lessequalorgreater: 0x22DA, + lessmonospace: 0xFF1C, + lessorequivalent: 0x2272, + lessorgreater: 0x2276, + lessoverequal: 0x2266, + lesssmall: 0xFE64, + lezh: 0x026E, + lfblock: 0x258C, + lhookretroflex: 0x026D, + lira: 0x20A4, + liwnarmenian: 0x056C, + lj: 0x01C9, + ljecyrillic: 0x0459, + ll: 0xF6C0, + lladeva: 0x0933, + llagujarati: 0x0AB3, + llinebelow: 0x1E3B, + llladeva: 0x0934, + llvocalicbengali: 0x09E1, + llvocalicdeva: 0x0961, + llvocalicvowelsignbengali: 0x09E3, + llvocalicvowelsigndeva: 0x0963, + lmiddletilde: 0x026B, + lmonospace: 0xFF4C, + lmsquare: 0x33D0, + lochulathai: 0x0E2C, + logicaland: 0x2227, + logicalnot: 0x00AC, + logicalnotreversed: 0x2310, + logicalor: 0x2228, + lolingthai: 0x0E25, + longs: 0x017F, + lowlinecenterline: 0xFE4E, + lowlinecmb: 0x0332, + lowlinedashed: 0xFE4D, + lozenge: 0x25CA, + lparen: 0x24A7, + lslash: 0x0142, + lsquare: 0x2113, + lsuperior: 0xF6EE, + ltshade: 0x2591, + luthai: 0x0E26, + lvocalicbengali: 0x098C, + lvocalicdeva: 0x090C, + lvocalicvowelsignbengali: 0x09E2, + lvocalicvowelsigndeva: 0x0962, + lxsquare: 0x33D3, + m: 0x006D, + mabengali: 0x09AE, + macron: 0x00AF, + macronbelowcmb: 0x0331, + macroncmb: 0x0304, + macronlowmod: 0x02CD, + macronmonospace: 0xFFE3, + macute: 0x1E3F, + madeva: 0x092E, + magujarati: 0x0AAE, + magurmukhi: 0x0A2E, + mahapakhhebrew: 0x05A4, + mahapakhlefthebrew: 0x05A4, + mahiragana: 0x307E, + maichattawalowleftthai: 0xF895, + maichattawalowrightthai: 0xF894, + maichattawathai: 0x0E4B, + maichattawaupperleftthai: 0xF893, + maieklowleftthai: 0xF88C, + maieklowrightthai: 0xF88B, + maiekthai: 0x0E48, + maiekupperleftthai: 0xF88A, + maihanakatleftthai: 0xF884, + maihanakatthai: 0x0E31, + maitaikhuleftthai: 0xF889, + maitaikhuthai: 0x0E47, + maitholowleftthai: 0xF88F, + maitholowrightthai: 0xF88E, + maithothai: 0x0E49, + maithoupperleftthai: 0xF88D, + maitrilowleftthai: 0xF892, + maitrilowrightthai: 0xF891, + maitrithai: 0x0E4A, + maitriupperleftthai: 0xF890, + maiyamokthai: 0x0E46, + makatakana: 0x30DE, + makatakanahalfwidth: 0xFF8F, + male: 0x2642, + mansyonsquare: 0x3347, + maqafhebrew: 0x05BE, + mars: 0x2642, + masoracirclehebrew: 0x05AF, + masquare: 0x3383, + mbopomofo: 0x3107, + mbsquare: 0x33D4, + mcircle: 0x24DC, + mcubedsquare: 0x33A5, + mdotaccent: 0x1E41, + mdotbelow: 0x1E43, + meemarabic: 0x0645, + meemfinalarabic: 0xFEE2, + meeminitialarabic: 0xFEE3, + meemmedialarabic: 0xFEE4, + meemmeeminitialarabic: 0xFCD1, + meemmeemisolatedarabic: 0xFC48, + meetorusquare: 0x334D, + mehiragana: 0x3081, + meizierasquare: 0x337E, + mekatakana: 0x30E1, + mekatakanahalfwidth: 0xFF92, + mem: 0x05DE, + memdagesh: 0xFB3E, + memdageshhebrew: 0xFB3E, + memhebrew: 0x05DE, + menarmenian: 0x0574, + merkhahebrew: 0x05A5, + merkhakefulahebrew: 0x05A6, + merkhakefulalefthebrew: 0x05A6, + merkhalefthebrew: 0x05A5, + mhook: 0x0271, + mhzsquare: 0x3392, + middledotkatakanahalfwidth: 0xFF65, + middot: 0x00B7, + mieumacirclekorean: 0x3272, + mieumaparenkorean: 0x3212, + mieumcirclekorean: 0x3264, + mieumkorean: 0x3141, + mieumpansioskorean: 0x3170, + mieumparenkorean: 0x3204, + mieumpieupkorean: 0x316E, + mieumsioskorean: 0x316F, + mihiragana: 0x307F, + mikatakana: 0x30DF, + mikatakanahalfwidth: 0xFF90, + minus: 0x2212, + minusbelowcmb: 0x0320, + minuscircle: 0x2296, + minusmod: 0x02D7, + minusplus: 0x2213, + minute: 0x2032, + miribaarusquare: 0x334A, + mirisquare: 0x3349, + mlonglegturned: 0x0270, + mlsquare: 0x3396, + mmcubedsquare: 0x33A3, + mmonospace: 0xFF4D, + mmsquaredsquare: 0x339F, + mohiragana: 0x3082, + mohmsquare: 0x33C1, + mokatakana: 0x30E2, + mokatakanahalfwidth: 0xFF93, + molsquare: 0x33D6, + momathai: 0x0E21, + moverssquare: 0x33A7, + moverssquaredsquare: 0x33A8, + mparen: 0x24A8, + mpasquare: 0x33AB, + mssquare: 0x33B3, + msuperior: 0xF6EF, + mturned: 0x026F, + mu: 0x00B5, + mu1: 0x00B5, + muasquare: 0x3382, + muchgreater: 0x226B, + muchless: 0x226A, + mufsquare: 0x338C, + mugreek: 0x03BC, + mugsquare: 0x338D, + muhiragana: 0x3080, + mukatakana: 0x30E0, + mukatakanahalfwidth: 0xFF91, + mulsquare: 0x3395, + multiply: 0x00D7, + mumsquare: 0x339B, + munahhebrew: 0x05A3, + munahlefthebrew: 0x05A3, + musicalnote: 0x266A, + musicalnotedbl: 0x266B, + musicflatsign: 0x266D, + musicsharpsign: 0x266F, + mussquare: 0x33B2, + muvsquare: 0x33B6, + muwsquare: 0x33BC, + mvmegasquare: 0x33B9, + mvsquare: 0x33B7, + mwmegasquare: 0x33BF, + mwsquare: 0x33BD, + n: 0x006E, + nabengali: 0x09A8, + nabla: 0x2207, + nacute: 0x0144, + nadeva: 0x0928, + nagujarati: 0x0AA8, + nagurmukhi: 0x0A28, + nahiragana: 0x306A, + nakatakana: 0x30CA, + nakatakanahalfwidth: 0xFF85, + napostrophe: 0x0149, + nasquare: 0x3381, + nbopomofo: 0x310B, + nbspace: 0x00A0, + ncaron: 0x0148, + ncedilla: 0x0146, + ncircle: 0x24DD, + ncircumflexbelow: 0x1E4B, + ncommaaccent: 0x0146, + ndotaccent: 0x1E45, + ndotbelow: 0x1E47, + nehiragana: 0x306D, + nekatakana: 0x30CD, + nekatakanahalfwidth: 0xFF88, + newsheqelsign: 0x20AA, + nfsquare: 0x338B, + ngabengali: 0x0999, + ngadeva: 0x0919, + ngagujarati: 0x0A99, + ngagurmukhi: 0x0A19, + ngonguthai: 0x0E07, + nhiragana: 0x3093, + nhookleft: 0x0272, + nhookretroflex: 0x0273, + nieunacirclekorean: 0x326F, + nieunaparenkorean: 0x320F, + nieuncieuckorean: 0x3135, + nieuncirclekorean: 0x3261, + nieunhieuhkorean: 0x3136, + nieunkorean: 0x3134, + nieunpansioskorean: 0x3168, + nieunparenkorean: 0x3201, + nieunsioskorean: 0x3167, + nieuntikeutkorean: 0x3166, + nihiragana: 0x306B, + nikatakana: 0x30CB, + nikatakanahalfwidth: 0xFF86, + nikhahitleftthai: 0xF899, + nikhahitthai: 0x0E4D, + nine: 0x0039, + ninearabic: 0x0669, + ninebengali: 0x09EF, + ninecircle: 0x2468, + ninecircleinversesansserif: 0x2792, + ninedeva: 0x096F, + ninegujarati: 0x0AEF, + ninegurmukhi: 0x0A6F, + ninehackarabic: 0x0669, + ninehangzhou: 0x3029, + nineideographicparen: 0x3228, + nineinferior: 0x2089, + ninemonospace: 0xFF19, + nineoldstyle: 0xF739, + nineparen: 0x247C, + nineperiod: 0x2490, + ninepersian: 0x06F9, + nineroman: 0x2178, + ninesuperior: 0x2079, + nineteencircle: 0x2472, + nineteenparen: 0x2486, + nineteenperiod: 0x249A, + ninethai: 0x0E59, + nj: 0x01CC, + njecyrillic: 0x045A, + nkatakana: 0x30F3, + nkatakanahalfwidth: 0xFF9D, + nlegrightlong: 0x019E, + nlinebelow: 0x1E49, + nmonospace: 0xFF4E, + nmsquare: 0x339A, + nnabengali: 0x09A3, + nnadeva: 0x0923, + nnagujarati: 0x0AA3, + nnagurmukhi: 0x0A23, + nnnadeva: 0x0929, + nohiragana: 0x306E, + nokatakana: 0x30CE, + nokatakanahalfwidth: 0xFF89, + nonbreakingspace: 0x00A0, + nonenthai: 0x0E13, + nonuthai: 0x0E19, + noonarabic: 0x0646, + noonfinalarabic: 0xFEE6, + noonghunnaarabic: 0x06BA, + noonghunnafinalarabic: 0xFB9F, + nooninitialarabic: 0xFEE7, + noonjeeminitialarabic: 0xFCD2, + noonjeemisolatedarabic: 0xFC4B, + noonmedialarabic: 0xFEE8, + noonmeeminitialarabic: 0xFCD5, + noonmeemisolatedarabic: 0xFC4E, + noonnoonfinalarabic: 0xFC8D, + notcontains: 0x220C, + notelement: 0x2209, + notelementof: 0x2209, + notequal: 0x2260, + notgreater: 0x226F, + notgreaternorequal: 0x2271, + notgreaternorless: 0x2279, + notidentical: 0x2262, + notless: 0x226E, + notlessnorequal: 0x2270, + notparallel: 0x2226, + notprecedes: 0x2280, + notsubset: 0x2284, + notsucceeds: 0x2281, + notsuperset: 0x2285, + nowarmenian: 0x0576, + nparen: 0x24A9, + nssquare: 0x33B1, + nsuperior: 0x207F, + ntilde: 0x00F1, + nu: 0x03BD, + nuhiragana: 0x306C, + nukatakana: 0x30CC, + nukatakanahalfwidth: 0xFF87, + nuktabengali: 0x09BC, + nuktadeva: 0x093C, + nuktagujarati: 0x0ABC, + nuktagurmukhi: 0x0A3C, + numbersign: 0x0023, + numbersignmonospace: 0xFF03, + numbersignsmall: 0xFE5F, + numeralsigngreek: 0x0374, + numeralsignlowergreek: 0x0375, + numero: 0x2116, + nun: 0x05E0, + nundagesh: 0xFB40, + nundageshhebrew: 0xFB40, + nunhebrew: 0x05E0, + nvsquare: 0x33B5, + nwsquare: 0x33BB, + nyabengali: 0x099E, + nyadeva: 0x091E, + nyagujarati: 0x0A9E, + nyagurmukhi: 0x0A1E, + o: 0x006F, + oacute: 0x00F3, + oangthai: 0x0E2D, + obarred: 0x0275, + obarredcyrillic: 0x04E9, + obarreddieresiscyrillic: 0x04EB, + obengali: 0x0993, + obopomofo: 0x311B, + obreve: 0x014F, + ocandradeva: 0x0911, + ocandragujarati: 0x0A91, + ocandravowelsigndeva: 0x0949, + ocandravowelsigngujarati: 0x0AC9, + ocaron: 0x01D2, + ocircle: 0x24DE, + ocircumflex: 0x00F4, + ocircumflexacute: 0x1ED1, + ocircumflexdotbelow: 0x1ED9, + ocircumflexgrave: 0x1ED3, + ocircumflexhookabove: 0x1ED5, + ocircumflextilde: 0x1ED7, + ocyrillic: 0x043E, + odblacute: 0x0151, + odblgrave: 0x020D, + odeva: 0x0913, + odieresis: 0x00F6, + odieresiscyrillic: 0x04E7, + odotbelow: 0x1ECD, + oe: 0x0153, + oekorean: 0x315A, + ogonek: 0x02DB, + ogonekcmb: 0x0328, + ograve: 0x00F2, + ogujarati: 0x0A93, + oharmenian: 0x0585, + ohiragana: 0x304A, + ohookabove: 0x1ECF, + ohorn: 0x01A1, + ohornacute: 0x1EDB, + ohorndotbelow: 0x1EE3, + ohorngrave: 0x1EDD, + ohornhookabove: 0x1EDF, + ohorntilde: 0x1EE1, + ohungarumlaut: 0x0151, + oi: 0x01A3, + oinvertedbreve: 0x020F, + okatakana: 0x30AA, + okatakanahalfwidth: 0xFF75, + okorean: 0x3157, + olehebrew: 0x05AB, + omacron: 0x014D, + omacronacute: 0x1E53, + omacrongrave: 0x1E51, + omdeva: 0x0950, + omega: 0x03C9, + omega1: 0x03D6, + omegacyrillic: 0x0461, + omegalatinclosed: 0x0277, + omegaroundcyrillic: 0x047B, + omegatitlocyrillic: 0x047D, + omegatonos: 0x03CE, + omgujarati: 0x0AD0, + omicron: 0x03BF, + omicrontonos: 0x03CC, + omonospace: 0xFF4F, + one: 0x0031, + onearabic: 0x0661, + onebengali: 0x09E7, + onecircle: 0x2460, + onecircleinversesansserif: 0x278A, + onedeva: 0x0967, + onedotenleader: 0x2024, + oneeighth: 0x215B, + onefitted: 0xF6DC, + onegujarati: 0x0AE7, + onegurmukhi: 0x0A67, + onehackarabic: 0x0661, + onehalf: 0x00BD, + onehangzhou: 0x3021, + oneideographicparen: 0x3220, + oneinferior: 0x2081, + onemonospace: 0xFF11, + onenumeratorbengali: 0x09F4, + oneoldstyle: 0xF731, + oneparen: 0x2474, + oneperiod: 0x2488, + onepersian: 0x06F1, + onequarter: 0x00BC, + oneroman: 0x2170, + onesuperior: 0x00B9, + onethai: 0x0E51, + onethird: 0x2153, + oogonek: 0x01EB, + oogonekmacron: 0x01ED, + oogurmukhi: 0x0A13, + oomatragurmukhi: 0x0A4B, + oopen: 0x0254, + oparen: 0x24AA, + openbullet: 0x25E6, + option: 0x2325, + ordfeminine: 0x00AA, + ordmasculine: 0x00BA, + orthogonal: 0x221F, + oshortdeva: 0x0912, + oshortvowelsigndeva: 0x094A, + oslash: 0x00F8, + oslashacute: 0x01FF, + osmallhiragana: 0x3049, + osmallkatakana: 0x30A9, + osmallkatakanahalfwidth: 0xFF6B, + ostrokeacute: 0x01FF, + osuperior: 0xF6F0, + otcyrillic: 0x047F, + otilde: 0x00F5, + otildeacute: 0x1E4D, + otildedieresis: 0x1E4F, + oubopomofo: 0x3121, + overline: 0x203E, + overlinecenterline: 0xFE4A, + overlinecmb: 0x0305, + overlinedashed: 0xFE49, + overlinedblwavy: 0xFE4C, + overlinewavy: 0xFE4B, + overscore: 0x00AF, + ovowelsignbengali: 0x09CB, + ovowelsigndeva: 0x094B, + ovowelsigngujarati: 0x0ACB, + p: 0x0070, + paampssquare: 0x3380, + paasentosquare: 0x332B, + pabengali: 0x09AA, + pacute: 0x1E55, + padeva: 0x092A, + pagedown: 0x21DF, + pageup: 0x21DE, + pagujarati: 0x0AAA, + pagurmukhi: 0x0A2A, + pahiragana: 0x3071, + paiyannoithai: 0x0E2F, + pakatakana: 0x30D1, + palatalizationcyrilliccmb: 0x0484, + palochkacyrillic: 0x04C0, + pansioskorean: 0x317F, + paragraph: 0x00B6, + parallel: 0x2225, + parenleft: 0x0028, + parenleftaltonearabic: 0xFD3E, + parenleftbt: 0xF8ED, + parenleftex: 0xF8EC, + parenleftinferior: 0x208D, + parenleftmonospace: 0xFF08, + parenleftsmall: 0xFE59, + parenleftsuperior: 0x207D, + parenlefttp: 0xF8EB, + parenleftvertical: 0xFE35, + parenright: 0x0029, + parenrightaltonearabic: 0xFD3F, + parenrightbt: 0xF8F8, + parenrightex: 0xF8F7, + parenrightinferior: 0x208E, + parenrightmonospace: 0xFF09, + parenrightsmall: 0xFE5A, + parenrightsuperior: 0x207E, + parenrighttp: 0xF8F6, + parenrightvertical: 0xFE36, + partialdiff: 0x2202, + paseqhebrew: 0x05C0, + pashtahebrew: 0x0599, + pasquare: 0x33A9, + patah: 0x05B7, + patah11: 0x05B7, + patah1d: 0x05B7, + patah2a: 0x05B7, + patahhebrew: 0x05B7, + patahnarrowhebrew: 0x05B7, + patahquarterhebrew: 0x05B7, + patahwidehebrew: 0x05B7, + pazerhebrew: 0x05A1, + pbopomofo: 0x3106, + pcircle: 0x24DF, + pdotaccent: 0x1E57, + pe: 0x05E4, + pecyrillic: 0x043F, + pedagesh: 0xFB44, + pedageshhebrew: 0xFB44, + peezisquare: 0x333B, + pefinaldageshhebrew: 0xFB43, + peharabic: 0x067E, + peharmenian: 0x057A, + pehebrew: 0x05E4, + pehfinalarabic: 0xFB57, + pehinitialarabic: 0xFB58, + pehiragana: 0x307A, + pehmedialarabic: 0xFB59, + pekatakana: 0x30DA, + pemiddlehookcyrillic: 0x04A7, + perafehebrew: 0xFB4E, + percent: 0x0025, + percentarabic: 0x066A, + percentmonospace: 0xFF05, + percentsmall: 0xFE6A, + period: 0x002E, + periodarmenian: 0x0589, + periodcentered: 0x00B7, + periodhalfwidth: 0xFF61, + periodinferior: 0xF6E7, + periodmonospace: 0xFF0E, + periodsmall: 0xFE52, + periodsuperior: 0xF6E8, + perispomenigreekcmb: 0x0342, + perpendicular: 0x22A5, + perthousand: 0x2030, + peseta: 0x20A7, + pfsquare: 0x338A, + phabengali: 0x09AB, + phadeva: 0x092B, + phagujarati: 0x0AAB, + phagurmukhi: 0x0A2B, + phi: 0x03C6, + phi1: 0x03D5, + phieuphacirclekorean: 0x327A, + phieuphaparenkorean: 0x321A, + phieuphcirclekorean: 0x326C, + phieuphkorean: 0x314D, + phieuphparenkorean: 0x320C, + philatin: 0x0278, + phinthuthai: 0x0E3A, + phisymbolgreek: 0x03D5, + phook: 0x01A5, + phophanthai: 0x0E1E, + phophungthai: 0x0E1C, + phosamphaothai: 0x0E20, + pi: 0x03C0, + pieupacirclekorean: 0x3273, + pieupaparenkorean: 0x3213, + pieupcieuckorean: 0x3176, + pieupcirclekorean: 0x3265, + pieupkiyeokkorean: 0x3172, + pieupkorean: 0x3142, + pieupparenkorean: 0x3205, + pieupsioskiyeokkorean: 0x3174, + pieupsioskorean: 0x3144, + pieupsiostikeutkorean: 0x3175, + pieupthieuthkorean: 0x3177, + pieuptikeutkorean: 0x3173, + pihiragana: 0x3074, + pikatakana: 0x30D4, + pisymbolgreek: 0x03D6, + piwrarmenian: 0x0583, + plus: 0x002B, + plusbelowcmb: 0x031F, + pluscircle: 0x2295, + plusminus: 0x00B1, + plusmod: 0x02D6, + plusmonospace: 0xFF0B, + plussmall: 0xFE62, + plussuperior: 0x207A, + pmonospace: 0xFF50, + pmsquare: 0x33D8, + pohiragana: 0x307D, + pointingindexdownwhite: 0x261F, + pointingindexleftwhite: 0x261C, + pointingindexrightwhite: 0x261E, + pointingindexupwhite: 0x261D, + pokatakana: 0x30DD, + poplathai: 0x0E1B, + postalmark: 0x3012, + postalmarkface: 0x3020, + pparen: 0x24AB, + precedes: 0x227A, + prescription: 0x211E, + primemod: 0x02B9, + primereversed: 0x2035, + product: 0x220F, + projective: 0x2305, + prolongedkana: 0x30FC, + propellor: 0x2318, + propersubset: 0x2282, + propersuperset: 0x2283, + proportion: 0x2237, + proportional: 0x221D, + psi: 0x03C8, + psicyrillic: 0x0471, + psilipneumatacyrilliccmb: 0x0486, + pssquare: 0x33B0, + puhiragana: 0x3077, + pukatakana: 0x30D7, + pvsquare: 0x33B4, + pwsquare: 0x33BA, + q: 0x0071, + qadeva: 0x0958, + qadmahebrew: 0x05A8, + qafarabic: 0x0642, + qaffinalarabic: 0xFED6, + qafinitialarabic: 0xFED7, + qafmedialarabic: 0xFED8, + qamats: 0x05B8, + qamats10: 0x05B8, + qamats1a: 0x05B8, + qamats1c: 0x05B8, + qamats27: 0x05B8, + qamats29: 0x05B8, + qamats33: 0x05B8, + qamatsde: 0x05B8, + qamatshebrew: 0x05B8, + qamatsnarrowhebrew: 0x05B8, + qamatsqatanhebrew: 0x05B8, + qamatsqatannarrowhebrew: 0x05B8, + qamatsqatanquarterhebrew: 0x05B8, + qamatsqatanwidehebrew: 0x05B8, + qamatsquarterhebrew: 0x05B8, + qamatswidehebrew: 0x05B8, + qarneyparahebrew: 0x059F, + qbopomofo: 0x3111, + qcircle: 0x24E0, + qhook: 0x02A0, + qmonospace: 0xFF51, + qof: 0x05E7, + qofdagesh: 0xFB47, + qofdageshhebrew: 0xFB47, + qofhebrew: 0x05E7, + qparen: 0x24AC, + quarternote: 0x2669, + qubuts: 0x05BB, + qubuts18: 0x05BB, + qubuts25: 0x05BB, + qubuts31: 0x05BB, + qubutshebrew: 0x05BB, + qubutsnarrowhebrew: 0x05BB, + qubutsquarterhebrew: 0x05BB, + qubutswidehebrew: 0x05BB, + question: 0x003F, + questionarabic: 0x061F, + questionarmenian: 0x055E, + questiondown: 0x00BF, + questiondownsmall: 0xF7BF, + questiongreek: 0x037E, + questionmonospace: 0xFF1F, + questionsmall: 0xF73F, + quotedbl: 0x0022, + quotedblbase: 0x201E, + quotedblleft: 0x201C, + quotedblmonospace: 0xFF02, + quotedblprime: 0x301E, + quotedblprimereversed: 0x301D, + quotedblright: 0x201D, + quoteleft: 0x2018, + quoteleftreversed: 0x201B, + quotereversed: 0x201B, + quoteright: 0x2019, + quoterightn: 0x0149, + quotesinglbase: 0x201A, + quotesingle: 0x0027, + quotesinglemonospace: 0xFF07, + r: 0x0072, + raarmenian: 0x057C, + rabengali: 0x09B0, + racute: 0x0155, + radeva: 0x0930, + radical: 0x221A, + radicalex: 0xF8E5, + radoverssquare: 0x33AE, + radoverssquaredsquare: 0x33AF, + radsquare: 0x33AD, + rafe: 0x05BF, + rafehebrew: 0x05BF, + ragujarati: 0x0AB0, + ragurmukhi: 0x0A30, + rahiragana: 0x3089, + rakatakana: 0x30E9, + rakatakanahalfwidth: 0xFF97, + ralowerdiagonalbengali: 0x09F1, + ramiddlediagonalbengali: 0x09F0, + ramshorn: 0x0264, + ratio: 0x2236, + rbopomofo: 0x3116, + rcaron: 0x0159, + rcedilla: 0x0157, + rcircle: 0x24E1, + rcommaaccent: 0x0157, + rdblgrave: 0x0211, + rdotaccent: 0x1E59, + rdotbelow: 0x1E5B, + rdotbelowmacron: 0x1E5D, + referencemark: 0x203B, + reflexsubset: 0x2286, + reflexsuperset: 0x2287, + registered: 0x00AE, + registersans: 0xF8E8, + registerserif: 0xF6DA, + reharabic: 0x0631, + reharmenian: 0x0580, + rehfinalarabic: 0xFEAE, + rehiragana: 0x308C, + rekatakana: 0x30EC, + rekatakanahalfwidth: 0xFF9A, + resh: 0x05E8, + reshdageshhebrew: 0xFB48, + reshhebrew: 0x05E8, + reversedtilde: 0x223D, + reviahebrew: 0x0597, + reviamugrashhebrew: 0x0597, + revlogicalnot: 0x2310, + rfishhook: 0x027E, + rfishhookreversed: 0x027F, + rhabengali: 0x09DD, + rhadeva: 0x095D, + rho: 0x03C1, + rhook: 0x027D, + rhookturned: 0x027B, + rhookturnedsuperior: 0x02B5, + rhosymbolgreek: 0x03F1, + rhotichookmod: 0x02DE, + rieulacirclekorean: 0x3271, + rieulaparenkorean: 0x3211, + rieulcirclekorean: 0x3263, + rieulhieuhkorean: 0x3140, + rieulkiyeokkorean: 0x313A, + rieulkiyeoksioskorean: 0x3169, + rieulkorean: 0x3139, + rieulmieumkorean: 0x313B, + rieulpansioskorean: 0x316C, + rieulparenkorean: 0x3203, + rieulphieuphkorean: 0x313F, + rieulpieupkorean: 0x313C, + rieulpieupsioskorean: 0x316B, + rieulsioskorean: 0x313D, + rieulthieuthkorean: 0x313E, + rieultikeutkorean: 0x316A, + rieulyeorinhieuhkorean: 0x316D, + rightangle: 0x221F, + righttackbelowcmb: 0x0319, + righttriangle: 0x22BF, + rihiragana: 0x308A, + rikatakana: 0x30EA, + rikatakanahalfwidth: 0xFF98, + ring: 0x02DA, + ringbelowcmb: 0x0325, + ringcmb: 0x030A, + ringhalfleft: 0x02BF, + ringhalfleftarmenian: 0x0559, + ringhalfleftbelowcmb: 0x031C, + ringhalfleftcentered: 0x02D3, + ringhalfright: 0x02BE, + ringhalfrightbelowcmb: 0x0339, + ringhalfrightcentered: 0x02D2, + rinvertedbreve: 0x0213, + rittorusquare: 0x3351, + rlinebelow: 0x1E5F, + rlongleg: 0x027C, + rlonglegturned: 0x027A, + rmonospace: 0xFF52, + rohiragana: 0x308D, + rokatakana: 0x30ED, + rokatakanahalfwidth: 0xFF9B, + roruathai: 0x0E23, + rparen: 0x24AD, + rrabengali: 0x09DC, + rradeva: 0x0931, + rragurmukhi: 0x0A5C, + rreharabic: 0x0691, + rrehfinalarabic: 0xFB8D, + rrvocalicbengali: 0x09E0, + rrvocalicdeva: 0x0960, + rrvocalicgujarati: 0x0AE0, + rrvocalicvowelsignbengali: 0x09C4, + rrvocalicvowelsigndeva: 0x0944, + rrvocalicvowelsigngujarati: 0x0AC4, + rsuperior: 0xF6F1, + rtblock: 0x2590, + rturned: 0x0279, + rturnedsuperior: 0x02B4, + ruhiragana: 0x308B, + rukatakana: 0x30EB, + rukatakanahalfwidth: 0xFF99, + rupeemarkbengali: 0x09F2, + rupeesignbengali: 0x09F3, + rupiah: 0xF6DD, + ruthai: 0x0E24, + rvocalicbengali: 0x098B, + rvocalicdeva: 0x090B, + rvocalicgujarati: 0x0A8B, + rvocalicvowelsignbengali: 0x09C3, + rvocalicvowelsigndeva: 0x0943, + rvocalicvowelsigngujarati: 0x0AC3, + s: 0x0073, + sabengali: 0x09B8, + sacute: 0x015B, + sacutedotaccent: 0x1E65, + sadarabic: 0x0635, + sadeva: 0x0938, + sadfinalarabic: 0xFEBA, + sadinitialarabic: 0xFEBB, + sadmedialarabic: 0xFEBC, + sagujarati: 0x0AB8, + sagurmukhi: 0x0A38, + sahiragana: 0x3055, + sakatakana: 0x30B5, + sakatakanahalfwidth: 0xFF7B, + sallallahoualayhewasallamarabic: 0xFDFA, + samekh: 0x05E1, + samekhdagesh: 0xFB41, + samekhdageshhebrew: 0xFB41, + samekhhebrew: 0x05E1, + saraaathai: 0x0E32, + saraaethai: 0x0E41, + saraaimaimalaithai: 0x0E44, + saraaimaimuanthai: 0x0E43, + saraamthai: 0x0E33, + saraathai: 0x0E30, + saraethai: 0x0E40, + saraiileftthai: 0xF886, + saraiithai: 0x0E35, + saraileftthai: 0xF885, + saraithai: 0x0E34, + saraothai: 0x0E42, + saraueeleftthai: 0xF888, + saraueethai: 0x0E37, + saraueleftthai: 0xF887, + sarauethai: 0x0E36, + sarauthai: 0x0E38, + sarauuthai: 0x0E39, + sbopomofo: 0x3119, + scaron: 0x0161, + scarondotaccent: 0x1E67, + scedilla: 0x015F, + schwa: 0x0259, + schwacyrillic: 0x04D9, + schwadieresiscyrillic: 0x04DB, + schwahook: 0x025A, + scircle: 0x24E2, + scircumflex: 0x015D, + scommaaccent: 0x0219, + sdotaccent: 0x1E61, + sdotbelow: 0x1E63, + sdotbelowdotaccent: 0x1E69, + seagullbelowcmb: 0x033C, + second: 0x2033, + secondtonechinese: 0x02CA, + section: 0x00A7, + seenarabic: 0x0633, + seenfinalarabic: 0xFEB2, + seeninitialarabic: 0xFEB3, + seenmedialarabic: 0xFEB4, + segol: 0x05B6, + segol13: 0x05B6, + segol1f: 0x05B6, + segol2c: 0x05B6, + segolhebrew: 0x05B6, + segolnarrowhebrew: 0x05B6, + segolquarterhebrew: 0x05B6, + segoltahebrew: 0x0592, + segolwidehebrew: 0x05B6, + seharmenian: 0x057D, + sehiragana: 0x305B, + sekatakana: 0x30BB, + sekatakanahalfwidth: 0xFF7E, + semicolon: 0x003B, + semicolonarabic: 0x061B, + semicolonmonospace: 0xFF1B, + semicolonsmall: 0xFE54, + semivoicedmarkkana: 0x309C, + semivoicedmarkkanahalfwidth: 0xFF9F, + sentisquare: 0x3322, + sentosquare: 0x3323, + seven: 0x0037, + sevenarabic: 0x0667, + sevenbengali: 0x09ED, + sevencircle: 0x2466, + sevencircleinversesansserif: 0x2790, + sevendeva: 0x096D, + seveneighths: 0x215E, + sevengujarati: 0x0AED, + sevengurmukhi: 0x0A6D, + sevenhackarabic: 0x0667, + sevenhangzhou: 0x3027, + sevenideographicparen: 0x3226, + seveninferior: 0x2087, + sevenmonospace: 0xFF17, + sevenoldstyle: 0xF737, + sevenparen: 0x247A, + sevenperiod: 0x248E, + sevenpersian: 0x06F7, + sevenroman: 0x2176, + sevensuperior: 0x2077, + seventeencircle: 0x2470, + seventeenparen: 0x2484, + seventeenperiod: 0x2498, + seventhai: 0x0E57, + sfthyphen: 0x00AD, + shaarmenian: 0x0577, + shabengali: 0x09B6, + shacyrillic: 0x0448, + shaddaarabic: 0x0651, + shaddadammaarabic: 0xFC61, + shaddadammatanarabic: 0xFC5E, + shaddafathaarabic: 0xFC60, + shaddakasraarabic: 0xFC62, + shaddakasratanarabic: 0xFC5F, + shade: 0x2592, + shadedark: 0x2593, + shadelight: 0x2591, + shademedium: 0x2592, + shadeva: 0x0936, + shagujarati: 0x0AB6, + shagurmukhi: 0x0A36, + shalshelethebrew: 0x0593, + shbopomofo: 0x3115, + shchacyrillic: 0x0449, + sheenarabic: 0x0634, + sheenfinalarabic: 0xFEB6, + sheeninitialarabic: 0xFEB7, + sheenmedialarabic: 0xFEB8, + sheicoptic: 0x03E3, + sheqel: 0x20AA, + sheqelhebrew: 0x20AA, + sheva: 0x05B0, + sheva115: 0x05B0, + sheva15: 0x05B0, + sheva22: 0x05B0, + sheva2e: 0x05B0, + shevahebrew: 0x05B0, + shevanarrowhebrew: 0x05B0, + shevaquarterhebrew: 0x05B0, + shevawidehebrew: 0x05B0, + shhacyrillic: 0x04BB, + shimacoptic: 0x03ED, + shin: 0x05E9, + shindagesh: 0xFB49, + shindageshhebrew: 0xFB49, + shindageshshindot: 0xFB2C, + shindageshshindothebrew: 0xFB2C, + shindageshsindot: 0xFB2D, + shindageshsindothebrew: 0xFB2D, + shindothebrew: 0x05C1, + shinhebrew: 0x05E9, + shinshindot: 0xFB2A, + shinshindothebrew: 0xFB2A, + shinsindot: 0xFB2B, + shinsindothebrew: 0xFB2B, + shook: 0x0282, + sigma: 0x03C3, + sigma1: 0x03C2, + sigmafinal: 0x03C2, + sigmalunatesymbolgreek: 0x03F2, + sihiragana: 0x3057, + sikatakana: 0x30B7, + sikatakanahalfwidth: 0xFF7C, + siluqhebrew: 0x05BD, + siluqlefthebrew: 0x05BD, + similar: 0x223C, + sindothebrew: 0x05C2, + siosacirclekorean: 0x3274, + siosaparenkorean: 0x3214, + sioscieuckorean: 0x317E, + sioscirclekorean: 0x3266, + sioskiyeokkorean: 0x317A, + sioskorean: 0x3145, + siosnieunkorean: 0x317B, + siosparenkorean: 0x3206, + siospieupkorean: 0x317D, + siostikeutkorean: 0x317C, + six: 0x0036, + sixarabic: 0x0666, + sixbengali: 0x09EC, + sixcircle: 0x2465, + sixcircleinversesansserif: 0x278F, + sixdeva: 0x096C, + sixgujarati: 0x0AEC, + sixgurmukhi: 0x0A6C, + sixhackarabic: 0x0666, + sixhangzhou: 0x3026, + sixideographicparen: 0x3225, + sixinferior: 0x2086, + sixmonospace: 0xFF16, + sixoldstyle: 0xF736, + sixparen: 0x2479, + sixperiod: 0x248D, + sixpersian: 0x06F6, + sixroman: 0x2175, + sixsuperior: 0x2076, + sixteencircle: 0x246F, + sixteencurrencydenominatorbengali: 0x09F9, + sixteenparen: 0x2483, + sixteenperiod: 0x2497, + sixthai: 0x0E56, + slash: 0x002F, + slashmonospace: 0xFF0F, + slong: 0x017F, + slongdotaccent: 0x1E9B, + smileface: 0x263A, + smonospace: 0xFF53, + sofpasuqhebrew: 0x05C3, + softhyphen: 0x00AD, + softsigncyrillic: 0x044C, + sohiragana: 0x305D, + sokatakana: 0x30BD, + sokatakanahalfwidth: 0xFF7F, + soliduslongoverlaycmb: 0x0338, + solidusshortoverlaycmb: 0x0337, + sorusithai: 0x0E29, + sosalathai: 0x0E28, + sosothai: 0x0E0B, + sosuathai: 0x0E2A, + space: 0x0020, + spacehackarabic: 0x0020, + spade: 0x2660, + spadesuitblack: 0x2660, + spadesuitwhite: 0x2664, + sparen: 0x24AE, + squarebelowcmb: 0x033B, + squarecc: 0x33C4, + squarecm: 0x339D, + squarediagonalcrosshatchfill: 0x25A9, + squarehorizontalfill: 0x25A4, + squarekg: 0x338F, + squarekm: 0x339E, + squarekmcapital: 0x33CE, + squareln: 0x33D1, + squarelog: 0x33D2, + squaremg: 0x338E, + squaremil: 0x33D5, + squaremm: 0x339C, + squaremsquared: 0x33A1, + squareorthogonalcrosshatchfill: 0x25A6, + squareupperlefttolowerrightfill: 0x25A7, + squareupperrighttolowerleftfill: 0x25A8, + squareverticalfill: 0x25A5, + squarewhitewithsmallblack: 0x25A3, + srsquare: 0x33DB, + ssabengali: 0x09B7, + ssadeva: 0x0937, + ssagujarati: 0x0AB7, + ssangcieuckorean: 0x3149, + ssanghieuhkorean: 0x3185, + ssangieungkorean: 0x3180, + ssangkiyeokkorean: 0x3132, + ssangnieunkorean: 0x3165, + ssangpieupkorean: 0x3143, + ssangsioskorean: 0x3146, + ssangtikeutkorean: 0x3138, + ssuperior: 0xF6F2, + sterling: 0x00A3, + sterlingmonospace: 0xFFE1, + strokelongoverlaycmb: 0x0336, + strokeshortoverlaycmb: 0x0335, + subset: 0x2282, + subsetnotequal: 0x228A, + subsetorequal: 0x2286, + succeeds: 0x227B, + suchthat: 0x220B, + suhiragana: 0x3059, + sukatakana: 0x30B9, + sukatakanahalfwidth: 0xFF7D, + sukunarabic: 0x0652, + summation: 0x2211, + sun: 0x263C, + superset: 0x2283, + supersetnotequal: 0x228B, + supersetorequal: 0x2287, + svsquare: 0x33DC, + syouwaerasquare: 0x337C, + t: 0x0074, + tabengali: 0x09A4, + tackdown: 0x22A4, + tackleft: 0x22A3, + tadeva: 0x0924, + tagujarati: 0x0AA4, + tagurmukhi: 0x0A24, + taharabic: 0x0637, + tahfinalarabic: 0xFEC2, + tahinitialarabic: 0xFEC3, + tahiragana: 0x305F, + tahmedialarabic: 0xFEC4, + taisyouerasquare: 0x337D, + takatakana: 0x30BF, + takatakanahalfwidth: 0xFF80, + tatweelarabic: 0x0640, + tau: 0x03C4, + tav: 0x05EA, + tavdages: 0xFB4A, + tavdagesh: 0xFB4A, + tavdageshhebrew: 0xFB4A, + tavhebrew: 0x05EA, + tbar: 0x0167, + tbopomofo: 0x310A, + tcaron: 0x0165, + tccurl: 0x02A8, + tcedilla: 0x0163, + tcheharabic: 0x0686, + tchehfinalarabic: 0xFB7B, + tchehinitialarabic: 0xFB7C, + tchehmedialarabic: 0xFB7D, + tcircle: 0x24E3, + tcircumflexbelow: 0x1E71, + tcommaaccent: 0x0163, + tdieresis: 0x1E97, + tdotaccent: 0x1E6B, + tdotbelow: 0x1E6D, + tecyrillic: 0x0442, + tedescendercyrillic: 0x04AD, + teharabic: 0x062A, + tehfinalarabic: 0xFE96, + tehhahinitialarabic: 0xFCA2, + tehhahisolatedarabic: 0xFC0C, + tehinitialarabic: 0xFE97, + tehiragana: 0x3066, + tehjeeminitialarabic: 0xFCA1, + tehjeemisolatedarabic: 0xFC0B, + tehmarbutaarabic: 0x0629, + tehmarbutafinalarabic: 0xFE94, + tehmedialarabic: 0xFE98, + tehmeeminitialarabic: 0xFCA4, + tehmeemisolatedarabic: 0xFC0E, + tehnoonfinalarabic: 0xFC73, + tekatakana: 0x30C6, + tekatakanahalfwidth: 0xFF83, + telephone: 0x2121, + telephoneblack: 0x260E, + telishagedolahebrew: 0x05A0, + telishaqetanahebrew: 0x05A9, + tencircle: 0x2469, + tenideographicparen: 0x3229, + tenparen: 0x247D, + tenperiod: 0x2491, + tenroman: 0x2179, + tesh: 0x02A7, + tet: 0x05D8, + tetdagesh: 0xFB38, + tetdageshhebrew: 0xFB38, + tethebrew: 0x05D8, + tetsecyrillic: 0x04B5, + tevirhebrew: 0x059B, + tevirlefthebrew: 0x059B, + thabengali: 0x09A5, + thadeva: 0x0925, + thagujarati: 0x0AA5, + thagurmukhi: 0x0A25, + thalarabic: 0x0630, + thalfinalarabic: 0xFEAC, + thanthakhatlowleftthai: 0xF898, + thanthakhatlowrightthai: 0xF897, + thanthakhatthai: 0x0E4C, + thanthakhatupperleftthai: 0xF896, + theharabic: 0x062B, + thehfinalarabic: 0xFE9A, + thehinitialarabic: 0xFE9B, + thehmedialarabic: 0xFE9C, + thereexists: 0x2203, + therefore: 0x2234, + theta: 0x03B8, + theta1: 0x03D1, + thetasymbolgreek: 0x03D1, + thieuthacirclekorean: 0x3279, + thieuthaparenkorean: 0x3219, + thieuthcirclekorean: 0x326B, + thieuthkorean: 0x314C, + thieuthparenkorean: 0x320B, + thirteencircle: 0x246C, + thirteenparen: 0x2480, + thirteenperiod: 0x2494, + thonangmonthothai: 0x0E11, + thook: 0x01AD, + thophuthaothai: 0x0E12, + thorn: 0x00FE, + thothahanthai: 0x0E17, + thothanthai: 0x0E10, + thothongthai: 0x0E18, + thothungthai: 0x0E16, + thousandcyrillic: 0x0482, + thousandsseparatorarabic: 0x066C, + thousandsseparatorpersian: 0x066C, + three: 0x0033, + threearabic: 0x0663, + threebengali: 0x09E9, + threecircle: 0x2462, + threecircleinversesansserif: 0x278C, + threedeva: 0x0969, + threeeighths: 0x215C, + threegujarati: 0x0AE9, + threegurmukhi: 0x0A69, + threehackarabic: 0x0663, + threehangzhou: 0x3023, + threeideographicparen: 0x3222, + threeinferior: 0x2083, + threemonospace: 0xFF13, + threenumeratorbengali: 0x09F6, + threeoldstyle: 0xF733, + threeparen: 0x2476, + threeperiod: 0x248A, + threepersian: 0x06F3, + threequarters: 0x00BE, + threequartersemdash: 0xF6DE, + threeroman: 0x2172, + threesuperior: 0x00B3, + threethai: 0x0E53, + thzsquare: 0x3394, + tihiragana: 0x3061, + tikatakana: 0x30C1, + tikatakanahalfwidth: 0xFF81, + tikeutacirclekorean: 0x3270, + tikeutaparenkorean: 0x3210, + tikeutcirclekorean: 0x3262, + tikeutkorean: 0x3137, + tikeutparenkorean: 0x3202, + tilde: 0x02DC, + tildebelowcmb: 0x0330, + tildecmb: 0x0303, + tildecomb: 0x0303, + tildedoublecmb: 0x0360, + tildeoperator: 0x223C, + tildeoverlaycmb: 0x0334, + tildeverticalcmb: 0x033E, + timescircle: 0x2297, + tipehahebrew: 0x0596, + tipehalefthebrew: 0x0596, + tippigurmukhi: 0x0A70, + titlocyrilliccmb: 0x0483, + tiwnarmenian: 0x057F, + tlinebelow: 0x1E6F, + tmonospace: 0xFF54, + toarmenian: 0x0569, + tohiragana: 0x3068, + tokatakana: 0x30C8, + tokatakanahalfwidth: 0xFF84, + tonebarextrahighmod: 0x02E5, + tonebarextralowmod: 0x02E9, + tonebarhighmod: 0x02E6, + tonebarlowmod: 0x02E8, + tonebarmidmod: 0x02E7, + tonefive: 0x01BD, + tonesix: 0x0185, + tonetwo: 0x01A8, + tonos: 0x0384, + tonsquare: 0x3327, + topatakthai: 0x0E0F, + tortoiseshellbracketleft: 0x3014, + tortoiseshellbracketleftsmall: 0xFE5D, + tortoiseshellbracketleftvertical: 0xFE39, + tortoiseshellbracketright: 0x3015, + tortoiseshellbracketrightsmall: 0xFE5E, + tortoiseshellbracketrightvertical: 0xFE3A, + totaothai: 0x0E15, + tpalatalhook: 0x01AB, + tparen: 0x24AF, + trademark: 0x2122, + trademarksans: 0xF8EA, + trademarkserif: 0xF6DB, + tretroflexhook: 0x0288, + triagdn: 0x25BC, + triaglf: 0x25C4, + triagrt: 0x25BA, + triagup: 0x25B2, + ts: 0x02A6, + tsadi: 0x05E6, + tsadidagesh: 0xFB46, + tsadidageshhebrew: 0xFB46, + tsadihebrew: 0x05E6, + tsecyrillic: 0x0446, + tsere: 0x05B5, + tsere12: 0x05B5, + tsere1e: 0x05B5, + tsere2b: 0x05B5, + tserehebrew: 0x05B5, + tserenarrowhebrew: 0x05B5, + tserequarterhebrew: 0x05B5, + tserewidehebrew: 0x05B5, + tshecyrillic: 0x045B, + tsuperior: 0xF6F3, + ttabengali: 0x099F, + ttadeva: 0x091F, + ttagujarati: 0x0A9F, + ttagurmukhi: 0x0A1F, + tteharabic: 0x0679, + ttehfinalarabic: 0xFB67, + ttehinitialarabic: 0xFB68, + ttehmedialarabic: 0xFB69, + tthabengali: 0x09A0, + tthadeva: 0x0920, + tthagujarati: 0x0AA0, + tthagurmukhi: 0x0A20, + tturned: 0x0287, + tuhiragana: 0x3064, + tukatakana: 0x30C4, + tukatakanahalfwidth: 0xFF82, + tusmallhiragana: 0x3063, + tusmallkatakana: 0x30C3, + tusmallkatakanahalfwidth: 0xFF6F, + twelvecircle: 0x246B, + twelveparen: 0x247F, + twelveperiod: 0x2493, + twelveroman: 0x217B, + twentycircle: 0x2473, + twentyhangzhou: 0x5344, + twentyparen: 0x2487, + twentyperiod: 0x249B, + two: 0x0032, + twoarabic: 0x0662, + twobengali: 0x09E8, + twocircle: 0x2461, + twocircleinversesansserif: 0x278B, + twodeva: 0x0968, + twodotenleader: 0x2025, + twodotleader: 0x2025, + twodotleadervertical: 0xFE30, + twogujarati: 0x0AE8, + twogurmukhi: 0x0A68, + twohackarabic: 0x0662, + twohangzhou: 0x3022, + twoideographicparen: 0x3221, + twoinferior: 0x2082, + twomonospace: 0xFF12, + twonumeratorbengali: 0x09F5, + twooldstyle: 0xF732, + twoparen: 0x2475, + twoperiod: 0x2489, + twopersian: 0x06F2, + tworoman: 0x2171, + twostroke: 0x01BB, + twosuperior: 0x00B2, + twothai: 0x0E52, + twothirds: 0x2154, + u: 0x0075, + uacute: 0x00FA, + ubar: 0x0289, + ubengali: 0x0989, + ubopomofo: 0x3128, + ubreve: 0x016D, + ucaron: 0x01D4, + ucircle: 0x24E4, + ucircumflex: 0x00FB, + ucircumflexbelow: 0x1E77, + ucyrillic: 0x0443, + udattadeva: 0x0951, + udblacute: 0x0171, + udblgrave: 0x0215, + udeva: 0x0909, + udieresis: 0x00FC, + udieresisacute: 0x01D8, + udieresisbelow: 0x1E73, + udieresiscaron: 0x01DA, + udieresiscyrillic: 0x04F1, + udieresisgrave: 0x01DC, + udieresismacron: 0x01D6, + udotbelow: 0x1EE5, + ugrave: 0x00F9, + ugujarati: 0x0A89, + ugurmukhi: 0x0A09, + uhiragana: 0x3046, + uhookabove: 0x1EE7, + uhorn: 0x01B0, + uhornacute: 0x1EE9, + uhorndotbelow: 0x1EF1, + uhorngrave: 0x1EEB, + uhornhookabove: 0x1EED, + uhorntilde: 0x1EEF, + uhungarumlaut: 0x0171, + uhungarumlautcyrillic: 0x04F3, + uinvertedbreve: 0x0217, + ukatakana: 0x30A6, + ukatakanahalfwidth: 0xFF73, + ukcyrillic: 0x0479, + ukorean: 0x315C, + umacron: 0x016B, + umacroncyrillic: 0x04EF, + umacrondieresis: 0x1E7B, + umatragurmukhi: 0x0A41, + umonospace: 0xFF55, + underscore: 0x005F, + underscoredbl: 0x2017, + underscoremonospace: 0xFF3F, + underscorevertical: 0xFE33, + underscorewavy: 0xFE4F, + union: 0x222A, + universal: 0x2200, + uogonek: 0x0173, + uparen: 0x24B0, + upblock: 0x2580, + upperdothebrew: 0x05C4, + upsilon: 0x03C5, + upsilondieresis: 0x03CB, + upsilondieresistonos: 0x03B0, + upsilonlatin: 0x028A, + upsilontonos: 0x03CD, + uptackbelowcmb: 0x031D, + uptackmod: 0x02D4, + uragurmukhi: 0x0A73, + uring: 0x016F, + ushortcyrillic: 0x045E, + usmallhiragana: 0x3045, + usmallkatakana: 0x30A5, + usmallkatakanahalfwidth: 0xFF69, + ustraightcyrillic: 0x04AF, + ustraightstrokecyrillic: 0x04B1, + utilde: 0x0169, + utildeacute: 0x1E79, + utildebelow: 0x1E75, + uubengali: 0x098A, + uudeva: 0x090A, + uugujarati: 0x0A8A, + uugurmukhi: 0x0A0A, + uumatragurmukhi: 0x0A42, + uuvowelsignbengali: 0x09C2, + uuvowelsigndeva: 0x0942, + uuvowelsigngujarati: 0x0AC2, + uvowelsignbengali: 0x09C1, + uvowelsigndeva: 0x0941, + uvowelsigngujarati: 0x0AC1, + v: 0x0076, + vadeva: 0x0935, + vagujarati: 0x0AB5, + vagurmukhi: 0x0A35, + vakatakana: 0x30F7, + vav: 0x05D5, + vavdagesh: 0xFB35, + vavdagesh65: 0xFB35, + vavdageshhebrew: 0xFB35, + vavhebrew: 0x05D5, + vavholam: 0xFB4B, + vavholamhebrew: 0xFB4B, + vavvavhebrew: 0x05F0, + vavyodhebrew: 0x05F1, + vcircle: 0x24E5, + vdotbelow: 0x1E7F, + vecyrillic: 0x0432, + veharabic: 0x06A4, + vehfinalarabic: 0xFB6B, + vehinitialarabic: 0xFB6C, + vehmedialarabic: 0xFB6D, + vekatakana: 0x30F9, + venus: 0x2640, + verticalbar: 0x007C, + verticallineabovecmb: 0x030D, + verticallinebelowcmb: 0x0329, + verticallinelowmod: 0x02CC, + verticallinemod: 0x02C8, + vewarmenian: 0x057E, + vhook: 0x028B, + vikatakana: 0x30F8, + viramabengali: 0x09CD, + viramadeva: 0x094D, + viramagujarati: 0x0ACD, + visargabengali: 0x0983, + visargadeva: 0x0903, + visargagujarati: 0x0A83, + vmonospace: 0xFF56, + voarmenian: 0x0578, + voicediterationhiragana: 0x309E, + voicediterationkatakana: 0x30FE, + voicedmarkkana: 0x309B, + voicedmarkkanahalfwidth: 0xFF9E, + vokatakana: 0x30FA, + vparen: 0x24B1, + vtilde: 0x1E7D, + vturned: 0x028C, + vuhiragana: 0x3094, + vukatakana: 0x30F4, + w: 0x0077, + wacute: 0x1E83, + waekorean: 0x3159, + wahiragana: 0x308F, + wakatakana: 0x30EF, + wakatakanahalfwidth: 0xFF9C, + wakorean: 0x3158, + wasmallhiragana: 0x308E, + wasmallkatakana: 0x30EE, + wattosquare: 0x3357, + wavedash: 0x301C, + wavyunderscorevertical: 0xFE34, + wawarabic: 0x0648, + wawfinalarabic: 0xFEEE, + wawhamzaabovearabic: 0x0624, + wawhamzaabovefinalarabic: 0xFE86, + wbsquare: 0x33DD, + wcircle: 0x24E6, + wcircumflex: 0x0175, + wdieresis: 0x1E85, + wdotaccent: 0x1E87, + wdotbelow: 0x1E89, + wehiragana: 0x3091, + weierstrass: 0x2118, + wekatakana: 0x30F1, + wekorean: 0x315E, + weokorean: 0x315D, + wgrave: 0x1E81, + whitebullet: 0x25E6, + whitecircle: 0x25CB, + whitecircleinverse: 0x25D9, + whitecornerbracketleft: 0x300E, + whitecornerbracketleftvertical: 0xFE43, + whitecornerbracketright: 0x300F, + whitecornerbracketrightvertical: 0xFE44, + whitediamond: 0x25C7, + whitediamondcontainingblacksmalldiamond: 0x25C8, + whitedownpointingsmalltriangle: 0x25BF, + whitedownpointingtriangle: 0x25BD, + whiteleftpointingsmalltriangle: 0x25C3, + whiteleftpointingtriangle: 0x25C1, + whitelenticularbracketleft: 0x3016, + whitelenticularbracketright: 0x3017, + whiterightpointingsmalltriangle: 0x25B9, + whiterightpointingtriangle: 0x25B7, + whitesmallsquare: 0x25AB, + whitesmilingface: 0x263A, + whitesquare: 0x25A1, + whitestar: 0x2606, + whitetelephone: 0x260F, + whitetortoiseshellbracketleft: 0x3018, + whitetortoiseshellbracketright: 0x3019, + whiteuppointingsmalltriangle: 0x25B5, + whiteuppointingtriangle: 0x25B3, + wihiragana: 0x3090, + wikatakana: 0x30F0, + wikorean: 0x315F, + wmonospace: 0xFF57, + wohiragana: 0x3092, + wokatakana: 0x30F2, + wokatakanahalfwidth: 0xFF66, + won: 0x20A9, + wonmonospace: 0xFFE6, + wowaenthai: 0x0E27, + wparen: 0x24B2, + wring: 0x1E98, + wsuperior: 0x02B7, + wturned: 0x028D, + wynn: 0x01BF, + x: 0x0078, + xabovecmb: 0x033D, + xbopomofo: 0x3112, + xcircle: 0x24E7, + xdieresis: 0x1E8D, + xdotaccent: 0x1E8B, + xeharmenian: 0x056D, + xi: 0x03BE, + xmonospace: 0xFF58, + xparen: 0x24B3, + xsuperior: 0x02E3, + y: 0x0079, + yaadosquare: 0x334E, + yabengali: 0x09AF, + yacute: 0x00FD, + yadeva: 0x092F, + yaekorean: 0x3152, + yagujarati: 0x0AAF, + yagurmukhi: 0x0A2F, + yahiragana: 0x3084, + yakatakana: 0x30E4, + yakatakanahalfwidth: 0xFF94, + yakorean: 0x3151, + yamakkanthai: 0x0E4E, + yasmallhiragana: 0x3083, + yasmallkatakana: 0x30E3, + yasmallkatakanahalfwidth: 0xFF6C, + yatcyrillic: 0x0463, + ycircle: 0x24E8, + ycircumflex: 0x0177, + ydieresis: 0x00FF, + ydotaccent: 0x1E8F, + ydotbelow: 0x1EF5, + yeharabic: 0x064A, + yehbarreearabic: 0x06D2, + yehbarreefinalarabic: 0xFBAF, + yehfinalarabic: 0xFEF2, + yehhamzaabovearabic: 0x0626, + yehhamzaabovefinalarabic: 0xFE8A, + yehhamzaaboveinitialarabic: 0xFE8B, + yehhamzaabovemedialarabic: 0xFE8C, + yehinitialarabic: 0xFEF3, + yehmedialarabic: 0xFEF4, + yehmeeminitialarabic: 0xFCDD, + yehmeemisolatedarabic: 0xFC58, + yehnoonfinalarabic: 0xFC94, + yehthreedotsbelowarabic: 0x06D1, + yekorean: 0x3156, + yen: 0x00A5, + yenmonospace: 0xFFE5, + yeokorean: 0x3155, + yeorinhieuhkorean: 0x3186, + yerahbenyomohebrew: 0x05AA, + yerahbenyomolefthebrew: 0x05AA, + yericyrillic: 0x044B, + yerudieresiscyrillic: 0x04F9, + yesieungkorean: 0x3181, + yesieungpansioskorean: 0x3183, + yesieungsioskorean: 0x3182, + yetivhebrew: 0x059A, + ygrave: 0x1EF3, + yhook: 0x01B4, + yhookabove: 0x1EF7, + yiarmenian: 0x0575, + yicyrillic: 0x0457, + yikorean: 0x3162, + yinyang: 0x262F, + yiwnarmenian: 0x0582, + ymonospace: 0xFF59, + yod: 0x05D9, + yoddagesh: 0xFB39, + yoddageshhebrew: 0xFB39, + yodhebrew: 0x05D9, + yodyodhebrew: 0x05F2, + yodyodpatahhebrew: 0xFB1F, + yohiragana: 0x3088, + yoikorean: 0x3189, + yokatakana: 0x30E8, + yokatakanahalfwidth: 0xFF96, + yokorean: 0x315B, + yosmallhiragana: 0x3087, + yosmallkatakana: 0x30E7, + yosmallkatakanahalfwidth: 0xFF6E, + yotgreek: 0x03F3, + yoyaekorean: 0x3188, + yoyakorean: 0x3187, + yoyakthai: 0x0E22, + yoyingthai: 0x0E0D, + yparen: 0x24B4, + ypogegrammeni: 0x037A, + ypogegrammenigreekcmb: 0x0345, + yr: 0x01A6, + yring: 0x1E99, + ysuperior: 0x02B8, + ytilde: 0x1EF9, + yturned: 0x028E, + yuhiragana: 0x3086, + yuikorean: 0x318C, + yukatakana: 0x30E6, + yukatakanahalfwidth: 0xFF95, + yukorean: 0x3160, + yusbigcyrillic: 0x046B, + yusbigiotifiedcyrillic: 0x046D, + yuslittlecyrillic: 0x0467, + yuslittleiotifiedcyrillic: 0x0469, + yusmallhiragana: 0x3085, + yusmallkatakana: 0x30E5, + yusmallkatakanahalfwidth: 0xFF6D, + yuyekorean: 0x318B, + yuyeokorean: 0x318A, + yyabengali: 0x09DF, + yyadeva: 0x095F, + z: 0x007A, + zaarmenian: 0x0566, + zacute: 0x017A, + zadeva: 0x095B, + zagurmukhi: 0x0A5B, + zaharabic: 0x0638, + zahfinalarabic: 0xFEC6, + zahinitialarabic: 0xFEC7, + zahiragana: 0x3056, + zahmedialarabic: 0xFEC8, + zainarabic: 0x0632, + zainfinalarabic: 0xFEB0, + zakatakana: 0x30B6, + zaqefgadolhebrew: 0x0595, + zaqefqatanhebrew: 0x0594, + zarqahebrew: 0x0598, + zayin: 0x05D6, + zayindagesh: 0xFB36, + zayindageshhebrew: 0xFB36, + zayinhebrew: 0x05D6, + zbopomofo: 0x3117, + zcaron: 0x017E, + zcircle: 0x24E9, + zcircumflex: 0x1E91, + zcurl: 0x0291, + zdot: 0x017C, + zdotaccent: 0x017C, + zdotbelow: 0x1E93, + zecyrillic: 0x0437, + zedescendercyrillic: 0x0499, + zedieresiscyrillic: 0x04DF, + zehiragana: 0x305C, + zekatakana: 0x30BC, + zero: 0x0030, + zeroarabic: 0x0660, + zerobengali: 0x09E6, + zerodeva: 0x0966, + zerogujarati: 0x0AE6, + zerogurmukhi: 0x0A66, + zerohackarabic: 0x0660, + zeroinferior: 0x2080, + zeromonospace: 0xFF10, + zerooldstyle: 0xF730, + zeropersian: 0x06F0, + zerosuperior: 0x2070, + zerothai: 0x0E50, + zerowidthjoiner: 0xFEFF, + zerowidthnonjoiner: 0x200C, + zerowidthspace: 0x200B, + zeta: 0x03B6, + zhbopomofo: 0x3113, + zhearmenian: 0x056A, + zhebrevecyrillic: 0x04C2, + zhecyrillic: 0x0436, + zhedescendercyrillic: 0x0497, + zhedieresiscyrillic: 0x04DD, + zihiragana: 0x3058, + zikatakana: 0x30B8, + zinorhebrew: 0x05AE, + zlinebelow: 0x1E95, + zmonospace: 0xFF5A, + zohiragana: 0x305E, + zokatakana: 0x30BE, + zparen: 0x24B5, + zretroflexhook: 0x0290, + zstroke: 0x01B6, + zuhiragana: 0x305A, + zukatakana: 0x30BA, + '.notdef': 0x0000 +}; + +var DingbatsGlyphsUnicode = { + space: 0x0020, + a1: 0x2701, + a2: 0x2702, + a202: 0x2703, + a3: 0x2704, + a4: 0x260E, + a5: 0x2706, + a119: 0x2707, + a118: 0x2708, + a117: 0x2709, + a11: 0x261B, + a12: 0x261E, + a13: 0x270C, + a14: 0x270D, + a15: 0x270E, + a16: 0x270F, + a105: 0x2710, + a17: 0x2711, + a18: 0x2712, + a19: 0x2713, + a20: 0x2714, + a21: 0x2715, + a22: 0x2716, + a23: 0x2717, + a24: 0x2718, + a25: 0x2719, + a26: 0x271A, + a27: 0x271B, + a28: 0x271C, + a6: 0x271D, + a7: 0x271E, + a8: 0x271F, + a9: 0x2720, + a10: 0x2721, + a29: 0x2722, + a30: 0x2723, + a31: 0x2724, + a32: 0x2725, + a33: 0x2726, + a34: 0x2727, + a35: 0x2605, + a36: 0x2729, + a37: 0x272A, + a38: 0x272B, + a39: 0x272C, + a40: 0x272D, + a41: 0x272E, + a42: 0x272F, + a43: 0x2730, + a44: 0x2731, + a45: 0x2732, + a46: 0x2733, + a47: 0x2734, + a48: 0x2735, + a49: 0x2736, + a50: 0x2737, + a51: 0x2738, + a52: 0x2739, + a53: 0x273A, + a54: 0x273B, + a55: 0x273C, + a56: 0x273D, + a57: 0x273E, + a58: 0x273F, + a59: 0x2740, + a60: 0x2741, + a61: 0x2742, + a62: 0x2743, + a63: 0x2744, + a64: 0x2745, + a65: 0x2746, + a66: 0x2747, + a67: 0x2748, + a68: 0x2749, + a69: 0x274A, + a70: 0x274B, + a71: 0x25CF, + a72: 0x274D, + a73: 0x25A0, + a74: 0x274F, + a203: 0x2750, + a75: 0x2751, + a204: 0x2752, + a76: 0x25B2, + a77: 0x25BC, + a78: 0x25C6, + a79: 0x2756, + a81: 0x25D7, + a82: 0x2758, + a83: 0x2759, + a84: 0x275A, + a97: 0x275B, + a98: 0x275C, + a99: 0x275D, + a100: 0x275E, + a101: 0x2761, + a102: 0x2762, + a103: 0x2763, + a104: 0x2764, + a106: 0x2765, + a107: 0x2766, + a108: 0x2767, + a112: 0x2663, + a111: 0x2666, + a110: 0x2665, + a109: 0x2660, + a120: 0x2460, + a121: 0x2461, + a122: 0x2462, + a123: 0x2463, + a124: 0x2464, + a125: 0x2465, + a126: 0x2466, + a127: 0x2467, + a128: 0x2468, + a129: 0x2469, + a130: 0x2776, + a131: 0x2777, + a132: 0x2778, + a133: 0x2779, + a134: 0x277A, + a135: 0x277B, + a136: 0x277C, + a137: 0x277D, + a138: 0x277E, + a139: 0x277F, + a140: 0x2780, + a141: 0x2781, + a142: 0x2782, + a143: 0x2783, + a144: 0x2784, + a145: 0x2785, + a146: 0x2786, + a147: 0x2787, + a148: 0x2788, + a149: 0x2789, + a150: 0x278A, + a151: 0x278B, + a152: 0x278C, + a153: 0x278D, + a154: 0x278E, + a155: 0x278F, + a156: 0x2790, + a157: 0x2791, + a158: 0x2792, + a159: 0x2793, + a160: 0x2794, + a161: 0x2192, + a163: 0x2194, + a164: 0x2195, + a196: 0x2798, + a165: 0x2799, + a192: 0x279A, + a166: 0x279B, + a167: 0x279C, + a168: 0x279D, + a169: 0x279E, + a170: 0x279F, + a171: 0x27A0, + a172: 0x27A1, + a173: 0x27A2, + a162: 0x27A3, + a174: 0x27A4, + a175: 0x27A5, + a176: 0x27A6, + a177: 0x27A7, + a178: 0x27A8, + a179: 0x27A9, + a193: 0x27AA, + a180: 0x27AB, + a199: 0x27AC, + a181: 0x27AD, + a200: 0x27AE, + a182: 0x27AF, + a201: 0x27B1, + a183: 0x27B2, + a184: 0x27B3, + a197: 0x27B4, + a185: 0x27B5, + a194: 0x27B6, + a198: 0x27B7, + a186: 0x27B8, + a195: 0x27B9, + a187: 0x27BA, + a188: 0x27BB, + a189: 0x27BC, + a190: 0x27BD, + a191: 0x27BE, + a89: 0x2768, // 0xF8D7 + a90: 0x2769, // 0xF8D8 + a93: 0x276A, // 0xF8D9 + a94: 0x276B, // 0xF8DA + a91: 0x276C, // 0xF8DB + a92: 0x276D, // 0xF8DC + a205: 0x276E, // 0xF8DD + a85: 0x276F, // 0xF8DE + a206: 0x2770, // 0xF8DF + a86: 0x2771, // 0xF8E0 + a87: 0x2772, // 0xF8E1 + a88: 0x2773, // 0xF8E2 + a95: 0x2774, // 0xF8E3 + a96: 0x2775, // 0xF8E4 + '.notdef': 0x0000 +}; + +exports.GlyphsUnicode = GlyphsUnicode; +exports.DingbatsGlyphsUnicode = DingbatsGlyphsUnicode; +})); + + + +(function (root, factory) { + { + factory((root.pdfjsCoreJpg = {})); + } +}(this, function (exports) { + +/* +This code was forked from https://github.com/notmasteryet/jpgjs. The original +version was created by github user notmasteryet + +- The JPEG specification can be found in the ITU CCITT Recommendation T.81 + (www.w3.org/Graphics/JPEG/itu-t81.pdf) +- The JFIF specification can be found in the JPEG File Interchange Format + (www.w3.org/Graphics/JPEG/jfif3.pdf) +- The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters + in PostScript Level 2, Technical Note #5116 + (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf) +*/ + +var JpegImage = (function jpegImage() { + var dctZigZag = new Uint8Array([ + 0, + 1, 8, + 16, 9, 2, + 3, 10, 17, 24, + 32, 25, 18, 11, 4, + 5, 12, 19, 26, 33, 40, + 48, 41, 34, 27, 20, 13, 6, + 7, 14, 21, 28, 35, 42, 49, 56, + 57, 50, 43, 36, 29, 22, 15, + 23, 30, 37, 44, 51, 58, + 59, 52, 45, 38, 31, + 39, 46, 53, 60, + 61, 54, 47, + 55, 62, + 63 + ]); + + var dctCos1 = 4017; // cos(pi/16) + var dctSin1 = 799; // sin(pi/16) + var dctCos3 = 3406; // cos(3*pi/16) + var dctSin3 = 2276; // sin(3*pi/16) + var dctCos6 = 1567; // cos(6*pi/16) + var dctSin6 = 3784; // sin(6*pi/16) + var dctSqrt2 = 5793; // sqrt(2) + var dctSqrt1d2 = 2896; // sqrt(2) / 2 + + function constructor() { + } + + function buildHuffmanTable(codeLengths, values) { + var k = 0, code = [], i, j, length = 16; + while (length > 0 && !codeLengths[length - 1]) { + length--; + } + code.push({children: [], index: 0}); + var p = code[0], q; + for (i = 0; i < length; i++) { + for (j = 0; j < codeLengths[i]; j++) { + p = code.pop(); + p.children[p.index] = values[k]; + while (p.index > 0) { + p = code.pop(); + } + p.index++; + code.push(p); + while (code.length <= i) { + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + k++; + } + if (i + 1 < length) { + // p here points to last code + code.push(q = {children: [], index: 0}); + p.children[p.index] = q.children; + p = q; + } + } + return code[0].children; + } + + function getBlockBufferOffset(component, row, col) { + return 64 * ((component.blocksPerLine + 1) * row + col); + } + + function decodeScan(data, offset, frame, components, resetInterval, + spectralStart, spectralEnd, successivePrev, successive) { + var mcusPerLine = frame.mcusPerLine; + var progressive = frame.progressive; + + var startOffset = offset, bitsData = 0, bitsCount = 0; + + function readBit() { + if (bitsCount > 0) { + bitsCount--; + return (bitsData >> bitsCount) & 1; + } + bitsData = data[offset++]; + if (bitsData === 0xFF) { + var nextByte = data[offset++]; + if (nextByte) { + throw 'unexpected marker: ' + + ((bitsData << 8) | nextByte).toString(16); + } + // unstuff 0 + } + bitsCount = 7; + return bitsData >>> 7; + } + + function decodeHuffman(tree) { + var node = tree; + while (true) { + node = node[readBit()]; + if (typeof node === 'number') { + return node; + } + if (typeof node !== 'object') { + throw 'invalid huffman sequence'; + } + } + } + + function receive(length) { + var n = 0; + while (length > 0) { + n = (n << 1) | readBit(); + length--; + } + return n; + } + + function receiveAndExtend(length) { + if (length === 1) { + return readBit() === 1 ? 1 : -1; + } + var n = receive(length); + if (n >= 1 << (length - 1)) { + return n; + } + return n + (-1 << length) + 1; + } + + function decodeBaseline(component, offset) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : receiveAndExtend(t); + component.blockData[offset] = (component.pred += diff); + var k = 1; + while (k < 64) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + break; + } + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + component.blockData[offset + z] = receiveAndExtend(s); + k++; + } + } + + function decodeDCFirst(component, offset) { + var t = decodeHuffman(component.huffmanTableDC); + var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive); + component.blockData[offset] = (component.pred += diff); + } + + function decodeDCSuccessive(component, offset) { + component.blockData[offset] |= readBit() << successive; + } + + var eobrun = 0; + function decodeACFirst(component, offset) { + if (eobrun > 0) { + eobrun--; + return; + } + var k = spectralStart, e = spectralEnd; + while (k <= e) { + var rs = decodeHuffman(component.huffmanTableAC); + var s = rs & 15, r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r) - 1; + break; + } + k += 16; + continue; + } + k += r; + var z = dctZigZag[k]; + component.blockData[offset + z] = + receiveAndExtend(s) * (1 << successive); + k++; + } + } + + var successiveACState = 0, successiveACNextValue; + function decodeACSuccessive(component, offset) { + var k = spectralStart; + var e = spectralEnd; + var r = 0; + var s; + var rs; + while (k <= e) { + var z = dctZigZag[k]; + switch (successiveACState) { + case 0: // initial state + rs = decodeHuffman(component.huffmanTableAC); + s = rs & 15; + r = rs >> 4; + if (s === 0) { + if (r < 15) { + eobrun = receive(r) + (1 << r); + successiveACState = 4; + } else { + r = 16; + successiveACState = 1; + } + } else { + if (s !== 1) { + throw 'invalid ACn encoding'; + } + successiveACNextValue = receiveAndExtend(s); + successiveACState = r ? 2 : 3; + } + continue; + case 1: // skipping r zero items + case 2: + if (component.blockData[offset + z]) { + component.blockData[offset + z] += (readBit() << successive); + } else { + r--; + if (r === 0) { + successiveACState = successiveACState === 2 ? 3 : 0; + } + } + break; + case 3: // set value for a zero item + if (component.blockData[offset + z]) { + component.blockData[offset + z] += (readBit() << successive); + } else { + component.blockData[offset + z] = + successiveACNextValue << successive; + successiveACState = 0; + } + break; + case 4: // eob + if (component.blockData[offset + z]) { + component.blockData[offset + z] += (readBit() << successive); + } + break; + } + k++; + } + if (successiveACState === 4) { + eobrun--; + if (eobrun === 0) { + successiveACState = 0; + } + } + } + + function decodeMcu(component, decode, mcu, row, col) { + var mcuRow = (mcu / mcusPerLine) | 0; + var mcuCol = mcu % mcusPerLine; + var blockRow = mcuRow * component.v + row; + var blockCol = mcuCol * component.h + col; + var offset = getBlockBufferOffset(component, blockRow, blockCol); + decode(component, offset); + } + + function decodeBlock(component, decode, mcu) { + var blockRow = (mcu / component.blocksPerLine) | 0; + var blockCol = mcu % component.blocksPerLine; + var offset = getBlockBufferOffset(component, blockRow, blockCol); + decode(component, offset); + } + + var componentsLength = components.length; + var component, i, j, k, n; + var decodeFn; + if (progressive) { + if (spectralStart === 0) { + decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive; + } else { + decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive; + } + } else { + decodeFn = decodeBaseline; + } + + var mcu = 0, marker; + var mcuExpected; + if (componentsLength === 1) { + mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn; + } else { + mcuExpected = mcusPerLine * frame.mcusPerColumn; + } + if (!resetInterval) { + resetInterval = mcuExpected; + } + + var h, v; + while (mcu < mcuExpected) { + // reset interval stuff + for (i = 0; i < componentsLength; i++) { + components[i].pred = 0; + } + eobrun = 0; + + if (componentsLength === 1) { + component = components[0]; + for (n = 0; n < resetInterval; n++) { + decodeBlock(component, decodeFn, mcu); + mcu++; + } + } else { + for (n = 0; n < resetInterval; n++) { + for (i = 0; i < componentsLength; i++) { + component = components[i]; + h = component.h; + v = component.v; + for (j = 0; j < v; j++) { + for (k = 0; k < h; k++) { + decodeMcu(component, decodeFn, mcu, j, k); + } + } + } + mcu++; + } + } + + // find marker + bitsCount = 0; + marker = (data[offset] << 8) | data[offset + 1]; + if (marker <= 0xFF00) { + throw 'marker was not found'; + } + + if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx + offset += 2; + } else { + break; + } + } + + return offset - startOffset; + } + + // A port of poppler's IDCT method which in turn is taken from: + // Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz, + // 'Practical Fast 1-D DCT Algorithms with 11 Multiplications', + // IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989, + // 988-991. + function quantizeAndInverse(component, blockBufferOffset, p) { + var qt = component.quantizationTable, blockData = component.blockData; + var v0, v1, v2, v3, v4, v5, v6, v7; + var p0, p1, p2, p3, p4, p5, p6, p7; + var t; + + // inverse DCT on rows + for (var row = 0; row < 64; row += 8) { + // gather block data + p0 = blockData[blockBufferOffset + row]; + p1 = blockData[blockBufferOffset + row + 1]; + p2 = blockData[blockBufferOffset + row + 2]; + p3 = blockData[blockBufferOffset + row + 3]; + p4 = blockData[blockBufferOffset + row + 4]; + p5 = blockData[blockBufferOffset + row + 5]; + p6 = blockData[blockBufferOffset + row + 6]; + p7 = blockData[blockBufferOffset + row + 7]; + + // dequant p0 + p0 *= qt[row]; + + // check for all-zero AC coefficients + if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) { + t = (dctSqrt2 * p0 + 512) >> 10; + p[row] = t; + p[row + 1] = t; + p[row + 2] = t; + p[row + 3] = t; + p[row + 4] = t; + p[row + 5] = t; + p[row + 6] = t; + p[row + 7] = t; + continue; + } + // dequant p1 ... p7 + p1 *= qt[row + 1]; + p2 *= qt[row + 2]; + p3 *= qt[row + 3]; + p4 *= qt[row + 4]; + p5 *= qt[row + 5]; + p6 *= qt[row + 6]; + p7 *= qt[row + 7]; + + // stage 4 + v0 = (dctSqrt2 * p0 + 128) >> 8; + v1 = (dctSqrt2 * p4 + 128) >> 8; + v2 = p2; + v3 = p6; + v4 = (dctSqrt1d2 * (p1 - p7) + 128) >> 8; + v7 = (dctSqrt1d2 * (p1 + p7) + 128) >> 8; + v5 = p3 << 4; + v6 = p5 << 4; + + // stage 3 + v0 = (v0 + v1 + 1) >> 1; + v1 = v0 - v1; + t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8; + v3 = t; + v4 = (v4 + v6 + 1) >> 1; + v6 = v4 - v6; + v7 = (v7 + v5 + 1) >> 1; + v5 = v7 - v5; + + // stage 2 + v0 = (v0 + v3 + 1) >> 1; + v3 = v0 - v3; + v1 = (v1 + v2 + 1) >> 1; + v2 = v1 - v2; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p[row] = v0 + v7; + p[row + 7] = v0 - v7; + p[row + 1] = v1 + v6; + p[row + 6] = v1 - v6; + p[row + 2] = v2 + v5; + p[row + 5] = v2 - v5; + p[row + 3] = v3 + v4; + p[row + 4] = v3 - v4; + } + + // inverse DCT on columns + for (var col = 0; col < 8; ++col) { + p0 = p[col]; + p1 = p[col + 8]; + p2 = p[col + 16]; + p3 = p[col + 24]; + p4 = p[col + 32]; + p5 = p[col + 40]; + p6 = p[col + 48]; + p7 = p[col + 56]; + + // check for all-zero AC coefficients + if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) { + t = (dctSqrt2 * p0 + 8192) >> 14; + // convert to 8 bit + t = (t < -2040) ? 0 : (t >= 2024) ? 255 : (t + 2056) >> 4; + blockData[blockBufferOffset + col] = t; + blockData[blockBufferOffset + col + 8] = t; + blockData[blockBufferOffset + col + 16] = t; + blockData[blockBufferOffset + col + 24] = t; + blockData[blockBufferOffset + col + 32] = t; + blockData[blockBufferOffset + col + 40] = t; + blockData[blockBufferOffset + col + 48] = t; + blockData[blockBufferOffset + col + 56] = t; + continue; + } + + // stage 4 + v0 = (dctSqrt2 * p0 + 2048) >> 12; + v1 = (dctSqrt2 * p4 + 2048) >> 12; + v2 = p2; + v3 = p6; + v4 = (dctSqrt1d2 * (p1 - p7) + 2048) >> 12; + v7 = (dctSqrt1d2 * (p1 + p7) + 2048) >> 12; + v5 = p3; + v6 = p5; + + // stage 3 + // Shift v0 by 128.5 << 5 here, so we don't need to shift p0...p7 when + // converting to UInt8 range later. + v0 = ((v0 + v1 + 1) >> 1) + 4112; + v1 = v0 - v1; + t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12; + v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12; + v3 = t; + v4 = (v4 + v6 + 1) >> 1; + v6 = v4 - v6; + v7 = (v7 + v5 + 1) >> 1; + v5 = v7 - v5; + + // stage 2 + v0 = (v0 + v3 + 1) >> 1; + v3 = v0 - v3; + v1 = (v1 + v2 + 1) >> 1; + v2 = v1 - v2; + t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12; + v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12; + v7 = t; + t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12; + v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12; + v6 = t; + + // stage 1 + p0 = v0 + v7; + p7 = v0 - v7; + p1 = v1 + v6; + p6 = v1 - v6; + p2 = v2 + v5; + p5 = v2 - v5; + p3 = v3 + v4; + p4 = v3 - v4; + + // convert to 8-bit integers + p0 = (p0 < 16) ? 0 : (p0 >= 4080) ? 255 : p0 >> 4; + p1 = (p1 < 16) ? 0 : (p1 >= 4080) ? 255 : p1 >> 4; + p2 = (p2 < 16) ? 0 : (p2 >= 4080) ? 255 : p2 >> 4; + p3 = (p3 < 16) ? 0 : (p3 >= 4080) ? 255 : p3 >> 4; + p4 = (p4 < 16) ? 0 : (p4 >= 4080) ? 255 : p4 >> 4; + p5 = (p5 < 16) ? 0 : (p5 >= 4080) ? 255 : p5 >> 4; + p6 = (p6 < 16) ? 0 : (p6 >= 4080) ? 255 : p6 >> 4; + p7 = (p7 < 16) ? 0 : (p7 >= 4080) ? 255 : p7 >> 4; + + // store block data + blockData[blockBufferOffset + col] = p0; + blockData[blockBufferOffset + col + 8] = p1; + blockData[blockBufferOffset + col + 16] = p2; + blockData[blockBufferOffset + col + 24] = p3; + blockData[blockBufferOffset + col + 32] = p4; + blockData[blockBufferOffset + col + 40] = p5; + blockData[blockBufferOffset + col + 48] = p6; + blockData[blockBufferOffset + col + 56] = p7; + } + } + + function buildComponentData(frame, component) { + var blocksPerLine = component.blocksPerLine; + var blocksPerColumn = component.blocksPerColumn; + var computationBuffer = new Int16Array(64); + + for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) { + for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) { + var offset = getBlockBufferOffset(component, blockRow, blockCol); + quantizeAndInverse(component, offset, computationBuffer); + } + } + return component.blockData; + } + + function clamp0to255(a) { + return a <= 0 ? 0 : a >= 255 ? 255 : a; + } + + constructor.prototype = { + parse: function parse(data) { + + function readUint16() { + var value = (data[offset] << 8) | data[offset + 1]; + offset += 2; + return value; + } + + function readDataBlock() { + var length = readUint16(); + var array = data.subarray(offset, offset + length - 2); + offset += array.length; + return array; + } + + function prepareComponents(frame) { + var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH); + var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV); + for (var i = 0; i < frame.components.length; i++) { + component = frame.components[i]; + var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * + component.h / frame.maxH); + var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * + component.v / frame.maxV); + var blocksPerLineForMcu = mcusPerLine * component.h; + var blocksPerColumnForMcu = mcusPerColumn * component.v; + + var blocksBufferSize = 64 * blocksPerColumnForMcu * + (blocksPerLineForMcu + 1); + component.blockData = new Int16Array(blocksBufferSize); + component.blocksPerLine = blocksPerLine; + component.blocksPerColumn = blocksPerColumn; + } + frame.mcusPerLine = mcusPerLine; + frame.mcusPerColumn = mcusPerColumn; + } + + var offset = 0; + var jfif = null; + var adobe = null; + var frame, resetInterval; + var quantizationTables = []; + var huffmanTablesAC = [], huffmanTablesDC = []; + var fileMarker = readUint16(); + if (fileMarker !== 0xFFD8) { // SOI (Start of Image) + throw 'SOI not found'; + } + + fileMarker = readUint16(); + while (fileMarker !== 0xFFD9) { // EOI (End of image) + var i, j, l; + switch(fileMarker) { + case 0xFFE0: // APP0 (Application Specific) + case 0xFFE1: // APP1 + case 0xFFE2: // APP2 + case 0xFFE3: // APP3 + case 0xFFE4: // APP4 + case 0xFFE5: // APP5 + case 0xFFE6: // APP6 + case 0xFFE7: // APP7 + case 0xFFE8: // APP8 + case 0xFFE9: // APP9 + case 0xFFEA: // APP10 + case 0xFFEB: // APP11 + case 0xFFEC: // APP12 + case 0xFFED: // APP13 + case 0xFFEE: // APP14 + case 0xFFEF: // APP15 + case 0xFFFE: // COM (Comment) + var appData = readDataBlock(); + + if (fileMarker === 0xFFE0) { + if (appData[0] === 0x4A && appData[1] === 0x46 && + appData[2] === 0x49 && appData[3] === 0x46 && + appData[4] === 0) { // 'JFIF\x00' + jfif = { + version: { major: appData[5], minor: appData[6] }, + densityUnits: appData[7], + xDensity: (appData[8] << 8) | appData[9], + yDensity: (appData[10] << 8) | appData[11], + thumbWidth: appData[12], + thumbHeight: appData[13], + thumbData: appData.subarray(14, 14 + + 3 * appData[12] * appData[13]) + }; + } + } + // TODO APP1 - Exif + if (fileMarker === 0xFFEE) { + if (appData[0] === 0x41 && appData[1] === 0x64 && + appData[2] === 0x6F && appData[3] === 0x62 && + appData[4] === 0x65) { // 'Adobe' + adobe = { + version: (appData[5] << 8) | appData[6], + flags0: (appData[7] << 8) | appData[8], + flags1: (appData[9] << 8) | appData[10], + transformCode: appData[11] + }; + } + } + break; + + case 0xFFDB: // DQT (Define Quantization Tables) + var quantizationTablesLength = readUint16(); + var quantizationTablesEnd = quantizationTablesLength + offset - 2; + var z; + while (offset < quantizationTablesEnd) { + var quantizationTableSpec = data[offset++]; + var tableData = new Uint16Array(64); + if ((quantizationTableSpec >> 4) === 0) { // 8 bit values + for (j = 0; j < 64; j++) { + z = dctZigZag[j]; + tableData[z] = data[offset++]; + } + } else if ((quantizationTableSpec >> 4) === 1) { //16 bit + for (j = 0; j < 64; j++) { + z = dctZigZag[j]; + tableData[z] = readUint16(); + } + } else { + throw 'DQT: invalid table spec'; + } + quantizationTables[quantizationTableSpec & 15] = tableData; + } + break; + + case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT) + case 0xFFC1: // SOF1 (Start of Frame, Extended DCT) + case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT) + if (frame) { + throw 'Only single frame JPEGs supported'; + } + readUint16(); // skip data length + frame = {}; + frame.extended = (fileMarker === 0xFFC1); + frame.progressive = (fileMarker === 0xFFC2); + frame.precision = data[offset++]; + frame.scanLines = readUint16(); + frame.samplesPerLine = readUint16(); + frame.components = []; + frame.componentIds = {}; + var componentsCount = data[offset++], componentId; + var maxH = 0, maxV = 0; + for (i = 0; i < componentsCount; i++) { + componentId = data[offset]; + var h = data[offset + 1] >> 4; + var v = data[offset + 1] & 15; + if (maxH < h) { + maxH = h; + } + if (maxV < v) { + maxV = v; + } + var qId = data[offset + 2]; + l = frame.components.push({ + h: h, + v: v, + quantizationTable: quantizationTables[qId] + }); + frame.componentIds[componentId] = l - 1; + offset += 3; + } + frame.maxH = maxH; + frame.maxV = maxV; + prepareComponents(frame); + break; + + case 0xFFC4: // DHT (Define Huffman Tables) + var huffmanLength = readUint16(); + for (i = 2; i < huffmanLength;) { + var huffmanTableSpec = data[offset++]; + var codeLengths = new Uint8Array(16); + var codeLengthSum = 0; + for (j = 0; j < 16; j++, offset++) { + codeLengthSum += (codeLengths[j] = data[offset]); + } + var huffmanValues = new Uint8Array(codeLengthSum); + for (j = 0; j < codeLengthSum; j++, offset++) { + huffmanValues[j] = data[offset]; + } + i += 17 + codeLengthSum; + + ((huffmanTableSpec >> 4) === 0 ? + huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = + buildHuffmanTable(codeLengths, huffmanValues); + } + break; + + case 0xFFDD: // DRI (Define Restart Interval) + readUint16(); // skip data length + resetInterval = readUint16(); + break; + + case 0xFFDA: // SOS (Start of Scan) + var scanLength = readUint16(); + var selectorsCount = data[offset++]; + var components = [], component; + for (i = 0; i < selectorsCount; i++) { + var componentIndex = frame.componentIds[data[offset++]]; + component = frame.components[componentIndex]; + var tableSpec = data[offset++]; + component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4]; + component.huffmanTableAC = huffmanTablesAC[tableSpec & 15]; + components.push(component); + } + var spectralStart = data[offset++]; + var spectralEnd = data[offset++]; + var successiveApproximation = data[offset++]; + var processed = decodeScan(data, offset, + frame, components, resetInterval, + spectralStart, spectralEnd, + successiveApproximation >> 4, successiveApproximation & 15); + offset += processed; + break; + + case 0xFFFF: // Fill bytes + if (data[offset] !== 0xFF) { // Avoid skipping a valid marker. + offset--; + } + break; + + default: + if (data[offset - 3] === 0xFF && + data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) { + // could be incorrect encoding -- last 0xFF byte of the previous + // block was eaten by the encoder + offset -= 3; + break; + } + throw 'unknown JPEG marker ' + fileMarker.toString(16); + } + fileMarker = readUint16(); + } + + this.width = frame.samplesPerLine; + this.height = frame.scanLines; + this.jfif = jfif; + this.adobe = adobe; + this.components = []; + for (i = 0; i < frame.components.length; i++) { + component = frame.components[i]; + this.components.push({ + output: buildComponentData(frame, component), + scaleX: component.h / frame.maxH, + scaleY: component.v / frame.maxV, + blocksPerLine: component.blocksPerLine, + blocksPerColumn: component.blocksPerColumn + }); + } + this.numComponents = this.components.length; + }, + + _getLinearizedBlockData: function getLinearizedBlockData(width, height) { + var scaleX = this.width / width, scaleY = this.height / height; + + var component, componentScaleX, componentScaleY, blocksPerScanline; + var x, y, i, j, k; + var index; + var offset = 0; + var output; + var numComponents = this.components.length; + var dataLength = width * height * numComponents; + var data = new Uint8Array(dataLength); + var xScaleBlockOffset = new Uint32Array(width); + var mask3LSB = 0xfffffff8; // used to clear the 3 LSBs + + for (i = 0; i < numComponents; i++) { + component = this.components[i]; + componentScaleX = component.scaleX * scaleX; + componentScaleY = component.scaleY * scaleY; + offset = i; + output = component.output; + blocksPerScanline = (component.blocksPerLine + 1) << 3; + // precalculate the xScaleBlockOffset + for (x = 0; x < width; x++) { + j = 0 | (x * componentScaleX); + xScaleBlockOffset[x] = ((j & mask3LSB) << 3) | (j & 7); + } + // linearize the blocks of the component + for (y = 0; y < height; y++) { + j = 0 | (y * componentScaleY); + index = blocksPerScanline * (j & mask3LSB) | ((j & 7) << 3); + for (x = 0; x < width; x++) { + data[offset] = output[index + xScaleBlockOffset[x]]; + offset += numComponents; + } + } + } + + // decodeTransform contains pairs of multiplier (-256..256) and additive + var transform = this.decodeTransform; + if (transform) { + for (i = 0; i < dataLength;) { + for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) { + data[i] = ((data[i] * transform[k]) >> 8) + transform[k + 1]; + } + } + } + return data; + }, + + _isColorConversionNeeded: function isColorConversionNeeded() { + if (this.adobe && this.adobe.transformCode) { + // The adobe transform marker overrides any previous setting + return true; + } else if (this.numComponents === 3) { + return true; + } else { + return false; + } + }, + + _convertYccToRgb: function convertYccToRgb(data) { + var Y, Cb, Cr; + for (var i = 0, length = data.length; i < length; i += 3) { + Y = data[i ]; + Cb = data[i + 1]; + Cr = data[i + 2]; + data[i ] = clamp0to255(Y - 179.456 + 1.402 * Cr); + data[i + 1] = clamp0to255(Y + 135.459 - 0.344 * Cb - 0.714 * Cr); + data[i + 2] = clamp0to255(Y - 226.816 + 1.772 * Cb); + } + return data; + }, + + _convertYcckToRgb: function convertYcckToRgb(data) { + var Y, Cb, Cr, k; + var offset = 0; + for (var i = 0, length = data.length; i < length; i += 4) { + Y = data[i]; + Cb = data[i + 1]; + Cr = data[i + 2]; + k = data[i + 3]; + + var r = -122.67195406894 + + Cb * (-6.60635669420364e-5 * Cb + 0.000437130475926232 * Cr - + 5.4080610064599e-5 * Y + 0.00048449797120281 * k - + 0.154362151871126) + + Cr * (-0.000957964378445773 * Cr + 0.000817076911346625 * Y - + 0.00477271405408747 * k + 1.53380253221734) + + Y * (0.000961250184130688 * Y - 0.00266257332283933 * k + + 0.48357088451265) + + k * (-0.000336197177618394 * k + 0.484791561490776); + + var g = 107.268039397724 + + Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr + + 0.000659397001245577 * Y + 0.000426105652938837 * k - + 0.176491792462875) + + Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y + + 0.000770482631801132 * k - 0.151051492775562) + + Y * (0.00126935368114843 * Y - 0.00265090189010898 * k + + 0.25802910206845) + + k * (-0.000318913117588328 * k - 0.213742400323665); + + var b = -20.810012546947 + + Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr + + 0.0020741088115012 * Y - 0.00288260236853442 * k + + 0.814272968359295) + + Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y + + 0.000560833691242812 * k - 0.195152027534049) + + Y * (0.00174418132927582 * Y - 0.00255243321439347 * k + + 0.116935020465145) + + k * (-0.000343531996510555 * k + 0.24165260232407); + + data[offset++] = clamp0to255(r); + data[offset++] = clamp0to255(g); + data[offset++] = clamp0to255(b); + } + return data; + }, + + _convertYcckToCmyk: function convertYcckToCmyk(data) { + var Y, Cb, Cr; + for (var i = 0, length = data.length; i < length; i += 4) { + Y = data[i]; + Cb = data[i + 1]; + Cr = data[i + 2]; + data[i ] = clamp0to255(434.456 - Y - 1.402 * Cr); + data[i + 1] = clamp0to255(119.541 - Y + 0.344 * Cb + 0.714 * Cr); + data[i + 2] = clamp0to255(481.816 - Y - 1.772 * Cb); + // K in data[i + 3] is unchanged + } + return data; + }, + + _convertCmykToRgb: function convertCmykToRgb(data) { + var c, m, y, k; + var offset = 0; + var min = -255 * 255 * 255; + var scale = 1 / 255 / 255; + for (var i = 0, length = data.length; i < length; i += 4) { + c = data[i]; + m = data[i + 1]; + y = data[i + 2]; + k = data[i + 3]; + + var r = + c * (-4.387332384609988 * c + 54.48615194189176 * m + + 18.82290502165302 * y + 212.25662451639585 * k - + 72734.4411664936) + + m * (1.7149763477362134 * m - 5.6096736904047315 * y - + 17.873870861415444 * k - 1401.7366389350734) + + y * (-2.5217340131683033 * y - 21.248923337353073 * k + + 4465.541406466231) - + k * (21.86122147463605 * k + 48317.86113160301); + var g = + c * (8.841041422036149 * c + 60.118027045597366 * m + + 6.871425592049007 * y + 31.159100130055922 * k - + 20220.756542821975) + + m * (-15.310361306967817 * m + 17.575251261109482 * y + + 131.35250912493976 * k - 48691.05921601825) + + y * (4.444339102852739 * y + 9.8632861493405 * k - + 6341.191035517494) - + k * (20.737325471181034 * k + 47890.15695978492); + var b = + c * (0.8842522430003296 * c + 8.078677503112928 * m + + 30.89978309703729 * y - 0.23883238689178934 * k - + 3616.812083916688) + + m * (10.49593273432072 * m + 63.02378494754052 * y + + 50.606957656360734 * k - 28620.90484698408) + + y * (0.03296041114873217 * y + 115.60384449646641 * k - + 49363.43385999684) - + k * (22.33816807309886 * k + 45932.16563550634); + + data[offset++] = r >= 0 ? 255 : r <= min ? 0 : 255 + r * scale | 0; + data[offset++] = g >= 0 ? 255 : g <= min ? 0 : 255 + g * scale | 0; + data[offset++] = b >= 0 ? 255 : b <= min ? 0 : 255 + b * scale | 0; + } + return data; + }, + + getData: function getData(width, height, forceRGBoutput) { + if (this.numComponents > 4) { + throw 'Unsupported color mode'; + } + // type of data: Uint8Array(width * height * numComponents) + var data = this._getLinearizedBlockData(width, height); + + if (this.numComponents === 3) { + return this._convertYccToRgb(data); + } else if (this.numComponents === 4) { + if (this._isColorConversionNeeded()) { + if (forceRGBoutput) { + return this._convertYcckToRgb(data); + } else { + return this._convertYcckToCmyk(data); + } + } else if (forceRGBoutput) { + return this._convertCmykToRgb(data); + } + } + return data; + } + }; + + return constructor; +})(); + +exports.JpegImage = JpegImage; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreMetrics = {})); + } +}(this, function (exports) { + +// The Metrics object contains glyph widths (in glyph space units). +// As per PDF spec, for most fonts (Type 3 being an exception) a glyph +// space unit corresponds to 1/1000th of text space unit. +var Metrics = { + 'Courier': 600, + 'Courier-Bold': 600, + 'Courier-BoldOblique': 600, + 'Courier-Oblique': 600, + 'Helvetica' : { + 'space': 278, + 'exclam': 278, + 'quotedbl': 355, + 'numbersign': 556, + 'dollar': 556, + 'percent': 889, + 'ampersand': 667, + 'quoteright': 222, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 389, + 'plus': 584, + 'comma': 278, + 'hyphen': 333, + 'period': 278, + 'slash': 278, + 'zero': 556, + 'one': 556, + 'two': 556, + 'three': 556, + 'four': 556, + 'five': 556, + 'six': 556, + 'seven': 556, + 'eight': 556, + 'nine': 556, + 'colon': 278, + 'semicolon': 278, + 'less': 584, + 'equal': 584, + 'greater': 584, + 'question': 556, + 'at': 1015, + 'A': 667, + 'B': 667, + 'C': 722, + 'D': 722, + 'E': 667, + 'F': 611, + 'G': 778, + 'H': 722, + 'I': 278, + 'J': 500, + 'K': 667, + 'L': 556, + 'M': 833, + 'N': 722, + 'O': 778, + 'P': 667, + 'Q': 778, + 'R': 722, + 'S': 667, + 'T': 611, + 'U': 722, + 'V': 667, + 'W': 944, + 'X': 667, + 'Y': 667, + 'Z': 611, + 'bracketleft': 278, + 'backslash': 278, + 'bracketright': 278, + 'asciicircum': 469, + 'underscore': 556, + 'quoteleft': 222, + 'a': 556, + 'b': 556, + 'c': 500, + 'd': 556, + 'e': 556, + 'f': 278, + 'g': 556, + 'h': 556, + 'i': 222, + 'j': 222, + 'k': 500, + 'l': 222, + 'm': 833, + 'n': 556, + 'o': 556, + 'p': 556, + 'q': 556, + 'r': 333, + 's': 500, + 't': 278, + 'u': 556, + 'v': 500, + 'w': 722, + 'x': 500, + 'y': 500, + 'z': 500, + 'braceleft': 334, + 'bar': 260, + 'braceright': 334, + 'asciitilde': 584, + 'exclamdown': 333, + 'cent': 556, + 'sterling': 556, + 'fraction': 167, + 'yen': 556, + 'florin': 556, + 'section': 556, + 'currency': 556, + 'quotesingle': 191, + 'quotedblleft': 333, + 'guillemotleft': 556, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 500, + 'fl': 500, + 'endash': 556, + 'dagger': 556, + 'daggerdbl': 556, + 'periodcentered': 278, + 'paragraph': 537, + 'bullet': 350, + 'quotesinglbase': 222, + 'quotedblbase': 333, + 'quotedblright': 333, + 'guillemotright': 556, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 611, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 1000, + 'ordfeminine': 370, + 'Lslash': 556, + 'Oslash': 778, + 'OE': 1000, + 'ordmasculine': 365, + 'ae': 889, + 'dotlessi': 278, + 'lslash': 222, + 'oslash': 611, + 'oe': 944, + 'germandbls': 611, + 'Idieresis': 278, + 'eacute': 556, + 'abreve': 556, + 'uhungarumlaut': 556, + 'ecaron': 556, + 'Ydieresis': 667, + 'divide': 584, + 'Yacute': 667, + 'Acircumflex': 667, + 'aacute': 556, + 'Ucircumflex': 722, + 'yacute': 500, + 'scommaaccent': 500, + 'ecircumflex': 556, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 556, + 'Uacute': 722, + 'uogonek': 556, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 737, + 'Emacron': 667, + 'ccaron': 500, + 'aring': 556, + 'Ncommaaccent': 722, + 'lacute': 222, + 'agrave': 556, + 'Tcommaaccent': 611, + 'Cacute': 722, + 'atilde': 556, + 'Edotaccent': 667, + 'scaron': 500, + 'scedilla': 500, + 'iacute': 278, + 'lozenge': 471, + 'Rcaron': 722, + 'Gcommaaccent': 778, + 'ucircumflex': 556, + 'acircumflex': 556, + 'Amacron': 667, + 'rcaron': 333, + 'ccedilla': 500, + 'Zdotaccent': 611, + 'Thorn': 667, + 'Omacron': 778, + 'Racute': 722, + 'Sacute': 667, + 'dcaron': 643, + 'Umacron': 722, + 'uring': 556, + 'threesuperior': 333, + 'Ograve': 778, + 'Agrave': 667, + 'Abreve': 667, + 'multiply': 584, + 'uacute': 556, + 'Tcaron': 611, + 'partialdiff': 476, + 'ydieresis': 500, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 556, + 'edieresis': 556, + 'cacute': 500, + 'nacute': 556, + 'umacron': 556, + 'Ncaron': 722, + 'Iacute': 278, + 'plusminus': 584, + 'brokenbar': 260, + 'registered': 737, + 'Gbreve': 778, + 'Idotaccent': 278, + 'summation': 600, + 'Egrave': 667, + 'racute': 333, + 'omacron': 556, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 722, + 'lcommaaccent': 222, + 'tcaron': 317, + 'eogonek': 556, + 'Uogonek': 722, + 'Aacute': 667, + 'Adieresis': 667, + 'egrave': 556, + 'zacute': 500, + 'iogonek': 222, + 'Oacute': 778, + 'oacute': 556, + 'amacron': 556, + 'sacute': 500, + 'idieresis': 278, + 'Ocircumflex': 778, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 556, + 'twosuperior': 333, + 'Odieresis': 778, + 'mu': 556, + 'igrave': 278, + 'ohungarumlaut': 556, + 'Eogonek': 667, + 'dcroat': 556, + 'threequarters': 834, + 'Scedilla': 667, + 'lcaron': 299, + 'Kcommaaccent': 667, + 'Lacute': 556, + 'trademark': 1000, + 'edotaccent': 556, + 'Igrave': 278, + 'Imacron': 278, + 'Lcaron': 556, + 'onehalf': 834, + 'lessequal': 549, + 'ocircumflex': 556, + 'ntilde': 556, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 556, + 'gbreve': 556, + 'onequarter': 834, + 'Scaron': 667, + 'Scommaaccent': 667, + 'Ohungarumlaut': 778, + 'degree': 400, + 'ograve': 556, + 'Ccaron': 722, + 'ugrave': 556, + 'radical': 453, + 'Dcaron': 722, + 'rcommaaccent': 333, + 'Ntilde': 722, + 'otilde': 556, + 'Rcommaaccent': 722, + 'Lcommaaccent': 556, + 'Atilde': 667, + 'Aogonek': 667, + 'Aring': 667, + 'Otilde': 778, + 'zdotaccent': 500, + 'Ecaron': 667, + 'Iogonek': 278, + 'kcommaaccent': 500, + 'minus': 584, + 'Icircumflex': 278, + 'ncaron': 556, + 'tcommaaccent': 278, + 'logicalnot': 584, + 'odieresis': 556, + 'udieresis': 556, + 'notequal': 549, + 'gcommaaccent': 556, + 'eth': 556, + 'zcaron': 500, + 'ncommaaccent': 556, + 'onesuperior': 333, + 'imacron': 278, + 'Euro': 556 + }, + 'Helvetica-Bold': { + 'space': 278, + 'exclam': 333, + 'quotedbl': 474, + 'numbersign': 556, + 'dollar': 556, + 'percent': 889, + 'ampersand': 722, + 'quoteright': 278, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 389, + 'plus': 584, + 'comma': 278, + 'hyphen': 333, + 'period': 278, + 'slash': 278, + 'zero': 556, + 'one': 556, + 'two': 556, + 'three': 556, + 'four': 556, + 'five': 556, + 'six': 556, + 'seven': 556, + 'eight': 556, + 'nine': 556, + 'colon': 333, + 'semicolon': 333, + 'less': 584, + 'equal': 584, + 'greater': 584, + 'question': 611, + 'at': 975, + 'A': 722, + 'B': 722, + 'C': 722, + 'D': 722, + 'E': 667, + 'F': 611, + 'G': 778, + 'H': 722, + 'I': 278, + 'J': 556, + 'K': 722, + 'L': 611, + 'M': 833, + 'N': 722, + 'O': 778, + 'P': 667, + 'Q': 778, + 'R': 722, + 'S': 667, + 'T': 611, + 'U': 722, + 'V': 667, + 'W': 944, + 'X': 667, + 'Y': 667, + 'Z': 611, + 'bracketleft': 333, + 'backslash': 278, + 'bracketright': 333, + 'asciicircum': 584, + 'underscore': 556, + 'quoteleft': 278, + 'a': 556, + 'b': 611, + 'c': 556, + 'd': 611, + 'e': 556, + 'f': 333, + 'g': 611, + 'h': 611, + 'i': 278, + 'j': 278, + 'k': 556, + 'l': 278, + 'm': 889, + 'n': 611, + 'o': 611, + 'p': 611, + 'q': 611, + 'r': 389, + 's': 556, + 't': 333, + 'u': 611, + 'v': 556, + 'w': 778, + 'x': 556, + 'y': 556, + 'z': 500, + 'braceleft': 389, + 'bar': 280, + 'braceright': 389, + 'asciitilde': 584, + 'exclamdown': 333, + 'cent': 556, + 'sterling': 556, + 'fraction': 167, + 'yen': 556, + 'florin': 556, + 'section': 556, + 'currency': 556, + 'quotesingle': 238, + 'quotedblleft': 500, + 'guillemotleft': 556, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 611, + 'fl': 611, + 'endash': 556, + 'dagger': 556, + 'daggerdbl': 556, + 'periodcentered': 278, + 'paragraph': 556, + 'bullet': 350, + 'quotesinglbase': 278, + 'quotedblbase': 500, + 'quotedblright': 500, + 'guillemotright': 556, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 611, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 1000, + 'ordfeminine': 370, + 'Lslash': 611, + 'Oslash': 778, + 'OE': 1000, + 'ordmasculine': 365, + 'ae': 889, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 611, + 'oe': 944, + 'germandbls': 611, + 'Idieresis': 278, + 'eacute': 556, + 'abreve': 556, + 'uhungarumlaut': 611, + 'ecaron': 556, + 'Ydieresis': 667, + 'divide': 584, + 'Yacute': 667, + 'Acircumflex': 722, + 'aacute': 556, + 'Ucircumflex': 722, + 'yacute': 556, + 'scommaaccent': 556, + 'ecircumflex': 556, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 556, + 'Uacute': 722, + 'uogonek': 611, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 737, + 'Emacron': 667, + 'ccaron': 556, + 'aring': 556, + 'Ncommaaccent': 722, + 'lacute': 278, + 'agrave': 556, + 'Tcommaaccent': 611, + 'Cacute': 722, + 'atilde': 556, + 'Edotaccent': 667, + 'scaron': 556, + 'scedilla': 556, + 'iacute': 278, + 'lozenge': 494, + 'Rcaron': 722, + 'Gcommaaccent': 778, + 'ucircumflex': 611, + 'acircumflex': 556, + 'Amacron': 722, + 'rcaron': 389, + 'ccedilla': 556, + 'Zdotaccent': 611, + 'Thorn': 667, + 'Omacron': 778, + 'Racute': 722, + 'Sacute': 667, + 'dcaron': 743, + 'Umacron': 722, + 'uring': 611, + 'threesuperior': 333, + 'Ograve': 778, + 'Agrave': 722, + 'Abreve': 722, + 'multiply': 584, + 'uacute': 611, + 'Tcaron': 611, + 'partialdiff': 494, + 'ydieresis': 556, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 556, + 'edieresis': 556, + 'cacute': 556, + 'nacute': 611, + 'umacron': 611, + 'Ncaron': 722, + 'Iacute': 278, + 'plusminus': 584, + 'brokenbar': 280, + 'registered': 737, + 'Gbreve': 778, + 'Idotaccent': 278, + 'summation': 600, + 'Egrave': 667, + 'racute': 389, + 'omacron': 611, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 722, + 'lcommaaccent': 278, + 'tcaron': 389, + 'eogonek': 556, + 'Uogonek': 722, + 'Aacute': 722, + 'Adieresis': 722, + 'egrave': 556, + 'zacute': 500, + 'iogonek': 278, + 'Oacute': 778, + 'oacute': 611, + 'amacron': 556, + 'sacute': 556, + 'idieresis': 278, + 'Ocircumflex': 778, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 611, + 'twosuperior': 333, + 'Odieresis': 778, + 'mu': 611, + 'igrave': 278, + 'ohungarumlaut': 611, + 'Eogonek': 667, + 'dcroat': 611, + 'threequarters': 834, + 'Scedilla': 667, + 'lcaron': 400, + 'Kcommaaccent': 722, + 'Lacute': 611, + 'trademark': 1000, + 'edotaccent': 556, + 'Igrave': 278, + 'Imacron': 278, + 'Lcaron': 611, + 'onehalf': 834, + 'lessequal': 549, + 'ocircumflex': 611, + 'ntilde': 611, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 556, + 'gbreve': 611, + 'onequarter': 834, + 'Scaron': 667, + 'Scommaaccent': 667, + 'Ohungarumlaut': 778, + 'degree': 400, + 'ograve': 611, + 'Ccaron': 722, + 'ugrave': 611, + 'radical': 549, + 'Dcaron': 722, + 'rcommaaccent': 389, + 'Ntilde': 722, + 'otilde': 611, + 'Rcommaaccent': 722, + 'Lcommaaccent': 611, + 'Atilde': 722, + 'Aogonek': 722, + 'Aring': 722, + 'Otilde': 778, + 'zdotaccent': 500, + 'Ecaron': 667, + 'Iogonek': 278, + 'kcommaaccent': 556, + 'minus': 584, + 'Icircumflex': 278, + 'ncaron': 611, + 'tcommaaccent': 333, + 'logicalnot': 584, + 'odieresis': 611, + 'udieresis': 611, + 'notequal': 549, + 'gcommaaccent': 611, + 'eth': 611, + 'zcaron': 500, + 'ncommaaccent': 611, + 'onesuperior': 333, + 'imacron': 278, + 'Euro': 556 + }, + 'Helvetica-BoldOblique': { + 'space': 278, + 'exclam': 333, + 'quotedbl': 474, + 'numbersign': 556, + 'dollar': 556, + 'percent': 889, + 'ampersand': 722, + 'quoteright': 278, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 389, + 'plus': 584, + 'comma': 278, + 'hyphen': 333, + 'period': 278, + 'slash': 278, + 'zero': 556, + 'one': 556, + 'two': 556, + 'three': 556, + 'four': 556, + 'five': 556, + 'six': 556, + 'seven': 556, + 'eight': 556, + 'nine': 556, + 'colon': 333, + 'semicolon': 333, + 'less': 584, + 'equal': 584, + 'greater': 584, + 'question': 611, + 'at': 975, + 'A': 722, + 'B': 722, + 'C': 722, + 'D': 722, + 'E': 667, + 'F': 611, + 'G': 778, + 'H': 722, + 'I': 278, + 'J': 556, + 'K': 722, + 'L': 611, + 'M': 833, + 'N': 722, + 'O': 778, + 'P': 667, + 'Q': 778, + 'R': 722, + 'S': 667, + 'T': 611, + 'U': 722, + 'V': 667, + 'W': 944, + 'X': 667, + 'Y': 667, + 'Z': 611, + 'bracketleft': 333, + 'backslash': 278, + 'bracketright': 333, + 'asciicircum': 584, + 'underscore': 556, + 'quoteleft': 278, + 'a': 556, + 'b': 611, + 'c': 556, + 'd': 611, + 'e': 556, + 'f': 333, + 'g': 611, + 'h': 611, + 'i': 278, + 'j': 278, + 'k': 556, + 'l': 278, + 'm': 889, + 'n': 611, + 'o': 611, + 'p': 611, + 'q': 611, + 'r': 389, + 's': 556, + 't': 333, + 'u': 611, + 'v': 556, + 'w': 778, + 'x': 556, + 'y': 556, + 'z': 500, + 'braceleft': 389, + 'bar': 280, + 'braceright': 389, + 'asciitilde': 584, + 'exclamdown': 333, + 'cent': 556, + 'sterling': 556, + 'fraction': 167, + 'yen': 556, + 'florin': 556, + 'section': 556, + 'currency': 556, + 'quotesingle': 238, + 'quotedblleft': 500, + 'guillemotleft': 556, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 611, + 'fl': 611, + 'endash': 556, + 'dagger': 556, + 'daggerdbl': 556, + 'periodcentered': 278, + 'paragraph': 556, + 'bullet': 350, + 'quotesinglbase': 278, + 'quotedblbase': 500, + 'quotedblright': 500, + 'guillemotright': 556, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 611, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 1000, + 'ordfeminine': 370, + 'Lslash': 611, + 'Oslash': 778, + 'OE': 1000, + 'ordmasculine': 365, + 'ae': 889, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 611, + 'oe': 944, + 'germandbls': 611, + 'Idieresis': 278, + 'eacute': 556, + 'abreve': 556, + 'uhungarumlaut': 611, + 'ecaron': 556, + 'Ydieresis': 667, + 'divide': 584, + 'Yacute': 667, + 'Acircumflex': 722, + 'aacute': 556, + 'Ucircumflex': 722, + 'yacute': 556, + 'scommaaccent': 556, + 'ecircumflex': 556, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 556, + 'Uacute': 722, + 'uogonek': 611, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 737, + 'Emacron': 667, + 'ccaron': 556, + 'aring': 556, + 'Ncommaaccent': 722, + 'lacute': 278, + 'agrave': 556, + 'Tcommaaccent': 611, + 'Cacute': 722, + 'atilde': 556, + 'Edotaccent': 667, + 'scaron': 556, + 'scedilla': 556, + 'iacute': 278, + 'lozenge': 494, + 'Rcaron': 722, + 'Gcommaaccent': 778, + 'ucircumflex': 611, + 'acircumflex': 556, + 'Amacron': 722, + 'rcaron': 389, + 'ccedilla': 556, + 'Zdotaccent': 611, + 'Thorn': 667, + 'Omacron': 778, + 'Racute': 722, + 'Sacute': 667, + 'dcaron': 743, + 'Umacron': 722, + 'uring': 611, + 'threesuperior': 333, + 'Ograve': 778, + 'Agrave': 722, + 'Abreve': 722, + 'multiply': 584, + 'uacute': 611, + 'Tcaron': 611, + 'partialdiff': 494, + 'ydieresis': 556, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 556, + 'edieresis': 556, + 'cacute': 556, + 'nacute': 611, + 'umacron': 611, + 'Ncaron': 722, + 'Iacute': 278, + 'plusminus': 584, + 'brokenbar': 280, + 'registered': 737, + 'Gbreve': 778, + 'Idotaccent': 278, + 'summation': 600, + 'Egrave': 667, + 'racute': 389, + 'omacron': 611, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 722, + 'lcommaaccent': 278, + 'tcaron': 389, + 'eogonek': 556, + 'Uogonek': 722, + 'Aacute': 722, + 'Adieresis': 722, + 'egrave': 556, + 'zacute': 500, + 'iogonek': 278, + 'Oacute': 778, + 'oacute': 611, + 'amacron': 556, + 'sacute': 556, + 'idieresis': 278, + 'Ocircumflex': 778, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 611, + 'twosuperior': 333, + 'Odieresis': 778, + 'mu': 611, + 'igrave': 278, + 'ohungarumlaut': 611, + 'Eogonek': 667, + 'dcroat': 611, + 'threequarters': 834, + 'Scedilla': 667, + 'lcaron': 400, + 'Kcommaaccent': 722, + 'Lacute': 611, + 'trademark': 1000, + 'edotaccent': 556, + 'Igrave': 278, + 'Imacron': 278, + 'Lcaron': 611, + 'onehalf': 834, + 'lessequal': 549, + 'ocircumflex': 611, + 'ntilde': 611, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 556, + 'gbreve': 611, + 'onequarter': 834, + 'Scaron': 667, + 'Scommaaccent': 667, + 'Ohungarumlaut': 778, + 'degree': 400, + 'ograve': 611, + 'Ccaron': 722, + 'ugrave': 611, + 'radical': 549, + 'Dcaron': 722, + 'rcommaaccent': 389, + 'Ntilde': 722, + 'otilde': 611, + 'Rcommaaccent': 722, + 'Lcommaaccent': 611, + 'Atilde': 722, + 'Aogonek': 722, + 'Aring': 722, + 'Otilde': 778, + 'zdotaccent': 500, + 'Ecaron': 667, + 'Iogonek': 278, + 'kcommaaccent': 556, + 'minus': 584, + 'Icircumflex': 278, + 'ncaron': 611, + 'tcommaaccent': 333, + 'logicalnot': 584, + 'odieresis': 611, + 'udieresis': 611, + 'notequal': 549, + 'gcommaaccent': 611, + 'eth': 611, + 'zcaron': 500, + 'ncommaaccent': 611, + 'onesuperior': 333, + 'imacron': 278, + 'Euro': 556 + }, + 'Helvetica-Oblique' : { + 'space': 278, + 'exclam': 278, + 'quotedbl': 355, + 'numbersign': 556, + 'dollar': 556, + 'percent': 889, + 'ampersand': 667, + 'quoteright': 222, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 389, + 'plus': 584, + 'comma': 278, + 'hyphen': 333, + 'period': 278, + 'slash': 278, + 'zero': 556, + 'one': 556, + 'two': 556, + 'three': 556, + 'four': 556, + 'five': 556, + 'six': 556, + 'seven': 556, + 'eight': 556, + 'nine': 556, + 'colon': 278, + 'semicolon': 278, + 'less': 584, + 'equal': 584, + 'greater': 584, + 'question': 556, + 'at': 1015, + 'A': 667, + 'B': 667, + 'C': 722, + 'D': 722, + 'E': 667, + 'F': 611, + 'G': 778, + 'H': 722, + 'I': 278, + 'J': 500, + 'K': 667, + 'L': 556, + 'M': 833, + 'N': 722, + 'O': 778, + 'P': 667, + 'Q': 778, + 'R': 722, + 'S': 667, + 'T': 611, + 'U': 722, + 'V': 667, + 'W': 944, + 'X': 667, + 'Y': 667, + 'Z': 611, + 'bracketleft': 278, + 'backslash': 278, + 'bracketright': 278, + 'asciicircum': 469, + 'underscore': 556, + 'quoteleft': 222, + 'a': 556, + 'b': 556, + 'c': 500, + 'd': 556, + 'e': 556, + 'f': 278, + 'g': 556, + 'h': 556, + 'i': 222, + 'j': 222, + 'k': 500, + 'l': 222, + 'm': 833, + 'n': 556, + 'o': 556, + 'p': 556, + 'q': 556, + 'r': 333, + 's': 500, + 't': 278, + 'u': 556, + 'v': 500, + 'w': 722, + 'x': 500, + 'y': 500, + 'z': 500, + 'braceleft': 334, + 'bar': 260, + 'braceright': 334, + 'asciitilde': 584, + 'exclamdown': 333, + 'cent': 556, + 'sterling': 556, + 'fraction': 167, + 'yen': 556, + 'florin': 556, + 'section': 556, + 'currency': 556, + 'quotesingle': 191, + 'quotedblleft': 333, + 'guillemotleft': 556, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 500, + 'fl': 500, + 'endash': 556, + 'dagger': 556, + 'daggerdbl': 556, + 'periodcentered': 278, + 'paragraph': 537, + 'bullet': 350, + 'quotesinglbase': 222, + 'quotedblbase': 333, + 'quotedblright': 333, + 'guillemotright': 556, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 611, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 1000, + 'ordfeminine': 370, + 'Lslash': 556, + 'Oslash': 778, + 'OE': 1000, + 'ordmasculine': 365, + 'ae': 889, + 'dotlessi': 278, + 'lslash': 222, + 'oslash': 611, + 'oe': 944, + 'germandbls': 611, + 'Idieresis': 278, + 'eacute': 556, + 'abreve': 556, + 'uhungarumlaut': 556, + 'ecaron': 556, + 'Ydieresis': 667, + 'divide': 584, + 'Yacute': 667, + 'Acircumflex': 667, + 'aacute': 556, + 'Ucircumflex': 722, + 'yacute': 500, + 'scommaaccent': 500, + 'ecircumflex': 556, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 556, + 'Uacute': 722, + 'uogonek': 556, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 737, + 'Emacron': 667, + 'ccaron': 500, + 'aring': 556, + 'Ncommaaccent': 722, + 'lacute': 222, + 'agrave': 556, + 'Tcommaaccent': 611, + 'Cacute': 722, + 'atilde': 556, + 'Edotaccent': 667, + 'scaron': 500, + 'scedilla': 500, + 'iacute': 278, + 'lozenge': 471, + 'Rcaron': 722, + 'Gcommaaccent': 778, + 'ucircumflex': 556, + 'acircumflex': 556, + 'Amacron': 667, + 'rcaron': 333, + 'ccedilla': 500, + 'Zdotaccent': 611, + 'Thorn': 667, + 'Omacron': 778, + 'Racute': 722, + 'Sacute': 667, + 'dcaron': 643, + 'Umacron': 722, + 'uring': 556, + 'threesuperior': 333, + 'Ograve': 778, + 'Agrave': 667, + 'Abreve': 667, + 'multiply': 584, + 'uacute': 556, + 'Tcaron': 611, + 'partialdiff': 476, + 'ydieresis': 500, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 556, + 'edieresis': 556, + 'cacute': 500, + 'nacute': 556, + 'umacron': 556, + 'Ncaron': 722, + 'Iacute': 278, + 'plusminus': 584, + 'brokenbar': 260, + 'registered': 737, + 'Gbreve': 778, + 'Idotaccent': 278, + 'summation': 600, + 'Egrave': 667, + 'racute': 333, + 'omacron': 556, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 722, + 'lcommaaccent': 222, + 'tcaron': 317, + 'eogonek': 556, + 'Uogonek': 722, + 'Aacute': 667, + 'Adieresis': 667, + 'egrave': 556, + 'zacute': 500, + 'iogonek': 222, + 'Oacute': 778, + 'oacute': 556, + 'amacron': 556, + 'sacute': 500, + 'idieresis': 278, + 'Ocircumflex': 778, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 556, + 'twosuperior': 333, + 'Odieresis': 778, + 'mu': 556, + 'igrave': 278, + 'ohungarumlaut': 556, + 'Eogonek': 667, + 'dcroat': 556, + 'threequarters': 834, + 'Scedilla': 667, + 'lcaron': 299, + 'Kcommaaccent': 667, + 'Lacute': 556, + 'trademark': 1000, + 'edotaccent': 556, + 'Igrave': 278, + 'Imacron': 278, + 'Lcaron': 556, + 'onehalf': 834, + 'lessequal': 549, + 'ocircumflex': 556, + 'ntilde': 556, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 556, + 'gbreve': 556, + 'onequarter': 834, + 'Scaron': 667, + 'Scommaaccent': 667, + 'Ohungarumlaut': 778, + 'degree': 400, + 'ograve': 556, + 'Ccaron': 722, + 'ugrave': 556, + 'radical': 453, + 'Dcaron': 722, + 'rcommaaccent': 333, + 'Ntilde': 722, + 'otilde': 556, + 'Rcommaaccent': 722, + 'Lcommaaccent': 556, + 'Atilde': 667, + 'Aogonek': 667, + 'Aring': 667, + 'Otilde': 778, + 'zdotaccent': 500, + 'Ecaron': 667, + 'Iogonek': 278, + 'kcommaaccent': 500, + 'minus': 584, + 'Icircumflex': 278, + 'ncaron': 556, + 'tcommaaccent': 278, + 'logicalnot': 584, + 'odieresis': 556, + 'udieresis': 556, + 'notequal': 549, + 'gcommaaccent': 556, + 'eth': 556, + 'zcaron': 500, + 'ncommaaccent': 556, + 'onesuperior': 333, + 'imacron': 278, + 'Euro': 556 + }, + 'Symbol': { + 'space': 250, + 'exclam': 333, + 'universal': 713, + 'numbersign': 500, + 'existential': 549, + 'percent': 833, + 'ampersand': 778, + 'suchthat': 439, + 'parenleft': 333, + 'parenright': 333, + 'asteriskmath': 500, + 'plus': 549, + 'comma': 250, + 'minus': 549, + 'period': 250, + 'slash': 278, + 'zero': 500, + 'one': 500, + 'two': 500, + 'three': 500, + 'four': 500, + 'five': 500, + 'six': 500, + 'seven': 500, + 'eight': 500, + 'nine': 500, + 'colon': 278, + 'semicolon': 278, + 'less': 549, + 'equal': 549, + 'greater': 549, + 'question': 444, + 'congruent': 549, + 'Alpha': 722, + 'Beta': 667, + 'Chi': 722, + 'Delta': 612, + 'Epsilon': 611, + 'Phi': 763, + 'Gamma': 603, + 'Eta': 722, + 'Iota': 333, + 'theta1': 631, + 'Kappa': 722, + 'Lambda': 686, + 'Mu': 889, + 'Nu': 722, + 'Omicron': 722, + 'Pi': 768, + 'Theta': 741, + 'Rho': 556, + 'Sigma': 592, + 'Tau': 611, + 'Upsilon': 690, + 'sigma1': 439, + 'Omega': 768, + 'Xi': 645, + 'Psi': 795, + 'Zeta': 611, + 'bracketleft': 333, + 'therefore': 863, + 'bracketright': 333, + 'perpendicular': 658, + 'underscore': 500, + 'radicalex': 500, + 'alpha': 631, + 'beta': 549, + 'chi': 549, + 'delta': 494, + 'epsilon': 439, + 'phi': 521, + 'gamma': 411, + 'eta': 603, + 'iota': 329, + 'phi1': 603, + 'kappa': 549, + 'lambda': 549, + 'mu': 576, + 'nu': 521, + 'omicron': 549, + 'pi': 549, + 'theta': 521, + 'rho': 549, + 'sigma': 603, + 'tau': 439, + 'upsilon': 576, + 'omega1': 713, + 'omega': 686, + 'xi': 493, + 'psi': 686, + 'zeta': 494, + 'braceleft': 480, + 'bar': 200, + 'braceright': 480, + 'similar': 549, + 'Euro': 750, + 'Upsilon1': 620, + 'minute': 247, + 'lessequal': 549, + 'fraction': 167, + 'infinity': 713, + 'florin': 500, + 'club': 753, + 'diamond': 753, + 'heart': 753, + 'spade': 753, + 'arrowboth': 1042, + 'arrowleft': 987, + 'arrowup': 603, + 'arrowright': 987, + 'arrowdown': 603, + 'degree': 400, + 'plusminus': 549, + 'second': 411, + 'greaterequal': 549, + 'multiply': 549, + 'proportional': 713, + 'partialdiff': 494, + 'bullet': 460, + 'divide': 549, + 'notequal': 549, + 'equivalence': 549, + 'approxequal': 549, + 'ellipsis': 1000, + 'arrowvertex': 603, + 'arrowhorizex': 1000, + 'carriagereturn': 658, + 'aleph': 823, + 'Ifraktur': 686, + 'Rfraktur': 795, + 'weierstrass': 987, + 'circlemultiply': 768, + 'circleplus': 768, + 'emptyset': 823, + 'intersection': 768, + 'union': 768, + 'propersuperset': 713, + 'reflexsuperset': 713, + 'notsubset': 713, + 'propersubset': 713, + 'reflexsubset': 713, + 'element': 713, + 'notelement': 713, + 'angle': 768, + 'gradient': 713, + 'registerserif': 790, + 'copyrightserif': 790, + 'trademarkserif': 890, + 'product': 823, + 'radical': 549, + 'dotmath': 250, + 'logicalnot': 713, + 'logicaland': 603, + 'logicalor': 603, + 'arrowdblboth': 1042, + 'arrowdblleft': 987, + 'arrowdblup': 603, + 'arrowdblright': 987, + 'arrowdbldown': 603, + 'lozenge': 494, + 'angleleft': 329, + 'registersans': 790, + 'copyrightsans': 790, + 'trademarksans': 786, + 'summation': 713, + 'parenlefttp': 384, + 'parenleftex': 384, + 'parenleftbt': 384, + 'bracketlefttp': 384, + 'bracketleftex': 384, + 'bracketleftbt': 384, + 'bracelefttp': 494, + 'braceleftmid': 494, + 'braceleftbt': 494, + 'braceex': 494, + 'angleright': 329, + 'integral': 274, + 'integraltp': 686, + 'integralex': 686, + 'integralbt': 686, + 'parenrighttp': 384, + 'parenrightex': 384, + 'parenrightbt': 384, + 'bracketrighttp': 384, + 'bracketrightex': 384, + 'bracketrightbt': 384, + 'bracerighttp': 494, + 'bracerightmid': 494, + 'bracerightbt': 494, + 'apple': 790 + }, + 'Times-Roman': { + 'space': 250, + 'exclam': 333, + 'quotedbl': 408, + 'numbersign': 500, + 'dollar': 500, + 'percent': 833, + 'ampersand': 778, + 'quoteright': 333, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 500, + 'plus': 564, + 'comma': 250, + 'hyphen': 333, + 'period': 250, + 'slash': 278, + 'zero': 500, + 'one': 500, + 'two': 500, + 'three': 500, + 'four': 500, + 'five': 500, + 'six': 500, + 'seven': 500, + 'eight': 500, + 'nine': 500, + 'colon': 278, + 'semicolon': 278, + 'less': 564, + 'equal': 564, + 'greater': 564, + 'question': 444, + 'at': 921, + 'A': 722, + 'B': 667, + 'C': 667, + 'D': 722, + 'E': 611, + 'F': 556, + 'G': 722, + 'H': 722, + 'I': 333, + 'J': 389, + 'K': 722, + 'L': 611, + 'M': 889, + 'N': 722, + 'O': 722, + 'P': 556, + 'Q': 722, + 'R': 667, + 'S': 556, + 'T': 611, + 'U': 722, + 'V': 722, + 'W': 944, + 'X': 722, + 'Y': 722, + 'Z': 611, + 'bracketleft': 333, + 'backslash': 278, + 'bracketright': 333, + 'asciicircum': 469, + 'underscore': 500, + 'quoteleft': 333, + 'a': 444, + 'b': 500, + 'c': 444, + 'd': 500, + 'e': 444, + 'f': 333, + 'g': 500, + 'h': 500, + 'i': 278, + 'j': 278, + 'k': 500, + 'l': 278, + 'm': 778, + 'n': 500, + 'o': 500, + 'p': 500, + 'q': 500, + 'r': 333, + 's': 389, + 't': 278, + 'u': 500, + 'v': 500, + 'w': 722, + 'x': 500, + 'y': 500, + 'z': 444, + 'braceleft': 480, + 'bar': 200, + 'braceright': 480, + 'asciitilde': 541, + 'exclamdown': 333, + 'cent': 500, + 'sterling': 500, + 'fraction': 167, + 'yen': 500, + 'florin': 500, + 'section': 500, + 'currency': 500, + 'quotesingle': 180, + 'quotedblleft': 444, + 'guillemotleft': 500, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 556, + 'fl': 556, + 'endash': 500, + 'dagger': 500, + 'daggerdbl': 500, + 'periodcentered': 250, + 'paragraph': 453, + 'bullet': 350, + 'quotesinglbase': 333, + 'quotedblbase': 444, + 'quotedblright': 444, + 'guillemotright': 500, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 444, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 889, + 'ordfeminine': 276, + 'Lslash': 611, + 'Oslash': 722, + 'OE': 889, + 'ordmasculine': 310, + 'ae': 667, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 500, + 'oe': 722, + 'germandbls': 500, + 'Idieresis': 333, + 'eacute': 444, + 'abreve': 444, + 'uhungarumlaut': 500, + 'ecaron': 444, + 'Ydieresis': 722, + 'divide': 564, + 'Yacute': 722, + 'Acircumflex': 722, + 'aacute': 444, + 'Ucircumflex': 722, + 'yacute': 500, + 'scommaaccent': 389, + 'ecircumflex': 444, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 444, + 'Uacute': 722, + 'uogonek': 500, + 'Edieresis': 611, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 760, + 'Emacron': 611, + 'ccaron': 444, + 'aring': 444, + 'Ncommaaccent': 722, + 'lacute': 278, + 'agrave': 444, + 'Tcommaaccent': 611, + 'Cacute': 667, + 'atilde': 444, + 'Edotaccent': 611, + 'scaron': 389, + 'scedilla': 389, + 'iacute': 278, + 'lozenge': 471, + 'Rcaron': 667, + 'Gcommaaccent': 722, + 'ucircumflex': 500, + 'acircumflex': 444, + 'Amacron': 722, + 'rcaron': 333, + 'ccedilla': 444, + 'Zdotaccent': 611, + 'Thorn': 556, + 'Omacron': 722, + 'Racute': 667, + 'Sacute': 556, + 'dcaron': 588, + 'Umacron': 722, + 'uring': 500, + 'threesuperior': 300, + 'Ograve': 722, + 'Agrave': 722, + 'Abreve': 722, + 'multiply': 564, + 'uacute': 500, + 'Tcaron': 611, + 'partialdiff': 476, + 'ydieresis': 500, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 611, + 'adieresis': 444, + 'edieresis': 444, + 'cacute': 444, + 'nacute': 500, + 'umacron': 500, + 'Ncaron': 722, + 'Iacute': 333, + 'plusminus': 564, + 'brokenbar': 200, + 'registered': 760, + 'Gbreve': 722, + 'Idotaccent': 333, + 'summation': 600, + 'Egrave': 611, + 'racute': 333, + 'omacron': 500, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 667, + 'lcommaaccent': 278, + 'tcaron': 326, + 'eogonek': 444, + 'Uogonek': 722, + 'Aacute': 722, + 'Adieresis': 722, + 'egrave': 444, + 'zacute': 444, + 'iogonek': 278, + 'Oacute': 722, + 'oacute': 500, + 'amacron': 444, + 'sacute': 389, + 'idieresis': 278, + 'Ocircumflex': 722, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 500, + 'twosuperior': 300, + 'Odieresis': 722, + 'mu': 500, + 'igrave': 278, + 'ohungarumlaut': 500, + 'Eogonek': 611, + 'dcroat': 500, + 'threequarters': 750, + 'Scedilla': 556, + 'lcaron': 344, + 'Kcommaaccent': 722, + 'Lacute': 611, + 'trademark': 980, + 'edotaccent': 444, + 'Igrave': 333, + 'Imacron': 333, + 'Lcaron': 611, + 'onehalf': 750, + 'lessequal': 549, + 'ocircumflex': 500, + 'ntilde': 500, + 'Uhungarumlaut': 722, + 'Eacute': 611, + 'emacron': 444, + 'gbreve': 500, + 'onequarter': 750, + 'Scaron': 556, + 'Scommaaccent': 556, + 'Ohungarumlaut': 722, + 'degree': 400, + 'ograve': 500, + 'Ccaron': 667, + 'ugrave': 500, + 'radical': 453, + 'Dcaron': 722, + 'rcommaaccent': 333, + 'Ntilde': 722, + 'otilde': 500, + 'Rcommaaccent': 667, + 'Lcommaaccent': 611, + 'Atilde': 722, + 'Aogonek': 722, + 'Aring': 722, + 'Otilde': 722, + 'zdotaccent': 444, + 'Ecaron': 611, + 'Iogonek': 333, + 'kcommaaccent': 500, + 'minus': 564, + 'Icircumflex': 333, + 'ncaron': 500, + 'tcommaaccent': 278, + 'logicalnot': 564, + 'odieresis': 500, + 'udieresis': 500, + 'notequal': 549, + 'gcommaaccent': 500, + 'eth': 500, + 'zcaron': 444, + 'ncommaaccent': 500, + 'onesuperior': 300, + 'imacron': 278, + 'Euro': 500 + }, + 'Times-Bold': { + 'space': 250, + 'exclam': 333, + 'quotedbl': 555, + 'numbersign': 500, + 'dollar': 500, + 'percent': 1000, + 'ampersand': 833, + 'quoteright': 333, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 500, + 'plus': 570, + 'comma': 250, + 'hyphen': 333, + 'period': 250, + 'slash': 278, + 'zero': 500, + 'one': 500, + 'two': 500, + 'three': 500, + 'four': 500, + 'five': 500, + 'six': 500, + 'seven': 500, + 'eight': 500, + 'nine': 500, + 'colon': 333, + 'semicolon': 333, + 'less': 570, + 'equal': 570, + 'greater': 570, + 'question': 500, + 'at': 930, + 'A': 722, + 'B': 667, + 'C': 722, + 'D': 722, + 'E': 667, + 'F': 611, + 'G': 778, + 'H': 778, + 'I': 389, + 'J': 500, + 'K': 778, + 'L': 667, + 'M': 944, + 'N': 722, + 'O': 778, + 'P': 611, + 'Q': 778, + 'R': 722, + 'S': 556, + 'T': 667, + 'U': 722, + 'V': 722, + 'W': 1000, + 'X': 722, + 'Y': 722, + 'Z': 667, + 'bracketleft': 333, + 'backslash': 278, + 'bracketright': 333, + 'asciicircum': 581, + 'underscore': 500, + 'quoteleft': 333, + 'a': 500, + 'b': 556, + 'c': 444, + 'd': 556, + 'e': 444, + 'f': 333, + 'g': 500, + 'h': 556, + 'i': 278, + 'j': 333, + 'k': 556, + 'l': 278, + 'm': 833, + 'n': 556, + 'o': 500, + 'p': 556, + 'q': 556, + 'r': 444, + 's': 389, + 't': 333, + 'u': 556, + 'v': 500, + 'w': 722, + 'x': 500, + 'y': 500, + 'z': 444, + 'braceleft': 394, + 'bar': 220, + 'braceright': 394, + 'asciitilde': 520, + 'exclamdown': 333, + 'cent': 500, + 'sterling': 500, + 'fraction': 167, + 'yen': 500, + 'florin': 500, + 'section': 500, + 'currency': 500, + 'quotesingle': 278, + 'quotedblleft': 500, + 'guillemotleft': 500, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 556, + 'fl': 556, + 'endash': 500, + 'dagger': 500, + 'daggerdbl': 500, + 'periodcentered': 250, + 'paragraph': 540, + 'bullet': 350, + 'quotesinglbase': 333, + 'quotedblbase': 500, + 'quotedblright': 500, + 'guillemotright': 500, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 500, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 1000, + 'ordfeminine': 300, + 'Lslash': 667, + 'Oslash': 778, + 'OE': 1000, + 'ordmasculine': 330, + 'ae': 722, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 500, + 'oe': 722, + 'germandbls': 556, + 'Idieresis': 389, + 'eacute': 444, + 'abreve': 500, + 'uhungarumlaut': 556, + 'ecaron': 444, + 'Ydieresis': 722, + 'divide': 570, + 'Yacute': 722, + 'Acircumflex': 722, + 'aacute': 500, + 'Ucircumflex': 722, + 'yacute': 500, + 'scommaaccent': 389, + 'ecircumflex': 444, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 500, + 'Uacute': 722, + 'uogonek': 556, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 747, + 'Emacron': 667, + 'ccaron': 444, + 'aring': 500, + 'Ncommaaccent': 722, + 'lacute': 278, + 'agrave': 500, + 'Tcommaaccent': 667, + 'Cacute': 722, + 'atilde': 500, + 'Edotaccent': 667, + 'scaron': 389, + 'scedilla': 389, + 'iacute': 278, + 'lozenge': 494, + 'Rcaron': 722, + 'Gcommaaccent': 778, + 'ucircumflex': 556, + 'acircumflex': 500, + 'Amacron': 722, + 'rcaron': 444, + 'ccedilla': 444, + 'Zdotaccent': 667, + 'Thorn': 611, + 'Omacron': 778, + 'Racute': 722, + 'Sacute': 556, + 'dcaron': 672, + 'Umacron': 722, + 'uring': 556, + 'threesuperior': 300, + 'Ograve': 778, + 'Agrave': 722, + 'Abreve': 722, + 'multiply': 570, + 'uacute': 556, + 'Tcaron': 667, + 'partialdiff': 494, + 'ydieresis': 500, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 500, + 'edieresis': 444, + 'cacute': 444, + 'nacute': 556, + 'umacron': 556, + 'Ncaron': 722, + 'Iacute': 389, + 'plusminus': 570, + 'brokenbar': 220, + 'registered': 747, + 'Gbreve': 778, + 'Idotaccent': 389, + 'summation': 600, + 'Egrave': 667, + 'racute': 444, + 'omacron': 500, + 'Zacute': 667, + 'Zcaron': 667, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 722, + 'lcommaaccent': 278, + 'tcaron': 416, + 'eogonek': 444, + 'Uogonek': 722, + 'Aacute': 722, + 'Adieresis': 722, + 'egrave': 444, + 'zacute': 444, + 'iogonek': 278, + 'Oacute': 778, + 'oacute': 500, + 'amacron': 500, + 'sacute': 389, + 'idieresis': 278, + 'Ocircumflex': 778, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 556, + 'twosuperior': 300, + 'Odieresis': 778, + 'mu': 556, + 'igrave': 278, + 'ohungarumlaut': 500, + 'Eogonek': 667, + 'dcroat': 556, + 'threequarters': 750, + 'Scedilla': 556, + 'lcaron': 394, + 'Kcommaaccent': 778, + 'Lacute': 667, + 'trademark': 1000, + 'edotaccent': 444, + 'Igrave': 389, + 'Imacron': 389, + 'Lcaron': 667, + 'onehalf': 750, + 'lessequal': 549, + 'ocircumflex': 500, + 'ntilde': 556, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 444, + 'gbreve': 500, + 'onequarter': 750, + 'Scaron': 556, + 'Scommaaccent': 556, + 'Ohungarumlaut': 778, + 'degree': 400, + 'ograve': 500, + 'Ccaron': 722, + 'ugrave': 556, + 'radical': 549, + 'Dcaron': 722, + 'rcommaaccent': 444, + 'Ntilde': 722, + 'otilde': 500, + 'Rcommaaccent': 722, + 'Lcommaaccent': 667, + 'Atilde': 722, + 'Aogonek': 722, + 'Aring': 722, + 'Otilde': 778, + 'zdotaccent': 444, + 'Ecaron': 667, + 'Iogonek': 389, + 'kcommaaccent': 556, + 'minus': 570, + 'Icircumflex': 389, + 'ncaron': 556, + 'tcommaaccent': 333, + 'logicalnot': 570, + 'odieresis': 500, + 'udieresis': 556, + 'notequal': 549, + 'gcommaaccent': 500, + 'eth': 500, + 'zcaron': 444, + 'ncommaaccent': 556, + 'onesuperior': 300, + 'imacron': 278, + 'Euro': 500 + }, + 'Times-BoldItalic': { + 'space': 250, + 'exclam': 389, + 'quotedbl': 555, + 'numbersign': 500, + 'dollar': 500, + 'percent': 833, + 'ampersand': 778, + 'quoteright': 333, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 500, + 'plus': 570, + 'comma': 250, + 'hyphen': 333, + 'period': 250, + 'slash': 278, + 'zero': 500, + 'one': 500, + 'two': 500, + 'three': 500, + 'four': 500, + 'five': 500, + 'six': 500, + 'seven': 500, + 'eight': 500, + 'nine': 500, + 'colon': 333, + 'semicolon': 333, + 'less': 570, + 'equal': 570, + 'greater': 570, + 'question': 500, + 'at': 832, + 'A': 667, + 'B': 667, + 'C': 667, + 'D': 722, + 'E': 667, + 'F': 667, + 'G': 722, + 'H': 778, + 'I': 389, + 'J': 500, + 'K': 667, + 'L': 611, + 'M': 889, + 'N': 722, + 'O': 722, + 'P': 611, + 'Q': 722, + 'R': 667, + 'S': 556, + 'T': 611, + 'U': 722, + 'V': 667, + 'W': 889, + 'X': 667, + 'Y': 611, + 'Z': 611, + 'bracketleft': 333, + 'backslash': 278, + 'bracketright': 333, + 'asciicircum': 570, + 'underscore': 500, + 'quoteleft': 333, + 'a': 500, + 'b': 500, + 'c': 444, + 'd': 500, + 'e': 444, + 'f': 333, + 'g': 500, + 'h': 556, + 'i': 278, + 'j': 278, + 'k': 500, + 'l': 278, + 'm': 778, + 'n': 556, + 'o': 500, + 'p': 500, + 'q': 500, + 'r': 389, + 's': 389, + 't': 278, + 'u': 556, + 'v': 444, + 'w': 667, + 'x': 500, + 'y': 444, + 'z': 389, + 'braceleft': 348, + 'bar': 220, + 'braceright': 348, + 'asciitilde': 570, + 'exclamdown': 389, + 'cent': 500, + 'sterling': 500, + 'fraction': 167, + 'yen': 500, + 'florin': 500, + 'section': 500, + 'currency': 500, + 'quotesingle': 278, + 'quotedblleft': 500, + 'guillemotleft': 500, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 556, + 'fl': 556, + 'endash': 500, + 'dagger': 500, + 'daggerdbl': 500, + 'periodcentered': 250, + 'paragraph': 500, + 'bullet': 350, + 'quotesinglbase': 333, + 'quotedblbase': 500, + 'quotedblright': 500, + 'guillemotright': 500, + 'ellipsis': 1000, + 'perthousand': 1000, + 'questiondown': 500, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 1000, + 'AE': 944, + 'ordfeminine': 266, + 'Lslash': 611, + 'Oslash': 722, + 'OE': 944, + 'ordmasculine': 300, + 'ae': 722, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 500, + 'oe': 722, + 'germandbls': 500, + 'Idieresis': 389, + 'eacute': 444, + 'abreve': 500, + 'uhungarumlaut': 556, + 'ecaron': 444, + 'Ydieresis': 611, + 'divide': 570, + 'Yacute': 611, + 'Acircumflex': 667, + 'aacute': 500, + 'Ucircumflex': 722, + 'yacute': 444, + 'scommaaccent': 389, + 'ecircumflex': 444, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 500, + 'Uacute': 722, + 'uogonek': 556, + 'Edieresis': 667, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 747, + 'Emacron': 667, + 'ccaron': 444, + 'aring': 500, + 'Ncommaaccent': 722, + 'lacute': 278, + 'agrave': 500, + 'Tcommaaccent': 611, + 'Cacute': 667, + 'atilde': 500, + 'Edotaccent': 667, + 'scaron': 389, + 'scedilla': 389, + 'iacute': 278, + 'lozenge': 494, + 'Rcaron': 667, + 'Gcommaaccent': 722, + 'ucircumflex': 556, + 'acircumflex': 500, + 'Amacron': 667, + 'rcaron': 389, + 'ccedilla': 444, + 'Zdotaccent': 611, + 'Thorn': 611, + 'Omacron': 722, + 'Racute': 667, + 'Sacute': 556, + 'dcaron': 608, + 'Umacron': 722, + 'uring': 556, + 'threesuperior': 300, + 'Ograve': 722, + 'Agrave': 667, + 'Abreve': 667, + 'multiply': 570, + 'uacute': 556, + 'Tcaron': 611, + 'partialdiff': 494, + 'ydieresis': 444, + 'Nacute': 722, + 'icircumflex': 278, + 'Ecircumflex': 667, + 'adieresis': 500, + 'edieresis': 444, + 'cacute': 444, + 'nacute': 556, + 'umacron': 556, + 'Ncaron': 722, + 'Iacute': 389, + 'plusminus': 570, + 'brokenbar': 220, + 'registered': 747, + 'Gbreve': 722, + 'Idotaccent': 389, + 'summation': 600, + 'Egrave': 667, + 'racute': 389, + 'omacron': 500, + 'Zacute': 611, + 'Zcaron': 611, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 667, + 'lcommaaccent': 278, + 'tcaron': 366, + 'eogonek': 444, + 'Uogonek': 722, + 'Aacute': 667, + 'Adieresis': 667, + 'egrave': 444, + 'zacute': 389, + 'iogonek': 278, + 'Oacute': 722, + 'oacute': 500, + 'amacron': 500, + 'sacute': 389, + 'idieresis': 278, + 'Ocircumflex': 722, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 500, + 'twosuperior': 300, + 'Odieresis': 722, + 'mu': 576, + 'igrave': 278, + 'ohungarumlaut': 500, + 'Eogonek': 667, + 'dcroat': 500, + 'threequarters': 750, + 'Scedilla': 556, + 'lcaron': 382, + 'Kcommaaccent': 667, + 'Lacute': 611, + 'trademark': 1000, + 'edotaccent': 444, + 'Igrave': 389, + 'Imacron': 389, + 'Lcaron': 611, + 'onehalf': 750, + 'lessequal': 549, + 'ocircumflex': 500, + 'ntilde': 556, + 'Uhungarumlaut': 722, + 'Eacute': 667, + 'emacron': 444, + 'gbreve': 500, + 'onequarter': 750, + 'Scaron': 556, + 'Scommaaccent': 556, + 'Ohungarumlaut': 722, + 'degree': 400, + 'ograve': 500, + 'Ccaron': 667, + 'ugrave': 556, + 'radical': 549, + 'Dcaron': 722, + 'rcommaaccent': 389, + 'Ntilde': 722, + 'otilde': 500, + 'Rcommaaccent': 667, + 'Lcommaaccent': 611, + 'Atilde': 667, + 'Aogonek': 667, + 'Aring': 667, + 'Otilde': 722, + 'zdotaccent': 389, + 'Ecaron': 667, + 'Iogonek': 389, + 'kcommaaccent': 500, + 'minus': 606, + 'Icircumflex': 389, + 'ncaron': 556, + 'tcommaaccent': 278, + 'logicalnot': 606, + 'odieresis': 500, + 'udieresis': 556, + 'notequal': 549, + 'gcommaaccent': 500, + 'eth': 500, + 'zcaron': 389, + 'ncommaaccent': 556, + 'onesuperior': 300, + 'imacron': 278, + 'Euro': 500 + }, + 'Times-Italic': { + 'space': 250, + 'exclam': 333, + 'quotedbl': 420, + 'numbersign': 500, + 'dollar': 500, + 'percent': 833, + 'ampersand': 778, + 'quoteright': 333, + 'parenleft': 333, + 'parenright': 333, + 'asterisk': 500, + 'plus': 675, + 'comma': 250, + 'hyphen': 333, + 'period': 250, + 'slash': 278, + 'zero': 500, + 'one': 500, + 'two': 500, + 'three': 500, + 'four': 500, + 'five': 500, + 'six': 500, + 'seven': 500, + 'eight': 500, + 'nine': 500, + 'colon': 333, + 'semicolon': 333, + 'less': 675, + 'equal': 675, + 'greater': 675, + 'question': 500, + 'at': 920, + 'A': 611, + 'B': 611, + 'C': 667, + 'D': 722, + 'E': 611, + 'F': 611, + 'G': 722, + 'H': 722, + 'I': 333, + 'J': 444, + 'K': 667, + 'L': 556, + 'M': 833, + 'N': 667, + 'O': 722, + 'P': 611, + 'Q': 722, + 'R': 611, + 'S': 500, + 'T': 556, + 'U': 722, + 'V': 611, + 'W': 833, + 'X': 611, + 'Y': 556, + 'Z': 556, + 'bracketleft': 389, + 'backslash': 278, + 'bracketright': 389, + 'asciicircum': 422, + 'underscore': 500, + 'quoteleft': 333, + 'a': 500, + 'b': 500, + 'c': 444, + 'd': 500, + 'e': 444, + 'f': 278, + 'g': 500, + 'h': 500, + 'i': 278, + 'j': 278, + 'k': 444, + 'l': 278, + 'm': 722, + 'n': 500, + 'o': 500, + 'p': 500, + 'q': 500, + 'r': 389, + 's': 389, + 't': 278, + 'u': 500, + 'v': 444, + 'w': 667, + 'x': 444, + 'y': 444, + 'z': 389, + 'braceleft': 400, + 'bar': 275, + 'braceright': 400, + 'asciitilde': 541, + 'exclamdown': 389, + 'cent': 500, + 'sterling': 500, + 'fraction': 167, + 'yen': 500, + 'florin': 500, + 'section': 500, + 'currency': 500, + 'quotesingle': 214, + 'quotedblleft': 556, + 'guillemotleft': 500, + 'guilsinglleft': 333, + 'guilsinglright': 333, + 'fi': 500, + 'fl': 500, + 'endash': 500, + 'dagger': 500, + 'daggerdbl': 500, + 'periodcentered': 250, + 'paragraph': 523, + 'bullet': 350, + 'quotesinglbase': 333, + 'quotedblbase': 556, + 'quotedblright': 556, + 'guillemotright': 500, + 'ellipsis': 889, + 'perthousand': 1000, + 'questiondown': 500, + 'grave': 333, + 'acute': 333, + 'circumflex': 333, + 'tilde': 333, + 'macron': 333, + 'breve': 333, + 'dotaccent': 333, + 'dieresis': 333, + 'ring': 333, + 'cedilla': 333, + 'hungarumlaut': 333, + 'ogonek': 333, + 'caron': 333, + 'emdash': 889, + 'AE': 889, + 'ordfeminine': 276, + 'Lslash': 556, + 'Oslash': 722, + 'OE': 944, + 'ordmasculine': 310, + 'ae': 667, + 'dotlessi': 278, + 'lslash': 278, + 'oslash': 500, + 'oe': 667, + 'germandbls': 500, + 'Idieresis': 333, + 'eacute': 444, + 'abreve': 500, + 'uhungarumlaut': 500, + 'ecaron': 444, + 'Ydieresis': 556, + 'divide': 675, + 'Yacute': 556, + 'Acircumflex': 611, + 'aacute': 500, + 'Ucircumflex': 722, + 'yacute': 444, + 'scommaaccent': 389, + 'ecircumflex': 444, + 'Uring': 722, + 'Udieresis': 722, + 'aogonek': 500, + 'Uacute': 722, + 'uogonek': 500, + 'Edieresis': 611, + 'Dcroat': 722, + 'commaaccent': 250, + 'copyright': 760, + 'Emacron': 611, + 'ccaron': 444, + 'aring': 500, + 'Ncommaaccent': 667, + 'lacute': 278, + 'agrave': 500, + 'Tcommaaccent': 556, + 'Cacute': 667, + 'atilde': 500, + 'Edotaccent': 611, + 'scaron': 389, + 'scedilla': 389, + 'iacute': 278, + 'lozenge': 471, + 'Rcaron': 611, + 'Gcommaaccent': 722, + 'ucircumflex': 500, + 'acircumflex': 500, + 'Amacron': 611, + 'rcaron': 389, + 'ccedilla': 444, + 'Zdotaccent': 556, + 'Thorn': 611, + 'Omacron': 722, + 'Racute': 611, + 'Sacute': 500, + 'dcaron': 544, + 'Umacron': 722, + 'uring': 500, + 'threesuperior': 300, + 'Ograve': 722, + 'Agrave': 611, + 'Abreve': 611, + 'multiply': 675, + 'uacute': 500, + 'Tcaron': 556, + 'partialdiff': 476, + 'ydieresis': 444, + 'Nacute': 667, + 'icircumflex': 278, + 'Ecircumflex': 611, + 'adieresis': 500, + 'edieresis': 444, + 'cacute': 444, + 'nacute': 500, + 'umacron': 500, + 'Ncaron': 667, + 'Iacute': 333, + 'plusminus': 675, + 'brokenbar': 275, + 'registered': 760, + 'Gbreve': 722, + 'Idotaccent': 333, + 'summation': 600, + 'Egrave': 611, + 'racute': 389, + 'omacron': 500, + 'Zacute': 556, + 'Zcaron': 556, + 'greaterequal': 549, + 'Eth': 722, + 'Ccedilla': 667, + 'lcommaaccent': 278, + 'tcaron': 300, + 'eogonek': 444, + 'Uogonek': 722, + 'Aacute': 611, + 'Adieresis': 611, + 'egrave': 444, + 'zacute': 389, + 'iogonek': 278, + 'Oacute': 722, + 'oacute': 500, + 'amacron': 500, + 'sacute': 389, + 'idieresis': 278, + 'Ocircumflex': 722, + 'Ugrave': 722, + 'Delta': 612, + 'thorn': 500, + 'twosuperior': 300, + 'Odieresis': 722, + 'mu': 500, + 'igrave': 278, + 'ohungarumlaut': 500, + 'Eogonek': 611, + 'dcroat': 500, + 'threequarters': 750, + 'Scedilla': 500, + 'lcaron': 300, + 'Kcommaaccent': 667, + 'Lacute': 556, + 'trademark': 980, + 'edotaccent': 444, + 'Igrave': 333, + 'Imacron': 333, + 'Lcaron': 611, + 'onehalf': 750, + 'lessequal': 549, + 'ocircumflex': 500, + 'ntilde': 500, + 'Uhungarumlaut': 722, + 'Eacute': 611, + 'emacron': 444, + 'gbreve': 500, + 'onequarter': 750, + 'Scaron': 500, + 'Scommaaccent': 500, + 'Ohungarumlaut': 722, + 'degree': 400, + 'ograve': 500, + 'Ccaron': 667, + 'ugrave': 500, + 'radical': 453, + 'Dcaron': 722, + 'rcommaaccent': 389, + 'Ntilde': 667, + 'otilde': 500, + 'Rcommaaccent': 611, + 'Lcommaaccent': 556, + 'Atilde': 611, + 'Aogonek': 611, + 'Aring': 611, + 'Otilde': 722, + 'zdotaccent': 389, + 'Ecaron': 611, + 'Iogonek': 333, + 'kcommaaccent': 444, + 'minus': 675, + 'Icircumflex': 333, + 'ncaron': 500, + 'tcommaaccent': 278, + 'logicalnot': 675, + 'odieresis': 500, + 'udieresis': 500, + 'notequal': 549, + 'gcommaaccent': 500, + 'eth': 500, + 'zcaron': 389, + 'ncommaaccent': 500, + 'onesuperior': 300, + 'imacron': 278, + 'Euro': 500 + }, + 'ZapfDingbats': { + 'space': 278, + 'a1': 974, + 'a2': 961, + 'a202': 974, + 'a3': 980, + 'a4': 719, + 'a5': 789, + 'a119': 790, + 'a118': 791, + 'a117': 690, + 'a11': 960, + 'a12': 939, + 'a13': 549, + 'a14': 855, + 'a15': 911, + 'a16': 933, + 'a105': 911, + 'a17': 945, + 'a18': 974, + 'a19': 755, + 'a20': 846, + 'a21': 762, + 'a22': 761, + 'a23': 571, + 'a24': 677, + 'a25': 763, + 'a26': 760, + 'a27': 759, + 'a28': 754, + 'a6': 494, + 'a7': 552, + 'a8': 537, + 'a9': 577, + 'a10': 692, + 'a29': 786, + 'a30': 788, + 'a31': 788, + 'a32': 790, + 'a33': 793, + 'a34': 794, + 'a35': 816, + 'a36': 823, + 'a37': 789, + 'a38': 841, + 'a39': 823, + 'a40': 833, + 'a41': 816, + 'a42': 831, + 'a43': 923, + 'a44': 744, + 'a45': 723, + 'a46': 749, + 'a47': 790, + 'a48': 792, + 'a49': 695, + 'a50': 776, + 'a51': 768, + 'a52': 792, + 'a53': 759, + 'a54': 707, + 'a55': 708, + 'a56': 682, + 'a57': 701, + 'a58': 826, + 'a59': 815, + 'a60': 789, + 'a61': 789, + 'a62': 707, + 'a63': 687, + 'a64': 696, + 'a65': 689, + 'a66': 786, + 'a67': 787, + 'a68': 713, + 'a69': 791, + 'a70': 785, + 'a71': 791, + 'a72': 873, + 'a73': 761, + 'a74': 762, + 'a203': 762, + 'a75': 759, + 'a204': 759, + 'a76': 892, + 'a77': 892, + 'a78': 788, + 'a79': 784, + 'a81': 438, + 'a82': 138, + 'a83': 277, + 'a84': 415, + 'a97': 392, + 'a98': 392, + 'a99': 668, + 'a100': 668, + 'a89': 390, + 'a90': 390, + 'a93': 317, + 'a94': 317, + 'a91': 276, + 'a92': 276, + 'a205': 509, + 'a85': 509, + 'a206': 410, + 'a86': 410, + 'a87': 234, + 'a88': 234, + 'a95': 334, + 'a96': 334, + 'a101': 732, + 'a102': 544, + 'a103': 544, + 'a104': 910, + 'a106': 667, + 'a107': 760, + 'a108': 760, + 'a112': 776, + 'a111': 595, + 'a110': 694, + 'a109': 626, + 'a120': 788, + 'a121': 788, + 'a122': 788, + 'a123': 788, + 'a124': 788, + 'a125': 788, + 'a126': 788, + 'a127': 788, + 'a128': 788, + 'a129': 788, + 'a130': 788, + 'a131': 788, + 'a132': 788, + 'a133': 788, + 'a134': 788, + 'a135': 788, + 'a136': 788, + 'a137': 788, + 'a138': 788, + 'a139': 788, + 'a140': 788, + 'a141': 788, + 'a142': 788, + 'a143': 788, + 'a144': 788, + 'a145': 788, + 'a146': 788, + 'a147': 788, + 'a148': 788, + 'a149': 788, + 'a150': 788, + 'a151': 788, + 'a152': 788, + 'a153': 788, + 'a154': 788, + 'a155': 788, + 'a156': 788, + 'a157': 788, + 'a158': 788, + 'a159': 788, + 'a160': 894, + 'a161': 838, + 'a163': 1016, + 'a164': 458, + 'a196': 748, + 'a165': 924, + 'a192': 748, + 'a166': 918, + 'a167': 927, + 'a168': 928, + 'a169': 928, + 'a170': 834, + 'a171': 873, + 'a172': 828, + 'a173': 924, + 'a162': 924, + 'a174': 917, + 'a175': 930, + 'a176': 931, + 'a177': 463, + 'a178': 883, + 'a179': 836, + 'a193': 836, + 'a180': 867, + 'a199': 867, + 'a181': 696, + 'a200': 696, + 'a182': 874, + 'a201': 874, + 'a183': 760, + 'a184': 946, + 'a197': 771, + 'a185': 865, + 'a194': 771, + 'a198': 888, + 'a186': 967, + 'a195': 888, + 'a187': 831, + 'a188': 873, + 'a189': 927, + 'a190': 970, + 'a191': 918 + } +}; + +exports.Metrics = Metrics; +})); + + + + +var NetworkManager = (function NetworkManagerClosure() { + + 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 = {}; + this.loadedRequests = {}; + } + + 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(); + // Firefox 37- required .open() to be called before setting responseType. + // https://bugzilla.mozilla.org/show_bug.cgi?id=707484 + // Even though the URL is not visited, .open() could fail if the URL is + // blocked, e.g. via the connect-src CSP directive or the NoScript addon. + // When this error occurs, this feature detection method will mistakenly + // report that moz-chunked-arraybuffer is not supported in Firefox 37-. + x.open('GET', 'https://example.com'); + 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) { + // Maybe abortRequest was called... + 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) { + // Maybe abortRequest was called... + 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)) { + // The XHR request might have been aborted in onHeadersReceived() + // callback, in which case we should abort request + return; + } + + delete this.pendingRequests[xhrId]; + + // success status == 0 can be on ftp, file and other protocols + if (xhr.status === 0 && this.isHttp) { + if (pendingRequest.onError) { + pendingRequest.onError(xhr.status); + } + return; + } + var xhrStatus = xhr.status || OK_RESPONSE; + + // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2: + // "A server MAY ignore the Range header". This means it's possible to + // get a 200 rather than a 206 response from a range request. + 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(); + } + }; + + return NetworkManager; +})(); + +(function (root, factory) { + { + factory((root.pdfjsCoreNetwork = {})); + } +}(this, function (exports) { + exports.NetworkManager = NetworkManager; +})); + + +(function (root, factory) { + { + factory((root.pdfjsSharedGlobal = {})); + } +}(this, function (exports) { + + var globalScope = (typeof window !== 'undefined') ? window : + (typeof global !== 'undefined') ? global : + (typeof self !== 'undefined') ? self : this; + + var isWorker = (typeof window === 'undefined'); + + // The global PDFJS object exposes the API + // In production, it will be declared outside a global wrapper + // In development, it will be declared here + if (!globalScope.PDFJS) { + globalScope.PDFJS = {}; + } + + if (typeof pdfjsVersion !== 'undefined') { + globalScope.PDFJS.version = pdfjsVersion; + } + if (typeof pdfjsVersion !== 'undefined') { + globalScope.PDFJS.build = pdfjsBuild; + } + + globalScope.PDFJS.pdfBug = false; + + exports.globalScope = globalScope; + exports.isWorker = isWorker; + exports.PDFJS = globalScope.PDFJS; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreBidi = {}), root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedGlobal) { + +var PDFJS = sharedGlobal.PDFJS; + +var bidi = PDFJS.bidi = (function bidiClosure() { + // Character types for symbols from 0000 to 00FF. + var baseTypes = [ + 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'S', 'B', 'S', 'WS', + 'B', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', + 'BN', 'BN', 'B', 'B', 'B', 'S', 'WS', 'ON', 'ON', 'ET', 'ET', 'ET', 'ON', + 'ON', 'ON', 'ON', 'ON', 'ON', 'CS', 'ON', 'CS', 'ON', 'EN', 'EN', 'EN', + 'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'ON', 'ON', 'ON', 'ON', 'ON', + 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'ON', 'ON', + 'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'ON', 'ON', 'ON', 'ON', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'B', 'BN', + 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', + 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', + 'BN', 'CS', 'ON', 'ET', 'ET', 'ET', 'ET', 'ON', 'ON', 'ON', 'ON', 'L', 'ON', + 'ON', 'ON', 'ON', 'ON', 'ET', 'ET', 'EN', 'EN', 'ON', 'L', 'ON', 'ON', 'ON', + 'EN', 'L', 'ON', 'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', + 'L', 'L', 'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L' + ]; + + // Character types for symbols from 0600 to 06FF + var arabicTypes = [ + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'CS', 'AL', 'ON', 'ON', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', + 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', + 'AN', 'ET', 'AN', 'AN', 'AL', 'AL', 'AL', 'NSM', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', + 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'ON', 'NSM', + 'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', + 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL' + ]; + + function isOdd(i) { + return (i & 1) !== 0; + } + + function isEven(i) { + return (i & 1) === 0; + } + + function findUnequal(arr, start, value) { + for (var j = start, jj = arr.length; j < jj; ++j) { + if (arr[j] !== value) { + return j; + } + } + return j; + } + + function setValues(arr, start, end, value) { + for (var j = start; j < end; ++j) { + arr[j] = value; + } + } + + function reverseValues(arr, start, end) { + for (var i = start, j = end - 1; i < j; ++i, --j) { + var temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + } + + function createBidiText(str, isLTR, vertical) { + return { + str: str, + dir: (vertical ? 'ttb' : (isLTR ? 'ltr' : 'rtl')) + }; + } + + // These are used in bidi(), which is called frequently. We re-use them on + // each call to avoid unnecessary allocations. + var chars = []; + var types = []; + + function bidi(str, startLevel, vertical) { + var isLTR = true; + var strLength = str.length; + if (strLength === 0 || vertical) { + return createBidiText(str, isLTR, vertical); + } + + // Get types and fill arrays + chars.length = strLength; + types.length = strLength; + var numBidi = 0; + + var i, ii; + for (i = 0; i < strLength; ++i) { + chars[i] = str.charAt(i); + + var charCode = str.charCodeAt(i); + var charType = 'L'; + if (charCode <= 0x00ff) { + charType = baseTypes[charCode]; + } else if (0x0590 <= charCode && charCode <= 0x05f4) { + charType = 'R'; + } else if (0x0600 <= charCode && charCode <= 0x06ff) { + charType = arabicTypes[charCode & 0xff]; + } else if (0x0700 <= charCode && charCode <= 0x08AC) { + charType = 'AL'; + } + if (charType === 'R' || charType === 'AL' || charType === 'AN') { + numBidi++; + } + types[i] = charType; + } + + // Detect the bidi method + // - If there are no rtl characters then no bidi needed + // - If less than 30% chars are rtl then string is primarily ltr + // - If more than 30% chars are rtl then string is primarily rtl + if (numBidi === 0) { + isLTR = true; + return createBidiText(str, isLTR); + } + + if (startLevel === -1) { + if ((strLength / numBidi) < 0.3) { + isLTR = true; + startLevel = 0; + } else { + isLTR = false; + startLevel = 1; + } + } + + var levels = []; + for (i = 0; i < strLength; ++i) { + levels[i] = startLevel; + } + + /* + X1-X10: skip most of this, since we are NOT doing the embeddings. + */ + var e = (isOdd(startLevel) ? 'R' : 'L'); + var sor = e; + var eor = sor; + + /* + W1. Examine each non-spacing mark (NSM) in the level run, and change the + type of the NSM to the type of the previous character. If the NSM is at the + start of the level run, it will get the type of sor. + */ + var lastType = sor; + for (i = 0; i < strLength; ++i) { + if (types[i] === 'NSM') { + types[i] = lastType; + } else { + lastType = types[i]; + } + } + + /* + W2. Search backwards from each instance of a European number until the + first strong type (R, L, AL, or sor) is found. If an AL is found, change + the type of the European number to Arabic number. + */ + lastType = sor; + var t; + for (i = 0; i < strLength; ++i) { + t = types[i]; + if (t === 'EN') { + types[i] = (lastType === 'AL') ? 'AN' : 'EN'; + } else if (t === 'R' || t === 'L' || t === 'AL') { + lastType = t; + } + } + + /* + W3. Change all ALs to R. + */ + for (i = 0; i < strLength; ++i) { + t = types[i]; + if (t === 'AL') { + types[i] = 'R'; + } + } + + /* + W4. A single European separator between two European numbers changes to a + European number. A single common separator between two numbers of the same + type changes to that type: + */ + for (i = 1; i < strLength - 1; ++i) { + if (types[i] === 'ES' && types[i - 1] === 'EN' && types[i + 1] === 'EN') { + types[i] = 'EN'; + } + if (types[i] === 'CS' && + (types[i - 1] === 'EN' || types[i - 1] === 'AN') && + types[i + 1] === types[i - 1]) { + types[i] = types[i - 1]; + } + } + + /* + W5. A sequence of European terminators adjacent to European numbers changes + to all European numbers: + */ + for (i = 0; i < strLength; ++i) { + if (types[i] === 'EN') { + // do before + var j; + for (j = i - 1; j >= 0; --j) { + if (types[j] !== 'ET') { + break; + } + types[j] = 'EN'; + } + // do after + for (j = i + 1; j < strLength; --j) { + if (types[j] !== 'ET') { + break; + } + types[j] = 'EN'; + } + } + } + + /* + W6. Otherwise, separators and terminators change to Other Neutral: + */ + for (i = 0; i < strLength; ++i) { + t = types[i]; + if (t === 'WS' || t === 'ES' || t === 'ET' || t === 'CS') { + types[i] = 'ON'; + } + } + + /* + W7. Search backwards from each instance of a European number until the + first strong type (R, L, or sor) is found. If an L is found, then change + the type of the European number to L. + */ + lastType = sor; + for (i = 0; i < strLength; ++i) { + t = types[i]; + if (t === 'EN') { + types[i] = ((lastType === 'L') ? 'L' : 'EN'); + } else if (t === 'R' || t === 'L') { + lastType = t; + } + } + + /* + N1. A sequence of neutrals takes the direction of the surrounding strong + text if the text on both sides has the same direction. European and Arabic + numbers are treated as though they were R. Start-of-level-run (sor) and + end-of-level-run (eor) are used at level run boundaries. + */ + for (i = 0; i < strLength; ++i) { + if (types[i] === 'ON') { + var end = findUnequal(types, i + 1, 'ON'); + var before = sor; + if (i > 0) { + before = types[i - 1]; + } + + var after = eor; + if (end + 1 < strLength) { + after = types[end + 1]; + } + if (before !== 'L') { + before = 'R'; + } + if (after !== 'L') { + after = 'R'; + } + if (before === after) { + setValues(types, i, end, before); + } + i = end - 1; // reset to end (-1 so next iteration is ok) + } + } + + /* + N2. Any remaining neutrals take the embedding direction. + */ + for (i = 0; i < strLength; ++i) { + if (types[i] === 'ON') { + types[i] = e; + } + } + + /* + I1. For all characters with an even (left-to-right) embedding direction, + those of type R go up one level and those of type AN or EN go up two + levels. + I2. For all characters with an odd (right-to-left) embedding direction, + those of type L, EN or AN go up one level. + */ + for (i = 0; i < strLength; ++i) { + t = types[i]; + if (isEven(levels[i])) { + if (t === 'R') { + levels[i] += 1; + } else if (t === 'AN' || t === 'EN') { + levels[i] += 2; + } + } else { // isOdd + if (t === 'L' || t === 'AN' || t === 'EN') { + levels[i] += 1; + } + } + } + + /* + L1. On each line, reset the embedding level of the following characters to + the paragraph embedding level: + + segment separators, + paragraph separators, + any sequence of whitespace characters preceding a segment separator or + paragraph separator, and any sequence of white space characters at the end + of the line. + */ + + // don't bother as text is only single line + + /* + L2. From the highest level found in the text to the lowest odd level on + each line, reverse any contiguous sequence of characters that are at that + level or higher. + */ + + // find highest level & lowest odd level + var highestLevel = -1; + var lowestOddLevel = 99; + var level; + for (i = 0, ii = levels.length; i < ii; ++i) { + level = levels[i]; + if (highestLevel < level) { + highestLevel = level; + } + if (lowestOddLevel > level && isOdd(level)) { + lowestOddLevel = level; + } + } + + // now reverse between those limits + for (level = highestLevel; level >= lowestOddLevel; --level) { + // find segments to reverse + var start = -1; + for (i = 0, ii = levels.length; i < ii; ++i) { + if (levels[i] < level) { + if (start >= 0) { + reverseValues(chars, start, i); + start = -1; + } + } else if (start < 0) { + start = i; + } + } + if (start >= 0) { + reverseValues(chars, start, levels.length); + } + } + + /* + L3. Combining marks applied to a right-to-left base character will at this + point precede their base character. If the rendering engine expects them to + follow the base characters in the final display process, then the ordering + of the marks and the base character must be reversed. + */ + + // don't bother for now + + /* + L4. A character that possesses the mirrored property as specified by + Section 4.7, Mirrored, must be depicted by a mirrored glyph if the resolved + directionality of that character is R. + */ + + // don't mirror as characters are already mirrored in the pdf + + // Finally, return string + for (i = 0, ii = chars.length; i < ii; ++i) { + var ch = chars[i]; + if (ch === '<' || ch === '>') { + chars[i] = ''; + } + } + return createBidiText(chars.join(''), isLTR); + } + + return bidi; +})(); + +exports.bidi = bidi; +})); + + +(function (root, factory) { + { + factory((root.pdfjsSharedUtil = {}), root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedGlobal) { + +var PDFJS = sharedGlobal.PDFJS; +var globalScope = sharedGlobal.globalScope; + +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 +}; + +var AnnotationType = { + TEXT: 1, + LINK: 2, + FREETEXT: 3, + LINE: 4, + SQUARE: 5, + CIRCLE: 6, + POLYGON: 7, + POLYLINE: 8, + HIGHLIGHT: 9, + UNDERLINE: 10, + SQUIGGLY: 11, + STRIKEOUT: 12, + STAMP: 13, + CARET: 14, + INK: 15, + POPUP: 16, + FILEATTACHMENT: 17, + SOUND: 18, + MOVIE: 19, + WIDGET: 20, + SCREEN: 21, + PRINTERMARK: 22, + TRAPNET: 23, + WATERMARK: 24, + THREED: 25, + REDACT: 26 +}; + +var AnnotationFlag = { + INVISIBLE: 0x01, + HIDDEN: 0x02, + PRINT: 0x04, + NOZOOM: 0x08, + NOROTATE: 0x10, + NOVIEW: 0x20, + READONLY: 0x40, + LOCKED: 0x80, + TOGGLENOVIEW: 0x100, + LOCKEDCONTENTS: 0x200 +}; + +var AnnotationBorderStyleType = { + SOLID: 1, + DASHED: 2, + BEVELED: 3, + INSET: 4, + UNDERLINE: 5 +}; + +var StreamType = { + UNKNOWN: 0, + FLATE: 1, + LZW: 2, + DCT: 3, + JPX: 4, + JBIG: 5, + A85: 6, + AHX: 7, + CCF: 8, + RL: 9 +}; + +var FontType = { + UNKNOWN: 0, + TYPE1: 1, + TYPE1C: 2, + CIDFONTTYPE0: 3, + CIDFONTTYPE0C: 4, + TRUETYPE: 5, + CIDFONTTYPE2: 6, + TYPE3: 7, + OPENTYPE: 8, + TYPE0: 9, + MMTYPE1: 10 +}; + +PDFJS.VERBOSITY_LEVELS = { + errors: 0, + warnings: 1, + infos: 5 +}; + +// All the possible operations for an operator list. +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, + constructPath: 91 +}; + +// A notice for devs. These are good for things that are helpful to devs, such +// as warning that Workers were disabled, which is important to devs but not +// end users. +function info(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) { + console.log('Info: ' + msg); + } +} + +// Non-fatal warnings. +function warn(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) { + console.log('Warning: ' + msg); + } +} + +// Deprecated API function -- treated as warnings. +function deprecated(details) { + warn('Deprecated API usage: ' + details); +} + +// Fatal errors that should trigger the fallback UI and halt execution by +// throwing an exception. +function error(msg) { + if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.errors) { + console.log('Error: ' + msg); + console.log(backtrace()); + } + 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' +}; + +// Combines two URLs. The baseUrl shall be absolute URL. If the url is an +// absolute URL, it will be returned as is. +function combineUrl(baseUrl, url) { + if (!url) { + return baseUrl; + } + return new URL(url, baseUrl).href; +} + +// Validates if URL is safe and allowed, e.g. to avoid XSS. +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': + case 'tel': + return true; + default: + return false; + } +} +PDFJS.isValidUrl = isValidUrl; + +/** + * Adds various attributes (href, title, target, rel) to hyperlinks. + * @param {HTMLLinkElement} link - The link element. + * @param {Object} params - An object with the properties: + * @param {string} params.url - An absolute URL. + */ +function addLinkAttributes(link, params) { + var url = params && params.url; + link.href = link.title = (url ? removeNullCharacters(url) : ''); + + if (url) { + if (isExternalLinkTargetSet()) { + link.target = LinkTargetStringMap[PDFJS.externalLinkTarget]; + } + // Strip referrer from the URL. + link.rel = PDFJS.externalLinkRel; + } +} +PDFJS.addLinkAttributes = addLinkAttributes; + +function shadow(obj, prop, value) { + Object.defineProperty(obj, prop, { value: value, + enumerable: true, + configurable: true, + writable: false }); + return value; +} +PDFJS.shadow = shadow; + +var LinkTarget = PDFJS.LinkTarget = { + NONE: 0, // Default value. + SELF: 1, + BLANK: 2, + PARENT: 3, + TOP: 4, +}; +var LinkTargetStringMap = [ + '', + '_self', + '_blank', + '_parent', + '_top' +]; + +function isExternalLinkTargetSet() { + if (PDFJS.openExternalLinksInNewWindow) { + deprecated('PDFJS.openExternalLinksInNewWindow, please use ' + + '"PDFJS.externalLinkTarget = PDFJS.LinkTarget.BLANK" instead.'); + if (PDFJS.externalLinkTarget === LinkTarget.NONE) { + PDFJS.externalLinkTarget = LinkTarget.BLANK; + } + // Reset the deprecated parameter, to suppress further warnings. + PDFJS.openExternalLinksInNewWindow = false; + } + switch (PDFJS.externalLinkTarget) { + case LinkTarget.NONE: + return false; + case LinkTarget.SELF: + case LinkTarget.BLANK: + case LinkTarget.PARENT: + case LinkTarget.TOP: + return true; + } + warn('PDFJS.externalLinkTarget is invalid: ' + PDFJS.externalLinkTarget); + // Reset the external link target, to suppress further warnings. + PDFJS.externalLinkTarget = LinkTarget.NONE; + return false; +} +PDFJS.isExternalLinkTargetSet = isExternalLinkTargetSet; + +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; +})(); +PDFJS.PasswordException = 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; +})(); +PDFJS.UnknownErrorException = UnknownErrorException; + +var InvalidPDFException = (function InvalidPDFExceptionClosure() { + function InvalidPDFException(msg) { + this.name = 'InvalidPDFException'; + this.message = msg; + } + + InvalidPDFException.prototype = new Error(); + InvalidPDFException.constructor = InvalidPDFException; + + return InvalidPDFException; +})(); +PDFJS.InvalidPDFException = InvalidPDFException; + +var MissingPDFException = (function MissingPDFExceptionClosure() { + function MissingPDFException(msg) { + this.name = 'MissingPDFException'; + this.message = msg; + } + + MissingPDFException.prototype = new Error(); + MissingPDFException.constructor = MissingPDFException; + + return MissingPDFException; +})(); +PDFJS.MissingPDFException = MissingPDFException; + +var UnexpectedResponseException = + (function UnexpectedResponseExceptionClosure() { + function UnexpectedResponseException(msg, status) { + this.name = 'UnexpectedResponseException'; + this.message = msg; + this.status = status; + } + + UnexpectedResponseException.prototype = new Error(); + UnexpectedResponseException.constructor = UnexpectedResponseException; + + return UnexpectedResponseException; +})(); +PDFJS.UnexpectedResponseException = UnexpectedResponseException; + +var NotImplementedException = (function NotImplementedExceptionClosure() { + function NotImplementedException(msg) { + this.message = msg; + } + + NotImplementedException.prototype = new Error(); + NotImplementedException.prototype.name = 'NotImplementedException'; + NotImplementedException.constructor = NotImplementedException; + + return NotImplementedException; +})(); + +var MissingDataException = (function MissingDataExceptionClosure() { + function MissingDataException(begin, end) { + this.begin = begin; + this.end = end; + this.message = 'Missing data [' + begin + ', ' + end + ')'; + } + + MissingDataException.prototype = new Error(); + MissingDataException.prototype.name = 'MissingDataException'; + MissingDataException.constructor = MissingDataException; + + return MissingDataException; +})(); + +var XRefParseException = (function XRefParseExceptionClosure() { + function XRefParseException(msg) { + this.message = msg; + } + + XRefParseException.prototype = new Error(); + XRefParseException.prototype.name = 'XRefParseException'; + XRefParseException.constructor = XRefParseException; + + return XRefParseException; +})(); + +var NullCharactersRegExp = /\x00/g; + +function removeNullCharacters(str) { + if (typeof str !== 'string') { + warn('The argument for removeNullCharacters must be a string.'); + return str; + } + return str.replace(NullCharactersRegExp, ''); +} +PDFJS.removeNullCharacters = removeNullCharacters; + +function bytesToString(bytes) { + assert(bytes !== null && typeof bytes === 'object' && + bytes.length !== undefined, 'Invalid argument for bytesToString'); + var length = bytes.length; + var MAX_ARGUMENT_COUNT = 8192; + if (length < MAX_ARGUMENT_COUNT) { + return String.fromCharCode.apply(null, bytes); + } + var strBuf = []; + for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) { + var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length); + var chunk = bytes.subarray(i, chunkEnd); + strBuf.push(String.fromCharCode.apply(null, chunk)); + } + return strBuf.join(''); +} + +function stringToBytes(str) { + assert(typeof str === 'string', 'Invalid argument for stringToBytes'); + var length = str.length; + var bytes = new Uint8Array(length); + for (var i = 0; i < length; ++i) { + bytes[i] = str.charCodeAt(i) & 0xFF; + } + return bytes; +} + +function 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; +} + +// Lazy test the endianness of the platform +// NOTE: This will be 'true' for simulated TypedArrays +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 userAgent 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; +})(); + +exports.Uint32ArrayView = Uint32ArrayView; + +var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]; + +var Util = PDFJS.Util = (function UtilClosure() { + function Util() {} + + var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')']; + + // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids + // creating many intermediate strings. + Util.makeCssRgb = function Util_makeCssRgb(r, g, b) { + rgbBuf[1] = r; + rgbBuf[3] = g; + rgbBuf[5] = b; + return rgbBuf.join(''); + }; + + // 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; + }; + + var ROMAN_NUMBER_MAP = [ + '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', + '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', + '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX' + ]; + /** + * Converts positive integers to (upper case) Roman numerals. + * @param {integer} number - The number that should be converted. + * @param {boolean} lowerCase - Indicates if the result should be converted + * to lower case letters. The default is false. + * @return {string} The resulting Roman number. + */ + Util.toRoman = function Util_toRoman(number, lowerCase) { + assert(isInt(number) && number > 0, + 'The number should be a positive integer.'); + var pos, romanBuf = []; + // Thousands + while (number >= 1000) { + number -= 1000; + romanBuf.push('M'); + } + // Hundreds + pos = (number / 100) | 0; + number %= 100; + romanBuf.push(ROMAN_NUMBER_MAP[pos]); + // Tens + pos = (number / 10) | 0; + number %= 10; + romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]); + // Ones + romanBuf.push(ROMAN_NUMBER_MAP[20 + number]); + + var romanStr = romanBuf.join(''); + return (lowerCase ? romanStr.toLowerCase() : romanStr); + }; + + Util.appendToArray = function Util_appendToArray(arr1, arr2) { + Array.prototype.push.apply(arr1, arr2); + }; + + Util.prependToArray = function Util_prependToArray(arr1, arr2) { + Array.prototype.unshift.apply(arr1, arr2); + }; + + Util.extendObj = function extendObj(obj1, obj2) { + for (var key in obj2) { + obj1[key] = obj2[key]; + } + }; + + Util.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; +})(); + +/** + * PDF page viewport created based on scale, rotation and offset. + * @class + * @alias PDFJS.PageViewport + */ +var PageViewport = PDFJS.PageViewport = (function PageViewportClosure() { + /** + * @constructor + * @private + * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates. + * @param scale {number} scale of the viewport. + * @param rotation {number} rotations of the viewport in degrees. + * @param offsetX {number} offset X + * @param offsetY {number} offset Y + * @param dontFlip {boolean} if true, axis Y will not be flipped. + */ + 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 = /** @lends PDFJS.PageViewport.prototype */ { + /** + * Clones viewport with additional properties. + * @param args {Object} (optional) If specified, may contain the 'scale' or + * 'rotation' properties to override the corresponding properties in + * the cloned viewport. + * @returns {PDFJS.PageViewport} Cloned viewport. + */ + 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); + }, + /** + * Converts PDF point to the viewport coordinates. For examples, useful for + * converting PDF location into canvas pixel coordinates. + * @param x {number} X coordinate. + * @param y {number} Y coordinate. + * @returns {Object} Object that contains 'x' and 'y' properties of the + * point in the viewport coordinate space. + * @see {@link convertToPdfPoint} + * @see {@link convertToViewportRectangle} + */ + convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) { + return Util.applyTransform([x, y], this.transform); + }, + /** + * Converts PDF rectangle to the viewport coordinates. + * @param rect {Array} xMin, yMin, xMax and yMax coordinates. + * @returns {Array} Contains corresponding coordinates of the rectangle + * in the viewport coordinate space. + * @see {@link convertToViewportPoint} + */ + 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]]; + }, + /** + * Converts viewport coordinates to the PDF location. For examples, useful + * for converting canvas pixel location into PDF one. + * @param x {number} X coordinate. + * @param y {number} Y coordinate. + * @returns {Object} Object that contains 'x' and 'y' properties of the + * point in the PDF coordinate space. + * @see {@link convertToViewportPoint} + */ + 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 utf8StringToString(str) { + return unescape(encodeURIComponent(str)); +} + +function isEmptyObj(obj) { + for (var key in obj) { + return false; + } + return true; +} + +function isBool(v) { + return typeof v === 'boolean'; +} + +function isInt(v) { + return typeof v === 'number' && ((v | 0) === v); +} + +function isNum(v) { + return typeof v === 'number'; +} + +function isString(v) { + return typeof v === 'string'; +} + +function isArray(v) { + return v instanceof Array; +} + +function isArrayBuffer(v) { + return typeof v === 'object' && v !== null && v.byteLength !== undefined; +} + +/** + * Promise Capability object. + * + * @typedef {Object} PromiseCapability + * @property {Promise} promise - A promise object. + * @property {function} resolve - Fullfills the promise. + * @property {function} reject - Rejects the promise. + */ + +/** + * Creates a promise capability object. + * @alias PDFJS.createPromiseCapability + * + * @return {PromiseCapability} A capability object contains: + * - a Promise, resolve and reject methods. + */ +function createPromiseCapability() { + var capability = {}; + capability.promise = new Promise(function (resolve, reject) { + capability.resolve = resolve; + capability.reject = reject; + }); + return capability; +} + +PDFJS.createPromiseCapability = createPromiseCapability; + +/** + * Polyfill for Promises: + * The following promise implementation tries to generally implement the + * Promise/A+ spec. Some notable differences from other promise libaries are: + * - There currently isn't a seperate deferred and promise object. + * - Unhandled rejections eventually show an error if they aren't handled. + * + * Based off of the work in: + * https://bugzilla.mozilla.org/show_bug.cgi?id=810490 + */ +(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) { + 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; + + // In an attempt to avoid silent exceptions, unhandled rejections are + // tracked and if they aren't handled in a certain amount of time an + // error is logged. + 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; // ms + 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() { + if (this.pendingRejectionCheck) { + return; + } + this.pendingRejectionCheck = true; + setTimeout(function rejectionCheck() { + 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; + } + warn(msg); + this.unhandledRejections.splice(i); + i--; + } + } + if (this.unhandledRejections.length) { + this.scheduleRejectionCheck(); + } + }.bind(this), REJECTION_TIMEOUT); + } + }; + + 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); + } + } + /** + * Builds a promise that is resolved when all the passed in promises are + * resolved. + * @param {array} array of data and/or promises to wait for. + * @return {Promise} New dependant promise. + */ + 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; + }; + + /** + * Checks if the value is likely a promise (has a 'then' function). + * @return {boolean} true if value is thenable + */ + Promise.isPromise = function Promise_isPromise(value) { + return value && typeof value.then === 'function'; + }; + + /** + * Creates resolved promise + * @param value resolve value + * @returns {Promise} + */ + Promise.resolve = function Promise_resolve(value) { + return new Promise(function (resolve) { resolve(value); }); + }; + + /** + * Creates rejected promise + * @param reason rejection value + * @returns {Promise} + */ + 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; +})(); + +var StatTimer = (function StatTimerClosure() { + function rpad(str, pad, length) { + while (str.length < length) { + str += pad; + } + return str; + } + function StatTimer() { + this.started = {}; + this.times = []; + this.enabled = true; + } + StatTimer.prototype = { + time: function StatTimer_time(name) { + if (!this.enabled) { + return; + } + if (name in this.started) { + warn('Timer is already running for ' + name); + } + this.started[name] = Date.now(); + }, + timeEnd: function StatTimer_timeEnd(name) { + if (!this.enabled) { + return; + } + if (!(name in this.started)) { + warn('Timer has not been started for ' + name); + } + this.times.push({ + 'name': name, + 'start': this.started[name], + 'end': Date.now() + }); + // Remove timer from started so it can be called again. + delete this.started[name]; + }, + toString: function StatTimer_toString() { + var i, ii; + var times = this.times; + var out = ''; + // Find the longest name for padding purposes. + var longest = 0; + for (i = 0, ii = times.length; i < ii; ++i) { + var name = times[i]['name']; + if (name.length > longest) { + longest = name.length; + } + } + for (i = 0, ii = times.length; i < ii; ++i) { + var span = times[i]; + var duration = span.end - span.start; + out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n'; + } + return out; + } + }; + return StatTimer; +})(); + +PDFJS.createBlob = function createBlob(data, contentType) { + if (typeof Blob !== 'undefined') { + return new Blob([data], { type: contentType }); + } + // Blob builder is deprecated in FF14 and removed in FF18. + var bb = new MozBlobBuilder(); + bb.append(data); + return bb.getBlob(contentType); +}; + +PDFJS.createObjectURL = (function createObjectURLClosure() { + // Blob/createObjectURL is not available, falling back to data schema. + var digits = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; + + return function createObjectURL(data, contentType) { + if (!PDFJS.disableCreateObjectURL && + typeof URL !== 'undefined' && URL.createObjectURL) { + var blob = PDFJS.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 MessageHandler(sourceName, targetName, comObj) { + this.sourceName = sourceName; + this.targetName = targetName; + this.comObj = comObj; + this.callbackIndex = 1; + this.postMessageTransfers = true; + var callbacksCapabilities = this.callbacksCapabilities = {}; + var ah = this.actionHandler = {}; + + this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) { + var data = event.data; + if (data.targetName !== this.sourceName) { + return; + } + 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(data.error); + } else { + callback.resolve(data.data); + } + } else { + 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) { + // Serialize error to avoid "DataCloneError" + reason = reason + ''; + } + comObj.postMessage({ + sourceName: sourceName, + targetName: targetName, + isReply: true, + callbackId: data.callbackId, + error: reason + }); + }); + } else { + action[0].call(action[1], data.data); + } + } else { + error('Unknown action from worker: ' + data.action); + } + }.bind(this); + comObj.addEventListener('message', this._onComObjOnMessage); +} + +MessageHandler.prototype = { + on: function messageHandlerOn(actionName, handler, scope) { + var ah = this.actionHandler; + if (ah[actionName]) { + error('There is already an actionName called "' + actionName + '"'); + } + ah[actionName] = [handler, scope]; + }, + /** + * Sends a message to the comObj to invoke the action with the supplied data. + * @param {String} actionName Action to call. + * @param {JSON} data JSON data to send. + * @param {Array} [transfers] Optional list of transfers/ArrayBuffers + */ + send: function messageHandlerSend(actionName, data, transfers) { + var message = { + sourceName: this.sourceName, + targetName: this.targetName, + action: actionName, + data: data + }; + this.postMessage(message, transfers); + }, + /** + * Sends a message to the comObj to invoke the action with the supplied data. + * Expects that other side will callback with the response. + * @param {String} actionName Action to call. + * @param {JSON} data JSON data to send. + * @param {Array} [transfers] Optional list of transfers/ArrayBuffers. + * @returns {Promise} Promise to be resolved with response data. + */ + sendWithPromise: + function messageHandlerSendWithPromise(actionName, data, transfers) { + var callbackId = this.callbackIndex++; + 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; + }, + /** + * Sends raw message to the comObj. + * @private + * @param message {Object} Raw message. + * @param transfers List of transfers/ArrayBuffers, or undefined. + */ + postMessage: function (message, transfers) { + if (transfers && this.postMessageTransfers) { + this.comObj.postMessage(message, transfers); + } else { + this.comObj.postMessage(message); + } + }, + + destroy: function () { + 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; +} + + // Polyfill from https://github.com/Polymer/URL +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ +(function checkURLConstructor(scope) { + /* jshint ignore:start */ + + // feature detect for URL constructor + 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) + } + // XXX + 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) { + // XXX This actually needs to encode c using encoding and then + // convert the bytes one-by-one. + + var unicode = c.charCodeAt(0); + if (unicode > 0x20 && + unicode < 0x7F && + // " # < > ` (do not escape '?') + [0x22, 0x23, 0x3C, 0x3E, 0x60].indexOf(unicode) == -1 + ) { + return c; + } + return encodeURIComponent(c); + } + + var EOF = undefined, + 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(); // ASCII-safe + 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(); // ASCII-safe + } else if (':' == c) { + this._scheme = buffer; + buffer = ''; + if (stateOverride) { + break loop; + } + if (isRelativeScheme(this._scheme)) { + this._isRelative = true; + } + if ('file' == this._scheme) { + 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 (EOF == c) { + 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 { + // XXX error handling + if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + 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 ('file' != this._scheme) + this._scheme = base._scheme; + if (EOF == c) { + 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 ( + 'file' != this._scheme || !ALPHA.test(c) || + (nextC != ':' && nextC != '|') || + (EOF != nextNextC && '/' != 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 ('file' == this._scheme) { + state = 'file host'; + } else { + state = 'authority ignore slashes'; + } + } else { + if ('file' != this._scheme) { + 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 ('\t' == cp || '\n' == cp || '\r' == cp) { + err('Invalid whitespace in authority.'); + continue; + } + // XXX check URL code points + if (':' == cp && null === this._password) { + this._password = ''; + continue; + } + var tempC = percentEscape(cp); + (null !== this._password) ? this._password += tempC : this._username += tempC; + } + buffer = ''; + } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) { + cursor -= buffer.length; + buffer = ''; + state = 'host'; + continue; + } else { + buffer += c; + } + break; + + case 'file host': + if (EOF == c || '/' == 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 ('\t' == c || '\n' == c || '\r' == c) { + err('Invalid whitespace in file host.'); + } else { + buffer += c; + } + break; + + case 'host': + case 'hostname': + if (':' == c && !seenBracket) { + // XXX host parsing + this._host = IDNAToASCII.call(this, buffer); + buffer = ''; + state = 'port'; + if ('hostname' == stateOverride) { + break loop; + } + } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) { + this._host = IDNAToASCII.call(this, buffer); + buffer = ''; + state = 'relative path start'; + if (stateOverride) { + break loop; + } + continue; + } else if ('\t' != c && '\n' != c && '\r' != c) { + 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 (EOF == c || '/' == 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 ('\t' == c || '\n' == c || '\r' == c) { + 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 (EOF == c || '/' == 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 ('file' == this._scheme && 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 ('\t' != c && '\n' != c && '\r' != c) { + buffer += percentEscape(c); + } + break; + + case 'query': + if (!stateOverride && '#' == c) { + this._fragment = '#'; + state = 'fragment'; + } else if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + this._query += percentEscapeQuery(c); + } + break; + + case 'fragment': + if (EOF != c && '\t' != c && '\n' != c && '\r' != c) { + 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; + } + + // Does not process domain names or IP addresses. + // Does not handle encoding for the query parameter. + function jURL(url, base /* , encoding */) { + 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, ''); + // encoding = encoding || 'utf-8' + + parse.call(this, input, null, base); + } + + jURL.prototype = { + toString: function() { + return this.href; + }, + get href() { + if (this._isInvalid) + return this._url; + + var authority = ''; + if ('' != this._username || null != this._password) { + authority = this._username + + (null != this._password ? ':' + this._password : '') + '@'; + } + + return this.protocol + + (this._isRelative ? '//' + authority + this.host : '') + + this.pathname + this._query + this._fragment; + }, + set href(href) { + clear.call(this); + parse.call(this, href); + }, + + get protocol() { + return this._scheme + ':'; + }, + set protocol(protocol) { + if (this._isInvalid) + return; + parse.call(this, protocol + ':', 'scheme start'); + }, + + get host() { + return this._isInvalid ? '' : this._port ? + this._host + ':' + this._port : this._host; + }, + set host(host) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, host, 'host'); + }, + + get hostname() { + return this._host; + }, + set hostname(hostname) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, hostname, 'hostname'); + }, + + get port() { + return this._port; + }, + set port(port) { + if (this._isInvalid || !this._isRelative) + return; + parse.call(this, port, 'port'); + }, + + get pathname() { + return this._isInvalid ? '' : this._isRelative ? + '/' + this._path.join('/') : this._schemeData; + }, + set pathname(pathname) { + if (this._isInvalid || !this._isRelative) + return; + this._path = []; + parse.call(this, pathname, 'relative path start'); + }, + + get search() { + return this._isInvalid || !this._query || '?' == this._query ? + '' : this._query; + }, + set search(search) { + if (this._isInvalid || !this._isRelative) + return; + this._query = '?'; + if ('?' == search[0]) + search = search.slice(1); + parse.call(this, search, 'query'); + }, + + get hash() { + return this._isInvalid || !this._fragment || '#' == this._fragment ? + '' : this._fragment; + }, + set hash(hash) { + if (this._isInvalid) + return; + this._fragment = '#'; + if ('#' == hash[0]) + hash = hash.slice(1); + parse.call(this, hash, 'fragment'); + }, + + get origin() { + var host; + if (this._isInvalid || !this._scheme) { + return ''; + } + // javascript: Gecko returns String(""), WebKit/Blink String("null") + // Gecko throws error for "data://" + // data: Gecko returns "", Blink returns "data://", WebKit returns "null" + // Gecko returns String("") for file: mailto: + // WebKit/Blink returns String("SCHEME://") for file: mailto: + switch (this._scheme) { + case 'data': + case 'file': + case 'javascript': + case 'mailto': + return 'null'; + } + host = this.host; + if (!host) { + return ''; + } + return this._scheme + '://' + host; + } + }; + + // Copy over the static methods + var OriginalURL = scope.URL; + if (OriginalURL) { + jURL.createObjectURL = function(blob) { + // IE extension allows a second optional options argument. + // http://msdn.microsoft.com/en-us/library/ie/hh772302(v=vs.85).aspx + return OriginalURL.createObjectURL.apply(OriginalURL, arguments); + }; + jURL.revokeObjectURL = function(url) { + OriginalURL.revokeObjectURL(url); + }; + } + + scope.URL = jURL; + /* jshint ignore:end */ +})(globalScope); + +exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX; +exports.IDENTITY_MATRIX = IDENTITY_MATRIX; +exports.OPS = OPS; +exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES; +exports.AnnotationBorderStyleType = AnnotationBorderStyleType; +exports.AnnotationFlag = AnnotationFlag; +exports.AnnotationType = AnnotationType; +exports.FontType = FontType; +exports.ImageKind = ImageKind; +exports.InvalidPDFException = InvalidPDFException; +exports.LinkTarget = LinkTarget; +exports.LinkTargetStringMap = LinkTargetStringMap; +exports.MessageHandler = MessageHandler; +exports.MissingDataException = MissingDataException; +exports.MissingPDFException = MissingPDFException; +exports.NotImplementedException = NotImplementedException; +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.assert = assert; +exports.bytesToString = bytesToString; +exports.combineUrl = combineUrl; +exports.createPromiseCapability = createPromiseCapability; +exports.deprecated = deprecated; +exports.error = error; +exports.info = info; +exports.isArray = isArray; +exports.isArrayBuffer = isArrayBuffer; +exports.isBool = isBool; +exports.isEmptyObj = isEmptyObj; +exports.isExternalLinkTargetSet = isExternalLinkTargetSet; +exports.isInt = isInt; +exports.isNum = isNum; +exports.isString = isString; +exports.isValidUrl = isValidUrl; +exports.addLinkAttributes = addLinkAttributes; +exports.loadJpegStream = loadJpegStream; +exports.log2 = log2; +exports.readInt8 = readInt8; +exports.readUint16 = readUint16; +exports.readUint32 = readUint32; +exports.removeNullCharacters = removeNullCharacters; +exports.shadow = shadow; +exports.string32 = string32; +exports.stringToBytes = stringToBytes; +exports.stringToPDFString = stringToPDFString; +exports.stringToUTF8String = stringToUTF8String; +exports.utf8StringToString = utf8StringToString; +exports.warn = warn; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreChunkedStream = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var MissingDataException = sharedUtil.MissingDataException; +var assert = sharedUtil.assert; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var isInt = sharedUtil.isInt; +var isEmptyObj = sharedUtil.isEmptyObj; + +var ChunkedStream = (function ChunkedStreamClosure() { + function ChunkedStream(length, chunkSize, manager) { + this.bytes = new Uint8Array(length); + this.start = 0; + this.pos = 0; + this.end = length; + this.chunkSize = chunkSize; + this.loadedChunks = []; + this.numChunksLoaded = 0; + this.numChunks = Math.ceil(length / chunkSize); + this.manager = manager; + this.progressiveDataLength = 0; + this.lastSuccessfulEnsureByteChunk = -1; // a single-entry cache + } + + // required methods for a stream. if a particular stream does not + // implement these, an error should be thrown + ChunkedStream.prototype = { + + getMissingChunks: function ChunkedStream_getMissingChunks() { + var chunks = []; + for (var chunk = 0, n = this.numChunks; chunk < n; ++chunk) { + if (!this.loadedChunks[chunk]) { + chunks.push(chunk); + } + } + return chunks; + }, + + getBaseStreams: function ChunkedStream_getBaseStreams() { + return [this]; + }, + + allChunksLoaded: function ChunkedStream_allChunksLoaded() { + return this.numChunksLoaded === this.numChunks; + }, + + onReceiveData: function ChunkedStream_onReceiveData(begin, chunk) { + var end = begin + chunk.byteLength; + + assert(begin % this.chunkSize === 0, 'Bad begin offset: ' + begin); + // Using this.length is inaccurate here since this.start can be moved + // See ChunkedStream.moveStart() + var length = this.bytes.length; + assert(end % this.chunkSize === 0 || end === length, + 'Bad end offset: ' + end); + + this.bytes.set(new Uint8Array(chunk), begin); + var chunkSize = this.chunkSize; + var beginChunk = Math.floor(begin / chunkSize); + var endChunk = Math.floor((end - 1) / chunkSize) + 1; + var curChunk; + + for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) { + if (!this.loadedChunks[curChunk]) { + this.loadedChunks[curChunk] = true; + ++this.numChunksLoaded; + } + } + }, + + onReceiveProgressiveData: + function ChunkedStream_onReceiveProgressiveData(data) { + var position = this.progressiveDataLength; + var beginChunk = Math.floor(position / this.chunkSize); + + this.bytes.set(new Uint8Array(data), position); + position += data.byteLength; + this.progressiveDataLength = position; + var endChunk = position >= this.end ? this.numChunks : + Math.floor(position / this.chunkSize); + var curChunk; + for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) { + if (!this.loadedChunks[curChunk]) { + this.loadedChunks[curChunk] = true; + ++this.numChunksLoaded; + } + } + }, + + ensureByte: function ChunkedStream_ensureByte(pos) { + var chunk = Math.floor(pos / this.chunkSize); + if (chunk === this.lastSuccessfulEnsureByteChunk) { + return; + } + + if (!this.loadedChunks[chunk]) { + throw new MissingDataException(pos, pos + 1); + } + this.lastSuccessfulEnsureByteChunk = chunk; + }, + + ensureRange: function ChunkedStream_ensureRange(begin, end) { + if (begin >= end) { + return; + } + + if (end <= this.progressiveDataLength) { + return; + } + + var chunkSize = this.chunkSize; + var beginChunk = Math.floor(begin / chunkSize); + var endChunk = Math.floor((end - 1) / chunkSize) + 1; + for (var chunk = beginChunk; chunk < endChunk; ++chunk) { + if (!this.loadedChunks[chunk]) { + throw new MissingDataException(begin, end); + } + } + }, + + nextEmptyChunk: function ChunkedStream_nextEmptyChunk(beginChunk) { + var chunk, numChunks = this.numChunks; + for (var i = 0; i < numChunks; ++i) { + chunk = (beginChunk + i) % numChunks; // Wrap around to beginning + if (!this.loadedChunks[chunk]) { + return chunk; + } + } + return null; + }, + + hasChunk: function ChunkedStream_hasChunk(chunk) { + return !!this.loadedChunks[chunk]; + }, + + get length() { + return this.end - this.start; + }, + + get isEmpty() { + return this.length === 0; + }, + + getByte: function ChunkedStream_getByte() { + var pos = this.pos; + if (pos >= this.end) { + return -1; + } + this.ensureByte(pos); + return this.bytes[this.pos++]; + }, + + getUint16: function ChunkedStream_getUint16() { + var b0 = this.getByte(); + var b1 = this.getByte(); + if (b0 === -1 || b1 === -1) { + return -1; + } + return (b0 << 8) + b1; + }, + + getInt32: function ChunkedStream_getInt32() { + var b0 = this.getByte(); + var b1 = this.getByte(); + var b2 = this.getByte(); + var b3 = this.getByte(); + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + }, + + // returns subarray of original buffer + // should only be read + getBytes: function ChunkedStream_getBytes(length) { + var bytes = this.bytes; + var pos = this.pos; + var strEnd = this.end; + + if (!length) { + this.ensureRange(pos, strEnd); + return bytes.subarray(pos, strEnd); + } + + var end = pos + length; + if (end > strEnd) { + end = strEnd; + } + this.ensureRange(pos, end); + + this.pos = end; + return bytes.subarray(pos, end); + }, + + peekByte: function ChunkedStream_peekByte() { + var peekedByte = this.getByte(); + this.pos--; + return peekedByte; + }, + + peekBytes: function ChunkedStream_peekBytes(length) { + var bytes = this.getBytes(length); + this.pos -= bytes.length; + return bytes; + }, + + getByteRange: function ChunkedStream_getBytes(begin, end) { + this.ensureRange(begin, end); + return this.bytes.subarray(begin, end); + }, + + skip: function ChunkedStream_skip(n) { + if (!n) { + n = 1; + } + this.pos += n; + }, + + reset: function ChunkedStream_reset() { + this.pos = this.start; + }, + + moveStart: function ChunkedStream_moveStart() { + this.start = this.pos; + }, + + makeSubStream: function ChunkedStream_makeSubStream(start, length, dict) { + this.ensureRange(start, start + length); + + function ChunkedStreamSubstream() {} + ChunkedStreamSubstream.prototype = Object.create(this); + ChunkedStreamSubstream.prototype.getMissingChunks = function() { + var chunkSize = this.chunkSize; + var beginChunk = Math.floor(this.start / chunkSize); + var endChunk = Math.floor((this.end - 1) / chunkSize) + 1; + var missingChunks = []; + for (var chunk = beginChunk; chunk < endChunk; ++chunk) { + if (!this.loadedChunks[chunk]) { + missingChunks.push(chunk); + } + } + return missingChunks; + }; + var subStream = new ChunkedStreamSubstream(); + subStream.pos = subStream.start = start; + subStream.end = start + length || this.end; + subStream.dict = dict; + return subStream; + }, + + isStream: true + }; + + return ChunkedStream; +})(); + +var ChunkedStreamManager = (function ChunkedStreamManagerClosure() { + + function ChunkedStreamManager(length, chunkSize, url, args) { + this.stream = new ChunkedStream(length, chunkSize, this); + this.length = length; + this.chunkSize = chunkSize; + this.url = url; + this.disableAutoFetch = args.disableAutoFetch; + var msgHandler = this.msgHandler = args.msgHandler; + + if (args.chunkedViewerLoading) { + msgHandler.on('OnDataRange', this.onReceiveData.bind(this)); + msgHandler.on('OnDataProgress', this.onProgress.bind(this)); + this.sendRequest = function ChunkedStreamManager_sendRequest(begin, end) { + msgHandler.send('RequestDataRange', { begin: begin, end: end }); + }; + } else { + + var getXhr = function getXhr() { + return new XMLHttpRequest(); + }; + this.networkManager = new NetworkManager(this.url, { + getXhr: getXhr, + httpHeaders: args.httpHeaders, + withCredentials: args.withCredentials + }); + this.sendRequest = function ChunkedStreamManager_sendRequest(begin, end) { + this.networkManager.requestRange(begin, end, { + onDone: this.onReceiveData.bind(this), + onProgress: this.onProgress.bind(this) + }); + }; + } + + this.currRequestId = 0; + + this.chunksNeededByRequest = {}; + this.requestsByChunk = {}; + this.promisesByRequest = {}; + this.progressiveDataLength = 0; + + this._loadedStreamCapability = createPromiseCapability(); + + if (args.initialData) { + this.onReceiveData({chunk: args.initialData}); + } + } + + ChunkedStreamManager.prototype = { + onLoadedStream: function ChunkedStreamManager_getLoadedStream() { + return this._loadedStreamCapability.promise; + }, + + // Get all the chunks that are not yet loaded and groups them into + // contiguous ranges to load in as few requests as possible + requestAllChunks: function ChunkedStreamManager_requestAllChunks() { + var missingChunks = this.stream.getMissingChunks(); + this._requestChunks(missingChunks); + return this._loadedStreamCapability.promise; + }, + + _requestChunks: function ChunkedStreamManager_requestChunks(chunks) { + var requestId = this.currRequestId++; + + var chunksNeeded; + var i, ii; + this.chunksNeededByRequest[requestId] = chunksNeeded = {}; + for (i = 0, ii = chunks.length; i < ii; i++) { + if (!this.stream.hasChunk(chunks[i])) { + chunksNeeded[chunks[i]] = true; + } + } + + if (isEmptyObj(chunksNeeded)) { + return Promise.resolve(); + } + + var capability = createPromiseCapability(); + this.promisesByRequest[requestId] = capability; + + var chunksToRequest = []; + for (var chunk in chunksNeeded) { + chunk = chunk | 0; + if (!(chunk in this.requestsByChunk)) { + this.requestsByChunk[chunk] = []; + chunksToRequest.push(chunk); + } + this.requestsByChunk[chunk].push(requestId); + } + + if (!chunksToRequest.length) { + return capability.promise; + } + + var groupedChunksToRequest = this.groupChunks(chunksToRequest); + + for (i = 0; i < groupedChunksToRequest.length; ++i) { + var groupedChunk = groupedChunksToRequest[i]; + var begin = groupedChunk.beginChunk * this.chunkSize; + var end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length); + this.sendRequest(begin, end); + } + + return capability.promise; + }, + + getStream: function ChunkedStreamManager_getStream() { + return this.stream; + }, + + // Loads any chunks in the requested range that are not yet loaded + requestRange: function ChunkedStreamManager_requestRange(begin, end) { + + end = Math.min(end, this.length); + + var beginChunk = this.getBeginChunk(begin); + var endChunk = this.getEndChunk(end); + + var chunks = []; + for (var chunk = beginChunk; chunk < endChunk; ++chunk) { + chunks.push(chunk); + } + + return this._requestChunks(chunks); + }, + + requestRanges: function ChunkedStreamManager_requestRanges(ranges) { + ranges = ranges || []; + var chunksToRequest = []; + + for (var i = 0; i < ranges.length; i++) { + var beginChunk = this.getBeginChunk(ranges[i].begin); + var endChunk = this.getEndChunk(ranges[i].end); + for (var chunk = beginChunk; chunk < endChunk; ++chunk) { + if (chunksToRequest.indexOf(chunk) < 0) { + chunksToRequest.push(chunk); + } + } + } + + chunksToRequest.sort(function(a, b) { return a - b; }); + return this._requestChunks(chunksToRequest); + }, + + // Groups a sorted array of chunks into as few contiguous larger + // chunks as possible + groupChunks: function ChunkedStreamManager_groupChunks(chunks) { + var groupedChunks = []; + var beginChunk = -1; + var prevChunk = -1; + for (var i = 0; i < chunks.length; ++i) { + var chunk = chunks[i]; + + if (beginChunk < 0) { + beginChunk = chunk; + } + + if (prevChunk >= 0 && prevChunk + 1 !== chunk) { + groupedChunks.push({ beginChunk: beginChunk, + endChunk: prevChunk + 1 }); + beginChunk = chunk; + } + if (i + 1 === chunks.length) { + groupedChunks.push({ beginChunk: beginChunk, + endChunk: chunk + 1 }); + } + + prevChunk = chunk; + } + return groupedChunks; + }, + + onProgress: function ChunkedStreamManager_onProgress(args) { + var bytesLoaded = (this.stream.numChunksLoaded * this.chunkSize + + args.loaded); + this.msgHandler.send('DocProgress', { + loaded: bytesLoaded, + total: this.length + }); + }, + + onReceiveData: function ChunkedStreamManager_onReceiveData(args) { + var chunk = args.chunk; + var isProgressive = args.begin === undefined; + var begin = isProgressive ? this.progressiveDataLength : args.begin; + var end = begin + chunk.byteLength; + + var beginChunk = Math.floor(begin / this.chunkSize); + var endChunk = end < this.length ? Math.floor(end / this.chunkSize) : + Math.ceil(end / this.chunkSize); + + if (isProgressive) { + this.stream.onReceiveProgressiveData(chunk); + this.progressiveDataLength = end; + } else { + this.stream.onReceiveData(begin, chunk); + } + + if (this.stream.allChunksLoaded()) { + this._loadedStreamCapability.resolve(this.stream); + } + + var loadedRequests = []; + var i, requestId; + for (chunk = beginChunk; chunk < endChunk; ++chunk) { + // The server might return more chunks than requested + var requestIds = this.requestsByChunk[chunk] || []; + delete this.requestsByChunk[chunk]; + + for (i = 0; i < requestIds.length; ++i) { + requestId = requestIds[i]; + var chunksNeeded = this.chunksNeededByRequest[requestId]; + if (chunk in chunksNeeded) { + delete chunksNeeded[chunk]; + } + + if (!isEmptyObj(chunksNeeded)) { + continue; + } + + loadedRequests.push(requestId); + } + } + + // If there are no pending requests, automatically fetch the next + // unfetched chunk of the PDF + if (!this.disableAutoFetch && isEmptyObj(this.requestsByChunk)) { + var nextEmptyChunk; + if (this.stream.numChunksLoaded === 1) { + // This is a special optimization so that after fetching the first + // chunk, rather than fetching the second chunk, we fetch the last + // chunk. + var lastChunk = this.stream.numChunks - 1; + if (!this.stream.hasChunk(lastChunk)) { + nextEmptyChunk = lastChunk; + } + } else { + nextEmptyChunk = this.stream.nextEmptyChunk(endChunk); + } + if (isInt(nextEmptyChunk)) { + this._requestChunks([nextEmptyChunk]); + } + } + + for (i = 0; i < loadedRequests.length; ++i) { + requestId = loadedRequests[i]; + var capability = this.promisesByRequest[requestId]; + delete this.promisesByRequest[requestId]; + capability.resolve(); + } + + this.msgHandler.send('DocProgress', { + loaded: this.stream.numChunksLoaded * this.chunkSize, + total: this.length + }); + }, + + onError: function ChunkedStreamManager_onError(err) { + this._loadedStreamCapability.reject(err); + }, + + getBeginChunk: function ChunkedStreamManager_getBeginChunk(begin) { + var chunk = Math.floor(begin / this.chunkSize); + return chunk; + }, + + getEndChunk: function ChunkedStreamManager_getEndChunk(end) { + var chunk = Math.floor((end - 1) / this.chunkSize) + 1; + return chunk; + }, + + abort: function ChunkedStreamManager_abort() { + if (this.networkManager) { + this.networkManager.abortAllRequests(); + } + for(var requestId in this.promisesByRequest) { + var capability = this.promisesByRequest[requestId]; + capability.reject(new Error('Request was aborted')); + } + } + }; + + return ChunkedStreamManager; +})(); + +exports.ChunkedStream = ChunkedStream; +exports.ChunkedStreamManager = ChunkedStreamManager; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreJbig2 = {}), root.pdfjsSharedUtil, + root.pdfjsCoreArithmeticDecoder); + } +}(this, function (exports, sharedUtil, coreArithmeticDecoder) { + +var error = sharedUtil.error; +var log2 = sharedUtil.log2; +var readInt8 = sharedUtil.readInt8; +var readUint16 = sharedUtil.readUint16; +var readUint32 = sharedUtil.readUint32; +var shadow = sharedUtil.shadow; +var ArithmeticDecoder = coreArithmeticDecoder.ArithmeticDecoder; + +var Jbig2Image = (function Jbig2ImageClosure() { + // Utility data structures + function ContextCache() {} + + ContextCache.prototype = { + getContexts: function(id) { + if (id in this) { + return this[id]; + } + return (this[id] = new Int8Array(1 << 16)); + } + }; + + function DecodingContext(data, start, end) { + this.data = data; + this.start = start; + this.end = end; + } + + DecodingContext.prototype = { + get decoder() { + var decoder = new ArithmeticDecoder(this.data, this.start, this.end); + return shadow(this, 'decoder', decoder); + }, + get contextCache() { + var cache = new ContextCache(); + return shadow(this, 'contextCache', cache); + } + }; + + // Annex A. Arithmetic Integer Decoding Procedure + // A.2 Procedure for decoding values + function decodeInteger(contextCache, procedure, decoder) { + var contexts = contextCache.getContexts(procedure); + var prev = 1; + + function readBits(length) { + var v = 0; + for (var i = 0; i < length; i++) { + var bit = decoder.readBit(contexts, prev); + prev = (prev < 256 ? (prev << 1) | bit : + (((prev << 1) | bit) & 511) | 256); + v = (v << 1) | bit; + } + return v >>> 0; + } + + var sign = readBits(1); + var value = readBits(1) ? + (readBits(1) ? + (readBits(1) ? + (readBits(1) ? + (readBits(1) ? + (readBits(32) + 4436) : + readBits(12) + 340) : + readBits(8) + 84) : + readBits(6) + 20) : + readBits(4) + 4) : + readBits(2); + return (sign === 0 ? value : (value > 0 ? -value : null)); + } + + // A.3 The IAID decoding procedure + function decodeIAID(contextCache, decoder, codeLength) { + var contexts = contextCache.getContexts('IAID'); + + var prev = 1; + for (var i = 0; i < codeLength; i++) { + var bit = decoder.readBit(contexts, prev); + prev = (prev << 1) | bit; + } + if (codeLength < 31) { + return prev & ((1 << codeLength) - 1); + } + return prev & 0x7FFFFFFF; + } + + // 7.3 Segment types + var SegmentTypes = [ + 'SymbolDictionary', null, null, null, 'IntermediateTextRegion', null, + 'ImmediateTextRegion', 'ImmediateLosslessTextRegion', null, null, null, + null, null, null, null, null, 'patternDictionary', null, null, null, + 'IntermediateHalftoneRegion', null, 'ImmediateHalftoneRegion', + 'ImmediateLosslessHalftoneRegion', null, null, null, null, null, null, null, + null, null, null, null, null, 'IntermediateGenericRegion', null, + 'ImmediateGenericRegion', 'ImmediateLosslessGenericRegion', + 'IntermediateGenericRefinementRegion', null, + 'ImmediateGenericRefinementRegion', + 'ImmediateLosslessGenericRefinementRegion', null, null, null, null, + 'PageInformation', 'EndOfPage', 'EndOfStripe', 'EndOfFile', 'Profiles', + 'Tables', null, null, null, null, null, null, null, null, + 'Extension' + ]; + + var CodingTemplates = [ + [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: -2, y: -1}, + {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: 2, y: -1}, + {x: -4, y: 0}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}], + [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: 2, y: -2}, + {x: -2, y: -1}, {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, + {x: 2, y: -1}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}], + [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: -2, y: -1}, + {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: -2, y: 0}, + {x: -1, y: 0}], + [{x: -3, y: -1}, {x: -2, y: -1}, {x: -1, y: -1}, {x: 0, y: -1}, + {x: 1, y: -1}, {x: -4, y: 0}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}] + ]; + + var RefinementTemplates = [ + { + coding: [{x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}], + reference: [{x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}, {x: 0, y: 0}, + {x: 1, y: 0}, {x: -1, y: 1}, {x: 0, y: 1}, {x: 1, y: 1}] + }, + { + coding: [{x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}], + reference: [{x: 0, y: -1}, {x: -1, y: 0}, {x: 0, y: 0}, {x: 1, y: 0}, + {x: 0, y: 1}, {x: 1, y: 1}] + } + ]; + + // See 6.2.5.7 Decoding the bitmap. + var ReusedContexts = [ + 0x9B25, // 10011 0110010 0101 + 0x0795, // 0011 110010 101 + 0x00E5, // 001 11001 01 + 0x0195 // 011001 0101 + ]; + + var RefinementReusedContexts = [ + 0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference) + 0x0008 // '0000' + '001000' + ]; + + function decodeBitmapTemplate0(width, height, decodingContext) { + var decoder = decodingContext.decoder; + var contexts = decodingContext.contextCache.getContexts('GB'); + var contextLabel, i, j, pixel, row, row1, row2, bitmap = []; + + // ...ooooo.... + // ..ooooooo... Context template for current pixel (X) + // .ooooX...... (concatenate values of 'o'-pixels to get contextLabel) + var OLD_PIXEL_MASK = 0x7BF7; // 01111 0111111 0111 + + for (i = 0; i < height; i++) { + row = bitmap[i] = new Uint8Array(width); + row1 = (i < 1) ? row : bitmap[i - 1]; + row2 = (i < 2) ? row : bitmap[i - 2]; + + // At the beginning of each row: + // Fill contextLabel with pixels that are above/right of (X) + contextLabel = (row2[0] << 13) | (row2[1] << 12) | (row2[2] << 11) | + (row1[0] << 7) | (row1[1] << 6) | (row1[2] << 5) | + (row1[3] << 4); + + for (j = 0; j < width; j++) { + row[j] = pixel = decoder.readBit(contexts, contextLabel); + + // At each pixel: Clear contextLabel pixels that are shifted + // out of the context, then add new ones. + contextLabel = ((contextLabel & OLD_PIXEL_MASK) << 1) | + (j + 3 < width ? row2[j + 3] << 11 : 0) | + (j + 4 < width ? row1[j + 4] << 4 : 0) | pixel; + } + } + + return bitmap; + } + + // 6.2 Generic Region Decoding Procedure + function decodeBitmap(mmr, width, height, templateIndex, prediction, skip, at, + decodingContext) { + if (mmr) { + error('JBIG2 error: MMR encoding is not supported'); + } + + // Use optimized version for the most common case + if (templateIndex === 0 && !skip && !prediction && at.length === 4 && + at[0].x === 3 && at[0].y === -1 && at[1].x === -3 && at[1].y === -1 && + at[2].x === 2 && at[2].y === -2 && at[3].x === -2 && at[3].y === -2) { + return decodeBitmapTemplate0(width, height, decodingContext); + } + + var useskip = !!skip; + var template = CodingTemplates[templateIndex].concat(at); + + // Sorting is non-standard, and it is not required. But sorting increases + // the number of template bits that can be reused from the previous + // contextLabel in the main loop. + template.sort(function (a, b) { + return (a.y - b.y) || (a.x - b.x); + }); + + var templateLength = template.length; + var templateX = new Int8Array(templateLength); + var templateY = new Int8Array(templateLength); + var changingTemplateEntries = []; + var reuseMask = 0, minX = 0, maxX = 0, minY = 0; + var c, k; + + for (k = 0; k < templateLength; k++) { + templateX[k] = template[k].x; + templateY[k] = template[k].y; + minX = Math.min(minX, template[k].x); + maxX = Math.max(maxX, template[k].x); + minY = Math.min(minY, template[k].y); + // Check if the template pixel appears in two consecutive context labels, + // so it can be reused. Otherwise, we add it to the list of changing + // template entries. + if (k < templateLength - 1 && + template[k].y === template[k + 1].y && + template[k].x === template[k + 1].x - 1) { + reuseMask |= 1 << (templateLength - 1 - k); + } else { + changingTemplateEntries.push(k); + } + } + var changingEntriesLength = changingTemplateEntries.length; + + var changingTemplateX = new Int8Array(changingEntriesLength); + var changingTemplateY = new Int8Array(changingEntriesLength); + var changingTemplateBit = new Uint16Array(changingEntriesLength); + for (c = 0; c < changingEntriesLength; c++) { + k = changingTemplateEntries[c]; + changingTemplateX[c] = template[k].x; + changingTemplateY[c] = template[k].y; + changingTemplateBit[c] = 1 << (templateLength - 1 - k); + } + + // Get the safe bounding box edges from the width, height, minX, maxX, minY + var sbb_left = -minX; + var sbb_top = -minY; + var sbb_right = width - maxX; + + var pseudoPixelContext = ReusedContexts[templateIndex]; + var row = new Uint8Array(width); + var bitmap = []; + + var decoder = decodingContext.decoder; + var contexts = decodingContext.contextCache.getContexts('GB'); + + var ltp = 0, j, i0, j0, contextLabel = 0, bit, shift; + for (var i = 0; i < height; i++) { + if (prediction) { + var sltp = decoder.readBit(contexts, pseudoPixelContext); + ltp ^= sltp; + if (ltp) { + bitmap.push(row); // duplicate previous row + continue; + } + } + row = new Uint8Array(row); + bitmap.push(row); + for (j = 0; j < width; j++) { + if (useskip && skip[i][j]) { + row[j] = 0; + continue; + } + // Are we in the middle of a scanline, so we can reuse contextLabel + // bits? + if (j >= sbb_left && j < sbb_right && i >= sbb_top) { + // If yes, we can just shift the bits that are reusable and only + // fetch the remaining ones. + contextLabel = (contextLabel << 1) & reuseMask; + for (k = 0; k < changingEntriesLength; k++) { + i0 = i + changingTemplateY[k]; + j0 = j + changingTemplateX[k]; + bit = bitmap[i0][j0]; + if (bit) { + bit = changingTemplateBit[k]; + contextLabel |= bit; + } + } + } else { + // compute the contextLabel from scratch + contextLabel = 0; + shift = templateLength - 1; + for (k = 0; k < templateLength; k++, shift--) { + j0 = j + templateX[k]; + if (j0 >= 0 && j0 < width) { + i0 = i + templateY[k]; + if (i0 >= 0) { + bit = bitmap[i0][j0]; + if (bit) { + contextLabel |= bit << shift; + } + } + } + } + } + var pixel = decoder.readBit(contexts, contextLabel); + row[j] = pixel; + } + } + return bitmap; + } + + // 6.3.2 Generic Refinement Region Decoding Procedure + function decodeRefinement(width, height, templateIndex, referenceBitmap, + offsetX, offsetY, prediction, at, + decodingContext) { + var codingTemplate = RefinementTemplates[templateIndex].coding; + if (templateIndex === 0) { + codingTemplate = codingTemplate.concat([at[0]]); + } + var codingTemplateLength = codingTemplate.length; + var codingTemplateX = new Int32Array(codingTemplateLength); + var codingTemplateY = new Int32Array(codingTemplateLength); + var k; + for (k = 0; k < codingTemplateLength; k++) { + codingTemplateX[k] = codingTemplate[k].x; + codingTemplateY[k] = codingTemplate[k].y; + } + + var referenceTemplate = RefinementTemplates[templateIndex].reference; + if (templateIndex === 0) { + referenceTemplate = referenceTemplate.concat([at[1]]); + } + var referenceTemplateLength = referenceTemplate.length; + var referenceTemplateX = new Int32Array(referenceTemplateLength); + var referenceTemplateY = new Int32Array(referenceTemplateLength); + for (k = 0; k < referenceTemplateLength; k++) { + referenceTemplateX[k] = referenceTemplate[k].x; + referenceTemplateY[k] = referenceTemplate[k].y; + } + var referenceWidth = referenceBitmap[0].length; + var referenceHeight = referenceBitmap.length; + + var pseudoPixelContext = RefinementReusedContexts[templateIndex]; + var bitmap = []; + + var decoder = decodingContext.decoder; + var contexts = decodingContext.contextCache.getContexts('GR'); + + var ltp = 0; + for (var i = 0; i < height; i++) { + if (prediction) { + var sltp = decoder.readBit(contexts, pseudoPixelContext); + ltp ^= sltp; + if (ltp) { + error('JBIG2 error: prediction is not supported'); + } + } + var row = new Uint8Array(width); + bitmap.push(row); + for (var j = 0; j < width; j++) { + var i0, j0; + var contextLabel = 0; + for (k = 0; k < codingTemplateLength; k++) { + i0 = i + codingTemplateY[k]; + j0 = j + codingTemplateX[k]; + if (i0 < 0 || j0 < 0 || j0 >= width) { + contextLabel <<= 1; // out of bound pixel + } else { + contextLabel = (contextLabel << 1) | bitmap[i0][j0]; + } + } + for (k = 0; k < referenceTemplateLength; k++) { + i0 = i + referenceTemplateY[k] + offsetY; + j0 = j + referenceTemplateX[k] + offsetX; + if (i0 < 0 || i0 >= referenceHeight || j0 < 0 || + j0 >= referenceWidth) { + contextLabel <<= 1; // out of bound pixel + } else { + contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0]; + } + } + var pixel = decoder.readBit(contexts, contextLabel); + row[j] = pixel; + } + } + + return bitmap; + } + + // 6.5.5 Decoding the symbol dictionary + function decodeSymbolDictionary(huffman, refinement, symbols, + numberOfNewSymbols, numberOfExportedSymbols, + huffmanTables, templateIndex, at, + refinementTemplateIndex, refinementAt, + decodingContext) { + if (huffman) { + error('JBIG2 error: huffman is not supported'); + } + + var newSymbols = []; + var currentHeight = 0; + var symbolCodeLength = log2(symbols.length + numberOfNewSymbols); + + var decoder = decodingContext.decoder; + var contextCache = decodingContext.contextCache; + + while (newSymbols.length < numberOfNewSymbols) { + var deltaHeight = decodeInteger(contextCache, 'IADH', decoder); // 6.5.6 + currentHeight += deltaHeight; + var currentWidth = 0; + var totalWidth = 0; + while (true) { + var deltaWidth = decodeInteger(contextCache, 'IADW', decoder); // 6.5.7 + if (deltaWidth === null) { + break; // OOB + } + currentWidth += deltaWidth; + totalWidth += currentWidth; + var bitmap; + if (refinement) { + // 6.5.8.2 Refinement/aggregate-coded symbol bitmap + var numberOfInstances = decodeInteger(contextCache, 'IAAI', decoder); + if (numberOfInstances > 1) { + bitmap = decodeTextRegion(huffman, refinement, + currentWidth, currentHeight, 0, + numberOfInstances, 1, //strip size + symbols.concat(newSymbols), + symbolCodeLength, + 0, //transposed + 0, //ds offset + 1, //top left 7.4.3.1.1 + 0, //OR operator + huffmanTables, + refinementTemplateIndex, refinementAt, + decodingContext); + } else { + var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength); + var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3 + var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4 + var symbol = (symbolId < symbols.length ? symbols[symbolId] : + newSymbols[symbolId - symbols.length]); + bitmap = decodeRefinement(currentWidth, currentHeight, + refinementTemplateIndex, symbol, rdx, rdy, false, refinementAt, + decodingContext); + } + } else { + // 6.5.8.1 Direct-coded symbol bitmap + bitmap = decodeBitmap(false, currentWidth, currentHeight, + templateIndex, false, null, at, decodingContext); + } + newSymbols.push(bitmap); + } + } + // 6.5.10 Exported symbols + var exportedSymbols = []; + var flags = [], currentFlag = false; + var totalSymbolsLength = symbols.length + numberOfNewSymbols; + while (flags.length < totalSymbolsLength) { + var runLength = decodeInteger(contextCache, 'IAEX', decoder); + while (runLength--) { + flags.push(currentFlag); + } + currentFlag = !currentFlag; + } + for (var i = 0, ii = symbols.length; i < ii; i++) { + if (flags[i]) { + exportedSymbols.push(symbols[i]); + } + } + for (var j = 0; j < numberOfNewSymbols; i++, j++) { + if (flags[i]) { + exportedSymbols.push(newSymbols[j]); + } + } + return exportedSymbols; + } + + function decodeTextRegion(huffman, refinement, width, height, + defaultPixelValue, numberOfSymbolInstances, + stripSize, inputSymbols, symbolCodeLength, + transposed, dsOffset, referenceCorner, + combinationOperator, huffmanTables, + refinementTemplateIndex, refinementAt, + decodingContext) { + if (huffman) { + error('JBIG2 error: huffman is not supported'); + } + + // Prepare bitmap + var bitmap = []; + var i, row; + for (i = 0; i < height; i++) { + row = new Uint8Array(width); + if (defaultPixelValue) { + for (var j = 0; j < width; j++) { + row[j] = defaultPixelValue; + } + } + bitmap.push(row); + } + + var decoder = decodingContext.decoder; + var contextCache = decodingContext.contextCache; + var stripT = -decodeInteger(contextCache, 'IADT', decoder); // 6.4.6 + var firstS = 0; + i = 0; + while (i < numberOfSymbolInstances) { + var deltaT = decodeInteger(contextCache, 'IADT', decoder); // 6.4.6 + stripT += deltaT; + + var deltaFirstS = decodeInteger(contextCache, 'IAFS', decoder); // 6.4.7 + firstS += deltaFirstS; + var currentS = firstS; + do { + var currentT = (stripSize === 1 ? 0 : + decodeInteger(contextCache, 'IAIT', decoder)); // 6.4.9 + var t = stripSize * stripT + currentT; + var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength); + var applyRefinement = (refinement && + decodeInteger(contextCache, 'IARI', decoder)); + var symbolBitmap = inputSymbols[symbolId]; + var symbolWidth = symbolBitmap[0].length; + var symbolHeight = symbolBitmap.length; + if (applyRefinement) { + var rdw = decodeInteger(contextCache, 'IARDW', decoder); // 6.4.11.1 + var rdh = decodeInteger(contextCache, 'IARDH', decoder); // 6.4.11.2 + var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3 + var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4 + symbolWidth += rdw; + symbolHeight += rdh; + symbolBitmap = decodeRefinement(symbolWidth, symbolHeight, + refinementTemplateIndex, symbolBitmap, (rdw >> 1) + rdx, + (rdh >> 1) + rdy, false, refinementAt, + decodingContext); + } + var offsetT = t - ((referenceCorner & 1) ? 0 : symbolHeight); + var offsetS = currentS - ((referenceCorner & 2) ? symbolWidth : 0); + var s2, t2, symbolRow; + if (transposed) { + // Place Symbol Bitmap from T1,S1 + for (s2 = 0; s2 < symbolHeight; s2++) { + row = bitmap[offsetS + s2]; + if (!row) { + continue; + } + symbolRow = symbolBitmap[s2]; + // To ignore Parts of Symbol bitmap which goes + // outside bitmap region + var maxWidth = Math.min(width - offsetT, symbolWidth); + switch (combinationOperator) { + case 0: // OR + for (t2 = 0; t2 < maxWidth; t2++) { + row[offsetT + t2] |= symbolRow[t2]; + } + break; + case 2: // XOR + for (t2 = 0; t2 < maxWidth; t2++) { + row[offsetT + t2] ^= symbolRow[t2]; + } + break; + default: + error('JBIG2 error: operator ' + combinationOperator + + ' is not supported'); + } + } + currentS += symbolHeight - 1; + } else { + for (t2 = 0; t2 < symbolHeight; t2++) { + row = bitmap[offsetT + t2]; + if (!row) { + continue; + } + symbolRow = symbolBitmap[t2]; + switch (combinationOperator) { + case 0: // OR + for (s2 = 0; s2 < symbolWidth; s2++) { + row[offsetS + s2] |= symbolRow[s2]; + } + break; + case 2: // XOR + for (s2 = 0; s2 < symbolWidth; s2++) { + row[offsetS + s2] ^= symbolRow[s2]; + } + break; + default: + error('JBIG2 error: operator ' + combinationOperator + + ' is not supported'); + } + } + currentS += symbolWidth - 1; + } + i++; + var deltaS = decodeInteger(contextCache, 'IADS', decoder); // 6.4.8 + if (deltaS === null) { + break; // OOB + } + currentS += deltaS + dsOffset; + } while (true); + } + return bitmap; + } + + function readSegmentHeader(data, start) { + var segmentHeader = {}; + segmentHeader.number = readUint32(data, start); + var flags = data[start + 4]; + var segmentType = flags & 0x3F; + if (!SegmentTypes[segmentType]) { + error('JBIG2 error: invalid segment type: ' + segmentType); + } + segmentHeader.type = segmentType; + segmentHeader.typeName = SegmentTypes[segmentType]; + segmentHeader.deferredNonRetain = !!(flags & 0x80); + + var pageAssociationFieldSize = !!(flags & 0x40); + var referredFlags = data[start + 5]; + var referredToCount = (referredFlags >> 5) & 7; + var retainBits = [referredFlags & 31]; + var position = start + 6; + if (referredFlags === 7) { + referredToCount = readUint32(data, position - 1) & 0x1FFFFFFF; + position += 3; + var bytes = (referredToCount + 7) >> 3; + retainBits[0] = data[position++]; + while (--bytes > 0) { + retainBits.push(data[position++]); + } + } else if (referredFlags === 5 || referredFlags === 6) { + error('JBIG2 error: invalid referred-to flags'); + } + + segmentHeader.retainBits = retainBits; + var referredToSegmentNumberSize = (segmentHeader.number <= 256 ? 1 : + (segmentHeader.number <= 65536 ? 2 : 4)); + var referredTo = []; + var i, ii; + for (i = 0; i < referredToCount; i++) { + var number = (referredToSegmentNumberSize === 1 ? data[position] : + (referredToSegmentNumberSize === 2 ? readUint16(data, position) : + readUint32(data, position))); + referredTo.push(number); + position += referredToSegmentNumberSize; + } + segmentHeader.referredTo = referredTo; + if (!pageAssociationFieldSize) { + segmentHeader.pageAssociation = data[position++]; + } else { + segmentHeader.pageAssociation = readUint32(data, position); + position += 4; + } + segmentHeader.length = readUint32(data, position); + position += 4; + + if (segmentHeader.length === 0xFFFFFFFF) { + // 7.2.7 Segment data length, unknown segment length + if (segmentType === 38) { // ImmediateGenericRegion + var genericRegionInfo = readRegionSegmentInformation(data, position); + var genericRegionSegmentFlags = data[position + + RegionSegmentInformationFieldLength]; + var genericRegionMmr = !!(genericRegionSegmentFlags & 1); + // searching for the segment end + var searchPatternLength = 6; + var searchPattern = new Uint8Array(searchPatternLength); + if (!genericRegionMmr) { + searchPattern[0] = 0xFF; + searchPattern[1] = 0xAC; + } + searchPattern[2] = (genericRegionInfo.height >>> 24) & 0xFF; + searchPattern[3] = (genericRegionInfo.height >> 16) & 0xFF; + searchPattern[4] = (genericRegionInfo.height >> 8) & 0xFF; + searchPattern[5] = genericRegionInfo.height & 0xFF; + for (i = position, ii = data.length; i < ii; i++) { + var j = 0; + while (j < searchPatternLength && searchPattern[j] === data[i + j]) { + j++; + } + if (j === searchPatternLength) { + segmentHeader.length = i + searchPatternLength; + break; + } + } + if (segmentHeader.length === 0xFFFFFFFF) { + error('JBIG2 error: segment end was not found'); + } + } else { + error('JBIG2 error: invalid unknown segment length'); + } + } + segmentHeader.headerEnd = position; + return segmentHeader; + } + + function readSegments(header, data, start, end) { + var segments = []; + var position = start; + while (position < end) { + var segmentHeader = readSegmentHeader(data, position); + position = segmentHeader.headerEnd; + var segment = { + header: segmentHeader, + data: data + }; + if (!header.randomAccess) { + segment.start = position; + position += segmentHeader.length; + segment.end = position; + } + segments.push(segment); + if (segmentHeader.type === 51) { + break; // end of file is found + } + } + if (header.randomAccess) { + for (var i = 0, ii = segments.length; i < ii; i++) { + segments[i].start = position; + position += segments[i].header.length; + segments[i].end = position; + } + } + return segments; + } + + // 7.4.1 Region segment information field + function readRegionSegmentInformation(data, start) { + return { + width: readUint32(data, start), + height: readUint32(data, start + 4), + x: readUint32(data, start + 8), + y: readUint32(data, start + 12), + combinationOperator: data[start + 16] & 7 + }; + } + var RegionSegmentInformationFieldLength = 17; + + function processSegment(segment, visitor) { + var header = segment.header; + + var data = segment.data, position = segment.start, end = segment.end; + var args, at, i, atLength; + switch (header.type) { + case 0: // SymbolDictionary + // 7.4.2 Symbol dictionary segment syntax + var dictionary = {}; + var dictionaryFlags = readUint16(data, position); // 7.4.2.1.1 + dictionary.huffman = !!(dictionaryFlags & 1); + dictionary.refinement = !!(dictionaryFlags & 2); + dictionary.huffmanDHSelector = (dictionaryFlags >> 2) & 3; + dictionary.huffmanDWSelector = (dictionaryFlags >> 4) & 3; + dictionary.bitmapSizeSelector = (dictionaryFlags >> 6) & 1; + dictionary.aggregationInstancesSelector = (dictionaryFlags >> 7) & 1; + dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256); + dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512); + dictionary.template = (dictionaryFlags >> 10) & 3; + dictionary.refinementTemplate = (dictionaryFlags >> 12) & 1; + position += 2; + if (!dictionary.huffman) { + atLength = dictionary.template === 0 ? 4 : 1; + at = []; + for (i = 0; i < atLength; i++) { + at.push({ + x: readInt8(data, position), + y: readInt8(data, position + 1) + }); + position += 2; + } + dictionary.at = at; + } + if (dictionary.refinement && !dictionary.refinementTemplate) { + at = []; + for (i = 0; i < 2; i++) { + at.push({ + x: readInt8(data, position), + y: readInt8(data, position + 1) + }); + position += 2; + } + dictionary.refinementAt = at; + } + dictionary.numberOfExportedSymbols = readUint32(data, position); + position += 4; + dictionary.numberOfNewSymbols = readUint32(data, position); + position += 4; + args = [dictionary, header.number, header.referredTo, + data, position, end]; + break; + case 6: // ImmediateTextRegion + case 7: // ImmediateLosslessTextRegion + var textRegion = {}; + textRegion.info = readRegionSegmentInformation(data, position); + position += RegionSegmentInformationFieldLength; + var textRegionSegmentFlags = readUint16(data, position); + position += 2; + textRegion.huffman = !!(textRegionSegmentFlags & 1); + textRegion.refinement = !!(textRegionSegmentFlags & 2); + textRegion.stripSize = 1 << ((textRegionSegmentFlags >> 2) & 3); + textRegion.referenceCorner = (textRegionSegmentFlags >> 4) & 3; + textRegion.transposed = !!(textRegionSegmentFlags & 64); + textRegion.combinationOperator = (textRegionSegmentFlags >> 7) & 3; + textRegion.defaultPixelValue = (textRegionSegmentFlags >> 9) & 1; + textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27; + textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1; + if (textRegion.huffman) { + var textRegionHuffmanFlags = readUint16(data, position); + position += 2; + textRegion.huffmanFS = (textRegionHuffmanFlags) & 3; + textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3; + textRegion.huffmanDT = (textRegionHuffmanFlags >> 4) & 3; + textRegion.huffmanRefinementDW = (textRegionHuffmanFlags >> 6) & 3; + textRegion.huffmanRefinementDH = (textRegionHuffmanFlags >> 8) & 3; + textRegion.huffmanRefinementDX = (textRegionHuffmanFlags >> 10) & 3; + textRegion.huffmanRefinementDY = (textRegionHuffmanFlags >> 12) & 3; + textRegion.huffmanRefinementSizeSelector = + !!(textRegionHuffmanFlags & 14); + } + if (textRegion.refinement && !textRegion.refinementTemplate) { + at = []; + for (i = 0; i < 2; i++) { + at.push({ + x: readInt8(data, position), + y: readInt8(data, position + 1) + }); + position += 2; + } + textRegion.refinementAt = at; + } + textRegion.numberOfSymbolInstances = readUint32(data, position); + position += 4; + // TODO 7.4.3.1.7 Symbol ID Huffman table decoding + if (textRegion.huffman) { + error('JBIG2 error: huffman is not supported'); + } + args = [textRegion, header.referredTo, data, position, end]; + break; + case 38: // ImmediateGenericRegion + case 39: // ImmediateLosslessGenericRegion + var genericRegion = {}; + genericRegion.info = readRegionSegmentInformation(data, position); + position += RegionSegmentInformationFieldLength; + var genericRegionSegmentFlags = data[position++]; + genericRegion.mmr = !!(genericRegionSegmentFlags & 1); + genericRegion.template = (genericRegionSegmentFlags >> 1) & 3; + genericRegion.prediction = !!(genericRegionSegmentFlags & 8); + if (!genericRegion.mmr) { + atLength = genericRegion.template === 0 ? 4 : 1; + at = []; + for (i = 0; i < atLength; i++) { + at.push({ + x: readInt8(data, position), + y: readInt8(data, position + 1) + }); + position += 2; + } + genericRegion.at = at; + } + args = [genericRegion, data, position, end]; + break; + case 48: // PageInformation + var pageInfo = { + width: readUint32(data, position), + height: readUint32(data, position + 4), + resolutionX: readUint32(data, position + 8), + resolutionY: readUint32(data, position + 12) + }; + if (pageInfo.height === 0xFFFFFFFF) { + delete pageInfo.height; + } + var pageSegmentFlags = data[position + 16]; + var pageStripingInformation = readUint16(data, position + 17); + pageInfo.lossless = !!(pageSegmentFlags & 1); + pageInfo.refinement = !!(pageSegmentFlags & 2); + pageInfo.defaultPixelValue = (pageSegmentFlags >> 2) & 1; + pageInfo.combinationOperator = (pageSegmentFlags >> 3) & 3; + pageInfo.requiresBuffer = !!(pageSegmentFlags & 32); + pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64); + args = [pageInfo]; + break; + case 49: // EndOfPage + break; + case 50: // EndOfStripe + break; + case 51: // EndOfFile + break; + case 62: // 7.4.15 defines 2 extension types which + // are comments and can be ignored. + break; + default: + error('JBIG2 error: segment type ' + header.typeName + '(' + + header.type + ') is not implemented'); + } + var callbackName = 'on' + header.typeName; + if (callbackName in visitor) { + visitor[callbackName].apply(visitor, args); + } + } + + function processSegments(segments, visitor) { + for (var i = 0, ii = segments.length; i < ii; i++) { + processSegment(segments[i], visitor); + } + } + + function parseJbig2(data, start, end) { + var position = start; + if (data[position] !== 0x97 || data[position + 1] !== 0x4A || + data[position + 2] !== 0x42 || data[position + 3] !== 0x32 || + data[position + 4] !== 0x0D || data[position + 5] !== 0x0A || + data[position + 6] !== 0x1A || data[position + 7] !== 0x0A) { + error('JBIG2 error: invalid header'); + } + var header = {}; + position += 8; + var flags = data[position++]; + header.randomAccess = !(flags & 1); + if (!(flags & 2)) { + header.numberOfPages = readUint32(data, position); + position += 4; + } + var segments = readSegments(header, data, position, end); + error('Not implemented'); + // processSegments(segments, new SimpleSegmentVisitor()); + } + + function parseJbig2Chunks(chunks) { + var visitor = new SimpleSegmentVisitor(); + for (var i = 0, ii = chunks.length; i < ii; i++) { + var chunk = chunks[i]; + var segments = readSegments({}, chunk.data, chunk.start, chunk.end); + processSegments(segments, visitor); + } + return visitor.buffer; + } + + function SimpleSegmentVisitor() {} + + SimpleSegmentVisitor.prototype = { + onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) { + this.currentPageInfo = info; + var rowSize = (info.width + 7) >> 3; + var buffer = new Uint8Array(rowSize * info.height); + // The contents of ArrayBuffers are initialized to 0. + // Fill the buffer with 0xFF only if info.defaultPixelValue is set + if (info.defaultPixelValue) { + for (var i = 0, ii = buffer.length; i < ii; i++) { + buffer[i] = 0xFF; + } + } + this.buffer = buffer; + }, + drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) { + var pageInfo = this.currentPageInfo; + var width = regionInfo.width, height = regionInfo.height; + var rowSize = (pageInfo.width + 7) >> 3; + var combinationOperator = pageInfo.combinationOperatorOverride ? + regionInfo.combinationOperator : pageInfo.combinationOperator; + var buffer = this.buffer; + var mask0 = 128 >> (regionInfo.x & 7); + var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3); + var i, j, mask, offset; + switch (combinationOperator) { + case 0: // OR + for (i = 0; i < height; i++) { + mask = mask0; + offset = offset0; + for (j = 0; j < width; j++) { + if (bitmap[i][j]) { + buffer[offset] |= mask; + } + mask >>= 1; + if (!mask) { + mask = 128; + offset++; + } + } + offset0 += rowSize; + } + break; + case 2: // XOR + for (i = 0; i < height; i++) { + mask = mask0; + offset = offset0; + for (j = 0; j < width; j++) { + if (bitmap[i][j]) { + buffer[offset] ^= mask; + } + mask >>= 1; + if (!mask) { + mask = 128; + offset++; + } + } + offset0 += rowSize; + } + break; + default: + error('JBIG2 error: operator ' + combinationOperator + + ' is not supported'); + } + }, + onImmediateGenericRegion: + function SimpleSegmentVisitor_onImmediateGenericRegion(region, data, + start, end) { + var regionInfo = region.info; + var decodingContext = new DecodingContext(data, start, end); + var bitmap = decodeBitmap(region.mmr, regionInfo.width, regionInfo.height, + region.template, region.prediction, null, + region.at, decodingContext); + this.drawBitmap(regionInfo, bitmap); + }, + onImmediateLosslessGenericRegion: + function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() { + this.onImmediateGenericRegion.apply(this, arguments); + }, + onSymbolDictionary: + function SimpleSegmentVisitor_onSymbolDictionary(dictionary, + currentSegment, + referredSegments, + data, start, end) { + var huffmanTables; + if (dictionary.huffman) { + error('JBIG2 error: huffman is not supported'); + } + + // Combines exported symbols from all referred segments + var symbols = this.symbols; + if (!symbols) { + this.symbols = symbols = {}; + } + + var inputSymbols = []; + for (var i = 0, ii = referredSegments.length; i < ii; i++) { + inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]); + } + + var decodingContext = new DecodingContext(data, start, end); + symbols[currentSegment] = decodeSymbolDictionary(dictionary.huffman, + dictionary.refinement, inputSymbols, dictionary.numberOfNewSymbols, + dictionary.numberOfExportedSymbols, huffmanTables, + dictionary.template, dictionary.at, + dictionary.refinementTemplate, dictionary.refinementAt, + decodingContext); + }, + onImmediateTextRegion: + function SimpleSegmentVisitor_onImmediateTextRegion(region, + referredSegments, + data, start, end) { + var regionInfo = region.info; + var huffmanTables; + + // Combines exported symbols from all referred segments + var symbols = this.symbols; + var inputSymbols = []; + for (var i = 0, ii = referredSegments.length; i < ii; i++) { + inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]); + } + var symbolCodeLength = log2(inputSymbols.length); + + var decodingContext = new DecodingContext(data, start, end); + var bitmap = decodeTextRegion(region.huffman, region.refinement, + regionInfo.width, regionInfo.height, region.defaultPixelValue, + region.numberOfSymbolInstances, region.stripSize, inputSymbols, + symbolCodeLength, region.transposed, region.dsOffset, + region.referenceCorner, region.combinationOperator, huffmanTables, + region.refinementTemplate, region.refinementAt, decodingContext); + this.drawBitmap(regionInfo, bitmap); + }, + onImmediateLosslessTextRegion: + function SimpleSegmentVisitor_onImmediateLosslessTextRegion() { + this.onImmediateTextRegion.apply(this, arguments); + } + }; + + function Jbig2Image() {} + + Jbig2Image.prototype = { + parseChunks: function Jbig2Image_parseChunks(chunks) { + return parseJbig2Chunks(chunks); + } + }; + + return Jbig2Image; +})(); + +exports.Jbig2Image = Jbig2Image; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreJpx = {}), root.pdfjsSharedUtil, + root.pdfjsCoreArithmeticDecoder); + } +}(this, function (exports, sharedUtil, coreArithmeticDecoder) { + +var info = sharedUtil.info; +var log2 = sharedUtil.log2; +var readUint16 = sharedUtil.readUint16; +var readUint32 = sharedUtil.readUint32; +var warn = sharedUtil.warn; +var ArithmeticDecoder = coreArithmeticDecoder.ArithmeticDecoder; + +var JpxImage = (function JpxImageClosure() { + // Table E.1 + var SubbandsGainLog2 = { + 'LL': 0, + 'LH': 1, + 'HL': 1, + 'HH': 2 + }; + function JpxImage() { + this.failOnCorruptedImage = false; + } + JpxImage.prototype = { + parse: function JpxImage_parse(data) { + + var head = readUint16(data, 0); + // No box header, immediate start of codestream (SOC) + if (head === 0xFF4F) { + this.parseCodestream(data, 0, data.length); + return; + } + + var position = 0, length = data.length; + while (position < length) { + var headerSize = 8; + var lbox = readUint32(data, position); + var tbox = readUint32(data, position + 4); + position += headerSize; + if (lbox === 1) { + // XLBox: read UInt64 according to spec. + // JavaScript's int precision of 53 bit should be sufficient here. + lbox = readUint32(data, position) * 4294967296 + + readUint32(data, position + 4); + position += 8; + headerSize += 8; + } + if (lbox === 0) { + lbox = length - position + headerSize; + } + if (lbox < headerSize) { + throw new Error('JPX Error: Invalid box field size'); + } + var dataLength = lbox - headerSize; + var jumpDataLength = true; + switch (tbox) { + case 0x6A703268: // 'jp2h' + jumpDataLength = false; // parsing child boxes + break; + case 0x636F6C72: // 'colr' + // Colorspaces are not used, the CS from the PDF is used. + var method = data[position]; + if (method === 1) { + // enumerated colorspace + var colorspace = readUint32(data, position + 3); + switch (colorspace) { + case 16: // this indicates a sRGB colorspace + case 17: // this indicates a grayscale colorspace + case 18: // this indicates a YUV colorspace + break; + default: + warn('Unknown colorspace ' + colorspace); + break; + } + } else if (method === 2) { + info('ICC profile not supported'); + } + break; + case 0x6A703263: // 'jp2c' + this.parseCodestream(data, position, position + dataLength); + break; + case 0x6A502020: // 'jP\024\024' + if (0x0d0a870a !== readUint32(data, position)) { + warn('Invalid JP2 signature'); + } + break; + // The following header types are valid but currently not used: + case 0x6A501A1A: // 'jP\032\032' + case 0x66747970: // 'ftyp' + case 0x72726571: // 'rreq' + case 0x72657320: // 'res ' + case 0x69686472: // 'ihdr' + break; + default: + var headerType = String.fromCharCode((tbox >> 24) & 0xFF, + (tbox >> 16) & 0xFF, + (tbox >> 8) & 0xFF, + tbox & 0xFF); + warn('Unsupported header type ' + tbox + ' (' + headerType + ')'); + break; + } + if (jumpDataLength) { + position += dataLength; + } + } + }, + parseImageProperties: function JpxImage_parseImageProperties(stream) { + var newByte = stream.getByte(); + while (newByte >= 0) { + var oldByte = newByte; + newByte = stream.getByte(); + var code = (oldByte << 8) | newByte; + // Image and tile size (SIZ) + if (code === 0xFF51) { + stream.skip(4); + var Xsiz = stream.getInt32() >>> 0; // Byte 4 + var Ysiz = stream.getInt32() >>> 0; // Byte 8 + var XOsiz = stream.getInt32() >>> 0; // Byte 12 + var YOsiz = stream.getInt32() >>> 0; // Byte 16 + stream.skip(16); + var Csiz = stream.getUint16(); // Byte 36 + this.width = Xsiz - XOsiz; + this.height = Ysiz - YOsiz; + this.componentsCount = Csiz; + // Results are always returned as Uint8Arrays + this.bitsPerComponent = 8; + return; + } + } + throw new Error('JPX Error: No size marker found in JPX stream'); + }, + parseCodestream: function JpxImage_parseCodestream(data, start, end) { + var context = {}; + try { + var doNotRecover = false; + var position = start; + while (position + 1 < end) { + var code = readUint16(data, position); + position += 2; + + var length = 0, j, sqcd, spqcds, spqcdSize, scalarExpounded, tile; + switch (code) { + case 0xFF4F: // Start of codestream (SOC) + context.mainHeader = true; + break; + case 0xFFD9: // End of codestream (EOC) + break; + case 0xFF51: // Image and tile size (SIZ) + length = readUint16(data, position); + var siz = {}; + siz.Xsiz = readUint32(data, position + 4); + siz.Ysiz = readUint32(data, position + 8); + siz.XOsiz = readUint32(data, position + 12); + siz.YOsiz = readUint32(data, position + 16); + siz.XTsiz = readUint32(data, position + 20); + siz.YTsiz = readUint32(data, position + 24); + siz.XTOsiz = readUint32(data, position + 28); + siz.YTOsiz = readUint32(data, position + 32); + var componentsCount = readUint16(data, position + 36); + siz.Csiz = componentsCount; + var components = []; + j = position + 38; + for (var i = 0; i < componentsCount; i++) { + var component = { + precision: (data[j] & 0x7F) + 1, + isSigned: !!(data[j] & 0x80), + XRsiz: data[j + 1], + YRsiz: data[j + 1] + }; + calculateComponentDimensions(component, siz); + components.push(component); + } + context.SIZ = siz; + context.components = components; + calculateTileGrids(context, components); + context.QCC = []; + context.COC = []; + break; + case 0xFF5C: // Quantization default (QCD) + length = readUint16(data, position); + var qcd = {}; + j = position + 2; + sqcd = data[j++]; + switch (sqcd & 0x1F) { + case 0: + spqcdSize = 8; + scalarExpounded = true; + break; + case 1: + spqcdSize = 16; + scalarExpounded = false; + break; + case 2: + spqcdSize = 16; + scalarExpounded = true; + break; + default: + throw new Error('JPX Error: Invalid SQcd value ' + sqcd); + } + qcd.noQuantization = (spqcdSize === 8); + qcd.scalarExpounded = scalarExpounded; + qcd.guardBits = sqcd >> 5; + spqcds = []; + while (j < length + position) { + var spqcd = {}; + if (spqcdSize === 8) { + spqcd.epsilon = data[j++] >> 3; + spqcd.mu = 0; + } else { + spqcd.epsilon = data[j] >> 3; + spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1]; + j += 2; + } + spqcds.push(spqcd); + } + qcd.SPqcds = spqcds; + if (context.mainHeader) { + context.QCD = qcd; + } else { + context.currentTile.QCD = qcd; + context.currentTile.QCC = []; + } + break; + case 0xFF5D: // Quantization component (QCC) + length = readUint16(data, position); + var qcc = {}; + j = position + 2; + var cqcc; + if (context.SIZ.Csiz < 257) { + cqcc = data[j++]; + } else { + cqcc = readUint16(data, j); + j += 2; + } + sqcd = data[j++]; + switch (sqcd & 0x1F) { + case 0: + spqcdSize = 8; + scalarExpounded = true; + break; + case 1: + spqcdSize = 16; + scalarExpounded = false; + break; + case 2: + spqcdSize = 16; + scalarExpounded = true; + break; + default: + throw new Error('JPX Error: Invalid SQcd value ' + sqcd); + } + qcc.noQuantization = (spqcdSize === 8); + qcc.scalarExpounded = scalarExpounded; + qcc.guardBits = sqcd >> 5; + spqcds = []; + while (j < (length + position)) { + spqcd = {}; + if (spqcdSize === 8) { + spqcd.epsilon = data[j++] >> 3; + spqcd.mu = 0; + } else { + spqcd.epsilon = data[j] >> 3; + spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1]; + j += 2; + } + spqcds.push(spqcd); + } + qcc.SPqcds = spqcds; + if (context.mainHeader) { + context.QCC[cqcc] = qcc; + } else { + context.currentTile.QCC[cqcc] = qcc; + } + break; + case 0xFF52: // Coding style default (COD) + length = readUint16(data, position); + var cod = {}; + j = position + 2; + var scod = data[j++]; + cod.entropyCoderWithCustomPrecincts = !!(scod & 1); + cod.sopMarkerUsed = !!(scod & 2); + cod.ephMarkerUsed = !!(scod & 4); + cod.progressionOrder = data[j++]; + cod.layersCount = readUint16(data, j); + j += 2; + cod.multipleComponentTransform = data[j++]; + + cod.decompositionLevelsCount = data[j++]; + cod.xcb = (data[j++] & 0xF) + 2; + cod.ycb = (data[j++] & 0xF) + 2; + var blockStyle = data[j++]; + cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1); + cod.resetContextProbabilities = !!(blockStyle & 2); + cod.terminationOnEachCodingPass = !!(blockStyle & 4); + cod.verticalyStripe = !!(blockStyle & 8); + cod.predictableTermination = !!(blockStyle & 16); + cod.segmentationSymbolUsed = !!(blockStyle & 32); + cod.reversibleTransformation = data[j++]; + if (cod.entropyCoderWithCustomPrecincts) { + var precinctsSizes = []; + while (j < length + position) { + var precinctsSize = data[j++]; + precinctsSizes.push({ + PPx: precinctsSize & 0xF, + PPy: precinctsSize >> 4 + }); + } + cod.precinctsSizes = precinctsSizes; + } + var unsupported = []; + if (cod.selectiveArithmeticCodingBypass) { + unsupported.push('selectiveArithmeticCodingBypass'); + } + if (cod.resetContextProbabilities) { + unsupported.push('resetContextProbabilities'); + } + if (cod.terminationOnEachCodingPass) { + unsupported.push('terminationOnEachCodingPass'); + } + if (cod.verticalyStripe) { + unsupported.push('verticalyStripe'); + } + if (cod.predictableTermination) { + unsupported.push('predictableTermination'); + } + if (unsupported.length > 0) { + doNotRecover = true; + throw new Error('JPX Error: Unsupported COD options (' + + unsupported.join(', ') + ')'); + } + if (context.mainHeader) { + context.COD = cod; + } else { + context.currentTile.COD = cod; + context.currentTile.COC = []; + } + break; + case 0xFF90: // Start of tile-part (SOT) + length = readUint16(data, position); + tile = {}; + tile.index = readUint16(data, position + 2); + tile.length = readUint32(data, position + 4); + tile.dataEnd = tile.length + position - 2; + tile.partIndex = data[position + 8]; + tile.partsCount = data[position + 9]; + + context.mainHeader = false; + if (tile.partIndex === 0) { + // reset component specific settings + tile.COD = context.COD; + tile.COC = context.COC.slice(0); // clone of the global COC + tile.QCD = context.QCD; + tile.QCC = context.QCC.slice(0); // clone of the global COC + } + context.currentTile = tile; + break; + case 0xFF93: // Start of data (SOD) + tile = context.currentTile; + if (tile.partIndex === 0) { + initializeTile(context, tile.index); + buildPackets(context); + } + + // moving to the end of the data + length = tile.dataEnd - position; + parseTilePackets(context, data, position, length); + break; + case 0xFF55: // Tile-part lengths, main header (TLM) + case 0xFF57: // Packet length, main header (PLM) + case 0xFF58: // Packet length, tile-part header (PLT) + case 0xFF64: // Comment (COM) + length = readUint16(data, position); + // skipping content + break; + case 0xFF53: // Coding style component (COC) + throw new Error('JPX Error: Codestream code 0xFF53 (COC) is ' + + 'not implemented'); + default: + throw new Error('JPX Error: Unknown codestream code: ' + + code.toString(16)); + } + position += length; + } + } catch (e) { + if (doNotRecover || this.failOnCorruptedImage) { + throw e; + } else { + warn('Trying to recover from ' + e.message); + } + } + this.tiles = transformComponents(context); + this.width = context.SIZ.Xsiz - context.SIZ.XOsiz; + this.height = context.SIZ.Ysiz - context.SIZ.YOsiz; + this.componentsCount = context.SIZ.Csiz; + } + }; + function calculateComponentDimensions(component, siz) { + // Section B.2 Component mapping + component.x0 = Math.ceil(siz.XOsiz / component.XRsiz); + component.x1 = Math.ceil(siz.Xsiz / component.XRsiz); + component.y0 = Math.ceil(siz.YOsiz / component.YRsiz); + component.y1 = Math.ceil(siz.Ysiz / component.YRsiz); + component.width = component.x1 - component.x0; + component.height = component.y1 - component.y0; + } + function calculateTileGrids(context, components) { + var siz = context.SIZ; + // Section B.3 Division into tile and tile-components + var tile, tiles = []; + var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz); + var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz); + for (var q = 0; q < numYtiles; q++) { + for (var p = 0; p < numXtiles; p++) { + tile = {}; + tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz); + tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz); + tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz); + tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz); + tile.width = tile.tx1 - tile.tx0; + tile.height = tile.ty1 - tile.ty0; + tile.components = []; + tiles.push(tile); + } + } + context.tiles = tiles; + + var componentsCount = siz.Csiz; + for (var i = 0, ii = componentsCount; i < ii; i++) { + var component = components[i]; + for (var j = 0, jj = tiles.length; j < jj; j++) { + var tileComponent = {}; + tile = tiles[j]; + tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz); + tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz); + tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz); + tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz); + tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0; + tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0; + tile.components[i] = tileComponent; + } + } + } + function getBlocksDimensions(context, component, r) { + var codOrCoc = component.codingStyleParameters; + var result = {}; + if (!codOrCoc.entropyCoderWithCustomPrecincts) { + result.PPx = 15; + result.PPy = 15; + } else { + result.PPx = codOrCoc.precinctsSizes[r].PPx; + result.PPy = codOrCoc.precinctsSizes[r].PPy; + } + // calculate codeblock size as described in section B.7 + result.xcb_ = (r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) : + Math.min(codOrCoc.xcb, result.PPx)); + result.ycb_ = (r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) : + Math.min(codOrCoc.ycb, result.PPy)); + return result; + } + function buildPrecincts(context, resolution, dimensions) { + // Section B.6 Division resolution to precincts + var precinctWidth = 1 << dimensions.PPx; + var precinctHeight = 1 << dimensions.PPy; + // Jasper introduces codeblock groups for mapping each subband codeblocks + // to precincts. Precinct partition divides a resolution according to width + // and height parameters. The subband that belongs to the resolution level + // has a different size than the level, unless it is the zero resolution. + + // From Jasper documentation: jpeg2000.pdf, section K: Tier-2 coding: + // The precinct partitioning for a particular subband is derived from a + // partitioning of its parent LL band (i.e., the LL band at the next higher + // resolution level)... The LL band associated with each resolution level is + // divided into precincts... Each of the resulting precinct regions is then + // mapped into its child subbands (if any) at the next lower resolution + // level. This is accomplished by using the coordinate transformation + // (u, v) = (ceil(x/2), ceil(y/2)) where (x, y) and (u, v) are the + // coordinates of a point in the LL band and child subband, respectively. + var isZeroRes = resolution.resLevel === 0; + var precinctWidthInSubband = 1 << (dimensions.PPx + (isZeroRes ? 0 : -1)); + var precinctHeightInSubband = 1 << (dimensions.PPy + (isZeroRes ? 0 : -1)); + var numprecinctswide = (resolution.trx1 > resolution.trx0 ? + Math.ceil(resolution.trx1 / precinctWidth) - + Math.floor(resolution.trx0 / precinctWidth) : 0); + var numprecinctshigh = (resolution.try1 > resolution.try0 ? + Math.ceil(resolution.try1 / precinctHeight) - + Math.floor(resolution.try0 / precinctHeight) : 0); + var numprecincts = numprecinctswide * numprecinctshigh; + + resolution.precinctParameters = { + precinctWidth: precinctWidth, + precinctHeight: precinctHeight, + numprecinctswide: numprecinctswide, + numprecinctshigh: numprecinctshigh, + numprecincts: numprecincts, + precinctWidthInSubband: precinctWidthInSubband, + precinctHeightInSubband: precinctHeightInSubband + }; + } + function buildCodeblocks(context, subband, dimensions) { + // Section B.7 Division sub-band into code-blocks + var xcb_ = dimensions.xcb_; + var ycb_ = dimensions.ycb_; + var codeblockWidth = 1 << xcb_; + var codeblockHeight = 1 << ycb_; + var cbx0 = subband.tbx0 >> xcb_; + var cby0 = subband.tby0 >> ycb_; + var cbx1 = (subband.tbx1 + codeblockWidth - 1) >> xcb_; + var cby1 = (subband.tby1 + codeblockHeight - 1) >> ycb_; + var precinctParameters = subband.resolution.precinctParameters; + var codeblocks = []; + var precincts = []; + var i, j, codeblock, precinctNumber; + for (j = cby0; j < cby1; j++) { + for (i = cbx0; i < cbx1; i++) { + codeblock = { + cbx: i, + cby: j, + tbx0: codeblockWidth * i, + tby0: codeblockHeight * j, + tbx1: codeblockWidth * (i + 1), + tby1: codeblockHeight * (j + 1) + }; + + codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0); + codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0); + codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1); + codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1); + + // Calculate precinct number for this codeblock, codeblock position + // should be relative to its subband, use actual dimension and position + // See comment about codeblock group width and height + var pi = Math.floor((codeblock.tbx0_ - subband.tbx0) / + precinctParameters.precinctWidthInSubband); + var pj = Math.floor((codeblock.tby0_ - subband.tby0) / + precinctParameters.precinctHeightInSubband); + precinctNumber = pi + (pj * precinctParameters.numprecinctswide); + + codeblock.precinctNumber = precinctNumber; + codeblock.subbandType = subband.type; + codeblock.Lblock = 3; + + if (codeblock.tbx1_ <= codeblock.tbx0_ || + codeblock.tby1_ <= codeblock.tby0_) { + continue; + } + codeblocks.push(codeblock); + // building precinct for the sub-band + var precinct = precincts[precinctNumber]; + if (precinct !== undefined) { + if (i < precinct.cbxMin) { + precinct.cbxMin = i; + } else if (i > precinct.cbxMax) { + precinct.cbxMax = i; + } + if (j < precinct.cbyMin) { + precinct.cbxMin = j; + } else if (j > precinct.cbyMax) { + precinct.cbyMax = j; + } + } else { + precincts[precinctNumber] = precinct = { + cbxMin: i, + cbyMin: j, + cbxMax: i, + cbyMax: j + }; + } + codeblock.precinct = precinct; + } + } + subband.codeblockParameters = { + codeblockWidth: xcb_, + codeblockHeight: ycb_, + numcodeblockwide: cbx1 - cbx0 + 1, + numcodeblockhigh: cby1 - cby0 + 1 + }; + subband.codeblocks = codeblocks; + subband.precincts = precincts; + } + function createPacket(resolution, precinctNumber, layerNumber) { + var precinctCodeblocks = []; + // Section B.10.8 Order of info in packet + var subbands = resolution.subbands; + // sub-bands already ordered in 'LL', 'HL', 'LH', and 'HH' sequence + for (var i = 0, ii = subbands.length; i < ii; i++) { + var subband = subbands[i]; + var codeblocks = subband.codeblocks; + for (var j = 0, jj = codeblocks.length; j < jj; j++) { + var codeblock = codeblocks[j]; + if (codeblock.precinctNumber !== precinctNumber) { + continue; + } + precinctCodeblocks.push(codeblock); + } + } + return { + layerNumber: layerNumber, + codeblocks: precinctCodeblocks + }; + } + function LayerResolutionComponentPositionIterator(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var layersCount = tile.codingStyleDefaultParameters.layersCount; + var componentsCount = siz.Csiz; + var maxDecompositionLevelsCount = 0; + for (var q = 0; q < componentsCount; q++) { + maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, + tile.components[q].codingStyleParameters.decompositionLevelsCount); + } + + var l = 0, r = 0, i = 0, k = 0; + + this.nextPacket = function JpxImage_nextPacket() { + // Section B.12.1.1 Layer-resolution-component-position + for (; l < layersCount; l++) { + for (; r <= maxDecompositionLevelsCount; r++) { + for (; i < componentsCount; i++) { + var component = tile.components[i]; + if (r > component.codingStyleParameters.decompositionLevelsCount) { + continue; + } + + var resolution = component.resolutions[r]; + var numprecincts = resolution.precinctParameters.numprecincts; + for (; k < numprecincts;) { + var packet = createPacket(resolution, k, l); + k++; + return packet; + } + k = 0; + } + i = 0; + } + r = 0; + } + throw new Error('JPX Error: Out of packets'); + }; + } + function ResolutionLayerComponentPositionIterator(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var layersCount = tile.codingStyleDefaultParameters.layersCount; + var componentsCount = siz.Csiz; + var maxDecompositionLevelsCount = 0; + for (var q = 0; q < componentsCount; q++) { + maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, + tile.components[q].codingStyleParameters.decompositionLevelsCount); + } + + var r = 0, l = 0, i = 0, k = 0; + + this.nextPacket = function JpxImage_nextPacket() { + // Section B.12.1.2 Resolution-layer-component-position + for (; r <= maxDecompositionLevelsCount; r++) { + for (; l < layersCount; l++) { + for (; i < componentsCount; i++) { + var component = tile.components[i]; + if (r > component.codingStyleParameters.decompositionLevelsCount) { + continue; + } + + var resolution = component.resolutions[r]; + var numprecincts = resolution.precinctParameters.numprecincts; + for (; k < numprecincts;) { + var packet = createPacket(resolution, k, l); + k++; + return packet; + } + k = 0; + } + i = 0; + } + l = 0; + } + throw new Error('JPX Error: Out of packets'); + }; + } + function ResolutionPositionComponentLayerIterator(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var layersCount = tile.codingStyleDefaultParameters.layersCount; + var componentsCount = siz.Csiz; + var l, r, c, p; + var maxDecompositionLevelsCount = 0; + for (c = 0; c < componentsCount; c++) { + var component = tile.components[c]; + maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, + component.codingStyleParameters.decompositionLevelsCount); + } + var maxNumPrecinctsInLevel = new Int32Array( + maxDecompositionLevelsCount + 1); + for (r = 0; r <= maxDecompositionLevelsCount; ++r) { + var maxNumPrecincts = 0; + for (c = 0; c < componentsCount; ++c) { + var resolutions = tile.components[c].resolutions; + if (r < resolutions.length) { + maxNumPrecincts = Math.max(maxNumPrecincts, + resolutions[r].precinctParameters.numprecincts); + } + } + maxNumPrecinctsInLevel[r] = maxNumPrecincts; + } + l = 0; + r = 0; + c = 0; + p = 0; + + this.nextPacket = function JpxImage_nextPacket() { + // Section B.12.1.3 Resolution-position-component-layer + for (; r <= maxDecompositionLevelsCount; r++) { + for (; p < maxNumPrecinctsInLevel[r]; p++) { + for (; c < componentsCount; c++) { + var component = tile.components[c]; + if (r > component.codingStyleParameters.decompositionLevelsCount) { + continue; + } + var resolution = component.resolutions[r]; + var numprecincts = resolution.precinctParameters.numprecincts; + if (p >= numprecincts) { + continue; + } + for (; l < layersCount;) { + var packet = createPacket(resolution, p, l); + l++; + return packet; + } + l = 0; + } + c = 0; + } + p = 0; + } + throw new Error('JPX Error: Out of packets'); + }; + } + function PositionComponentResolutionLayerIterator(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var layersCount = tile.codingStyleDefaultParameters.layersCount; + var componentsCount = siz.Csiz; + var precinctsSizes = getPrecinctSizesInImageScale(tile); + var precinctsIterationSizes = precinctsSizes; + var l = 0, r = 0, c = 0, px = 0, py = 0; + + this.nextPacket = function JpxImage_nextPacket() { + // Section B.12.1.4 Position-component-resolution-layer + for (; py < precinctsIterationSizes.maxNumHigh; py++) { + for (; px < precinctsIterationSizes.maxNumWide; px++) { + for (; c < componentsCount; c++) { + var component = tile.components[c]; + var decompositionLevelsCount = + component.codingStyleParameters.decompositionLevelsCount; + for (; r <= decompositionLevelsCount; r++) { + var resolution = component.resolutions[r]; + var sizeInImageScale = + precinctsSizes.components[c].resolutions[r]; + var k = getPrecinctIndexIfExist( + px, + py, + sizeInImageScale, + precinctsIterationSizes, + resolution); + if (k === null) { + continue; + } + for (; l < layersCount;) { + var packet = createPacket(resolution, k, l); + l++; + return packet; + } + l = 0; + } + r = 0; + } + c = 0; + } + px = 0; + } + throw new Error('JPX Error: Out of packets'); + }; + } + function ComponentPositionResolutionLayerIterator(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var layersCount = tile.codingStyleDefaultParameters.layersCount; + var componentsCount = siz.Csiz; + var precinctsSizes = getPrecinctSizesInImageScale(tile); + var l = 0, r = 0, c = 0, px = 0, py = 0; + + this.nextPacket = function JpxImage_nextPacket() { + // Section B.12.1.5 Component-position-resolution-layer + for (; c < componentsCount; ++c) { + var component = tile.components[c]; + var precinctsIterationSizes = precinctsSizes.components[c]; + var decompositionLevelsCount = + component.codingStyleParameters.decompositionLevelsCount; + for (; py < precinctsIterationSizes.maxNumHigh; py++) { + for (; px < precinctsIterationSizes.maxNumWide; px++) { + for (; r <= decompositionLevelsCount; r++) { + var resolution = component.resolutions[r]; + var sizeInImageScale = precinctsIterationSizes.resolutions[r]; + var k = getPrecinctIndexIfExist( + px, + py, + sizeInImageScale, + precinctsIterationSizes, + resolution); + if (k === null) { + continue; + } + for (; l < layersCount;) { + var packet = createPacket(resolution, k, l); + l++; + return packet; + } + l = 0; + } + r = 0; + } + px = 0; + } + py = 0; + } + throw new Error('JPX Error: Out of packets'); + }; + } + function getPrecinctIndexIfExist( + pxIndex, pyIndex, sizeInImageScale, precinctIterationSizes, resolution) { + var posX = pxIndex * precinctIterationSizes.minWidth; + var posY = pyIndex * precinctIterationSizes.minHeight; + if (posX % sizeInImageScale.width !== 0 || + posY % sizeInImageScale.height !== 0) { + return null; + } + var startPrecinctRowIndex = + (posY / sizeInImageScale.width) * + resolution.precinctParameters.numprecinctswide; + return (posX / sizeInImageScale.height) + startPrecinctRowIndex; + } + function getPrecinctSizesInImageScale(tile) { + var componentsCount = tile.components.length; + var minWidth = Number.MAX_VALUE; + var minHeight = Number.MAX_VALUE; + var maxNumWide = 0; + var maxNumHigh = 0; + var sizePerComponent = new Array(componentsCount); + for (var c = 0; c < componentsCount; c++) { + var component = tile.components[c]; + var decompositionLevelsCount = + component.codingStyleParameters.decompositionLevelsCount; + var sizePerResolution = new Array(decompositionLevelsCount + 1); + var minWidthCurrentComponent = Number.MAX_VALUE; + var minHeightCurrentComponent = Number.MAX_VALUE; + var maxNumWideCurrentComponent = 0; + var maxNumHighCurrentComponent = 0; + var scale = 1; + for (var r = decompositionLevelsCount; r >= 0; --r) { + var resolution = component.resolutions[r]; + var widthCurrentResolution = + scale * resolution.precinctParameters.precinctWidth; + var heightCurrentResolution = + scale * resolution.precinctParameters.precinctHeight; + minWidthCurrentComponent = Math.min( + minWidthCurrentComponent, + widthCurrentResolution); + minHeightCurrentComponent = Math.min( + minHeightCurrentComponent, + heightCurrentResolution); + maxNumWideCurrentComponent = Math.max(maxNumWideCurrentComponent, + resolution.precinctParameters.numprecinctswide); + maxNumHighCurrentComponent = Math.max(maxNumHighCurrentComponent, + resolution.precinctParameters.numprecinctshigh); + sizePerResolution[r] = { + width: widthCurrentResolution, + height: heightCurrentResolution + }; + scale <<= 1; + } + minWidth = Math.min(minWidth, minWidthCurrentComponent); + minHeight = Math.min(minHeight, minHeightCurrentComponent); + maxNumWide = Math.max(maxNumWide, maxNumWideCurrentComponent); + maxNumHigh = Math.max(maxNumHigh, maxNumHighCurrentComponent); + sizePerComponent[c] = { + resolutions: sizePerResolution, + minWidth: minWidthCurrentComponent, + minHeight: minHeightCurrentComponent, + maxNumWide: maxNumWideCurrentComponent, + maxNumHigh: maxNumHighCurrentComponent + }; + } + return { + components: sizePerComponent, + minWidth: minWidth, + minHeight: minHeight, + maxNumWide: maxNumWide, + maxNumHigh: maxNumHigh + }; + } + function buildPackets(context) { + var siz = context.SIZ; + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var componentsCount = siz.Csiz; + // Creating resolutions and sub-bands for each component + for (var c = 0; c < componentsCount; c++) { + var component = tile.components[c]; + var decompositionLevelsCount = + component.codingStyleParameters.decompositionLevelsCount; + // Section B.5 Resolution levels and sub-bands + var resolutions = []; + var subbands = []; + for (var r = 0; r <= decompositionLevelsCount; r++) { + var blocksDimensions = getBlocksDimensions(context, component, r); + var resolution = {}; + var scale = 1 << (decompositionLevelsCount - r); + resolution.trx0 = Math.ceil(component.tcx0 / scale); + resolution.try0 = Math.ceil(component.tcy0 / scale); + resolution.trx1 = Math.ceil(component.tcx1 / scale); + resolution.try1 = Math.ceil(component.tcy1 / scale); + resolution.resLevel = r; + buildPrecincts(context, resolution, blocksDimensions); + resolutions.push(resolution); + + var subband; + if (r === 0) { + // one sub-band (LL) with last decomposition + subband = {}; + subband.type = 'LL'; + subband.tbx0 = Math.ceil(component.tcx0 / scale); + subband.tby0 = Math.ceil(component.tcy0 / scale); + subband.tbx1 = Math.ceil(component.tcx1 / scale); + subband.tby1 = Math.ceil(component.tcy1 / scale); + subband.resolution = resolution; + buildCodeblocks(context, subband, blocksDimensions); + subbands.push(subband); + resolution.subbands = [subband]; + } else { + var bscale = 1 << (decompositionLevelsCount - r + 1); + var resolutionSubbands = []; + // three sub-bands (HL, LH and HH) with rest of decompositions + subband = {}; + subband.type = 'HL'; + subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5); + subband.tby0 = Math.ceil(component.tcy0 / bscale); + subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5); + subband.tby1 = Math.ceil(component.tcy1 / bscale); + subband.resolution = resolution; + buildCodeblocks(context, subband, blocksDimensions); + subbands.push(subband); + resolutionSubbands.push(subband); + + subband = {}; + subband.type = 'LH'; + subband.tbx0 = Math.ceil(component.tcx0 / bscale); + subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5); + subband.tbx1 = Math.ceil(component.tcx1 / bscale); + subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5); + subband.resolution = resolution; + buildCodeblocks(context, subband, blocksDimensions); + subbands.push(subband); + resolutionSubbands.push(subband); + + subband = {}; + subband.type = 'HH'; + subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5); + subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5); + subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5); + subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5); + subband.resolution = resolution; + buildCodeblocks(context, subband, blocksDimensions); + subbands.push(subband); + resolutionSubbands.push(subband); + + resolution.subbands = resolutionSubbands; + } + } + component.resolutions = resolutions; + component.subbands = subbands; + } + // Generate the packets sequence + var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder; + switch (progressionOrder) { + case 0: + tile.packetsIterator = + new LayerResolutionComponentPositionIterator(context); + break; + case 1: + tile.packetsIterator = + new ResolutionLayerComponentPositionIterator(context); + break; + case 2: + tile.packetsIterator = + new ResolutionPositionComponentLayerIterator(context); + break; + case 3: + tile.packetsIterator = + new PositionComponentResolutionLayerIterator(context); + break; + case 4: + tile.packetsIterator = + new ComponentPositionResolutionLayerIterator(context); + break; + default: + throw new Error('JPX Error: Unsupported progression order ' + + progressionOrder); + } + } + function parseTilePackets(context, data, offset, dataLength) { + var position = 0; + var buffer, bufferSize = 0, skipNextBit = false; + function readBits(count) { + while (bufferSize < count) { + var b = data[offset + position]; + position++; + if (skipNextBit) { + buffer = (buffer << 7) | b; + bufferSize += 7; + skipNextBit = false; + } else { + buffer = (buffer << 8) | b; + bufferSize += 8; + } + if (b === 0xFF) { + skipNextBit = true; + } + } + bufferSize -= count; + return (buffer >>> bufferSize) & ((1 << count) - 1); + } + function skipMarkerIfEqual(value) { + if (data[offset + position - 1] === 0xFF && + data[offset + position] === value) { + skipBytes(1); + return true; + } else if (data[offset + position] === 0xFF && + data[offset + position + 1] === value) { + skipBytes(2); + return true; + } + return false; + } + function skipBytes(count) { + position += count; + } + function alignToByte() { + bufferSize = 0; + if (skipNextBit) { + position++; + skipNextBit = false; + } + } + function readCodingpasses() { + if (readBits(1) === 0) { + return 1; + } + if (readBits(1) === 0) { + return 2; + } + var value = readBits(2); + if (value < 3) { + return value + 3; + } + value = readBits(5); + if (value < 31) { + return value + 6; + } + value = readBits(7); + return value + 37; + } + var tileIndex = context.currentTile.index; + var tile = context.tiles[tileIndex]; + var sopMarkerUsed = context.COD.sopMarkerUsed; + var ephMarkerUsed = context.COD.ephMarkerUsed; + var packetsIterator = tile.packetsIterator; + while (position < dataLength) { + alignToByte(); + if (sopMarkerUsed && skipMarkerIfEqual(0x91)) { + // Skip also marker segment length and packet sequence ID + skipBytes(4); + } + var packet = packetsIterator.nextPacket(); + if (!readBits(1)) { + continue; + } + var layerNumber = packet.layerNumber; + var queue = [], codeblock; + for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) { + codeblock = packet.codeblocks[i]; + var precinct = codeblock.precinct; + var codeblockColumn = codeblock.cbx - precinct.cbxMin; + var codeblockRow = codeblock.cby - precinct.cbyMin; + var codeblockIncluded = false; + var firstTimeInclusion = false; + var valueReady; + if (codeblock['included'] !== undefined) { + codeblockIncluded = !!readBits(1); + } else { + // reading inclusion tree + precinct = codeblock.precinct; + var inclusionTree, zeroBitPlanesTree; + if (precinct['inclusionTree'] !== undefined) { + inclusionTree = precinct.inclusionTree; + } else { + // building inclusion and zero bit-planes trees + var width = precinct.cbxMax - precinct.cbxMin + 1; + var height = precinct.cbyMax - precinct.cbyMin + 1; + inclusionTree = new InclusionTree(width, height, layerNumber); + zeroBitPlanesTree = new TagTree(width, height); + precinct.inclusionTree = inclusionTree; + precinct.zeroBitPlanesTree = zeroBitPlanesTree; + } + + if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) { + while (true) { + if (readBits(1)) { + valueReady = !inclusionTree.nextLevel(); + if (valueReady) { + codeblock.included = true; + codeblockIncluded = firstTimeInclusion = true; + break; + } + } else { + inclusionTree.incrementValue(layerNumber); + break; + } + } + } + } + if (!codeblockIncluded) { + continue; + } + if (firstTimeInclusion) { + zeroBitPlanesTree = precinct.zeroBitPlanesTree; + zeroBitPlanesTree.reset(codeblockColumn, codeblockRow); + while (true) { + if (readBits(1)) { + valueReady = !zeroBitPlanesTree.nextLevel(); + if (valueReady) { + break; + } + } else { + zeroBitPlanesTree.incrementValue(); + } + } + codeblock.zeroBitPlanes = zeroBitPlanesTree.value; + } + var codingpasses = readCodingpasses(); + while (readBits(1)) { + codeblock.Lblock++; + } + var codingpassesLog2 = log2(codingpasses); + // rounding down log2 + var bits = ((codingpasses < (1 << codingpassesLog2)) ? + codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock; + var codedDataLength = readBits(bits); + queue.push({ + codeblock: codeblock, + codingpasses: codingpasses, + dataLength: codedDataLength + }); + } + alignToByte(); + if (ephMarkerUsed) { + skipMarkerIfEqual(0x92); + } + while (queue.length > 0) { + var packetItem = queue.shift(); + codeblock = packetItem.codeblock; + if (codeblock['data'] === undefined) { + codeblock.data = []; + } + codeblock.data.push({ + data: data, + start: offset + position, + end: offset + position + packetItem.dataLength, + codingpasses: packetItem.codingpasses + }); + position += packetItem.dataLength; + } + } + return position; + } + function copyCoefficients(coefficients, levelWidth, levelHeight, subband, + delta, mb, reversible, segmentationSymbolUsed) { + var x0 = subband.tbx0; + var y0 = subband.tby0; + var width = subband.tbx1 - subband.tbx0; + var codeblocks = subband.codeblocks; + var right = subband.type.charAt(0) === 'H' ? 1 : 0; + var bottom = subband.type.charAt(1) === 'H' ? levelWidth : 0; + + for (var i = 0, ii = codeblocks.length; i < ii; ++i) { + var codeblock = codeblocks[i]; + var blockWidth = codeblock.tbx1_ - codeblock.tbx0_; + var blockHeight = codeblock.tby1_ - codeblock.tby0_; + if (blockWidth === 0 || blockHeight === 0) { + continue; + } + if (codeblock['data'] === undefined) { + continue; + } + + var bitModel, currentCodingpassType; + bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType, + codeblock.zeroBitPlanes, mb); + currentCodingpassType = 2; // first bit plane starts from cleanup + + // collect data + var data = codeblock.data, totalLength = 0, codingpasses = 0; + var j, jj, dataItem; + for (j = 0, jj = data.length; j < jj; j++) { + dataItem = data[j]; + totalLength += dataItem.end - dataItem.start; + codingpasses += dataItem.codingpasses; + } + var encodedData = new Uint8Array(totalLength); + var position = 0; + for (j = 0, jj = data.length; j < jj; j++) { + dataItem = data[j]; + var chunk = dataItem.data.subarray(dataItem.start, dataItem.end); + encodedData.set(chunk, position); + position += chunk.length; + } + // decoding the item + var decoder = new ArithmeticDecoder(encodedData, 0, totalLength); + bitModel.setDecoder(decoder); + + for (j = 0; j < codingpasses; j++) { + switch (currentCodingpassType) { + case 0: + bitModel.runSignificancePropogationPass(); + break; + case 1: + bitModel.runMagnitudeRefinementPass(); + break; + case 2: + bitModel.runCleanupPass(); + if (segmentationSymbolUsed) { + bitModel.checkSegmentationSymbol(); + } + break; + } + currentCodingpassType = (currentCodingpassType + 1) % 3; + } + + var offset = (codeblock.tbx0_ - x0) + (codeblock.tby0_ - y0) * width; + var sign = bitModel.coefficentsSign; + var magnitude = bitModel.coefficentsMagnitude; + var bitsDecoded = bitModel.bitsDecoded; + var magnitudeCorrection = reversible ? 0 : 0.5; + var k, n, nb; + position = 0; + // Do the interleaving of Section F.3.3 here, so we do not need + // to copy later. LL level is not interleaved, just copied. + var interleave = (subband.type !== 'LL'); + for (j = 0; j < blockHeight; j++) { + var row = (offset / width) | 0; // row in the non-interleaved subband + var levelOffset = 2 * row * (levelWidth - width) + right + bottom; + for (k = 0; k < blockWidth; k++) { + n = magnitude[position]; + if (n !== 0) { + n = (n + magnitudeCorrection) * delta; + if (sign[position] !== 0) { + n = -n; + } + nb = bitsDecoded[position]; + var pos = interleave ? (levelOffset + (offset << 1)) : offset; + if (reversible && (nb >= mb)) { + coefficients[pos] = n; + } else { + coefficients[pos] = n * (1 << (mb - nb)); + } + } + offset++; + position++; + } + offset += width - blockWidth; + } + } + } + function transformTile(context, tile, c) { + var component = tile.components[c]; + var codingStyleParameters = component.codingStyleParameters; + var quantizationParameters = component.quantizationParameters; + var decompositionLevelsCount = + codingStyleParameters.decompositionLevelsCount; + var spqcds = quantizationParameters.SPqcds; + var scalarExpounded = quantizationParameters.scalarExpounded; + var guardBits = quantizationParameters.guardBits; + var segmentationSymbolUsed = codingStyleParameters.segmentationSymbolUsed; + var precision = context.components[c].precision; + + var reversible = codingStyleParameters.reversibleTransformation; + var transform = (reversible ? new ReversibleTransform() : + new IrreversibleTransform()); + + var subbandCoefficients = []; + var b = 0; + for (var i = 0; i <= decompositionLevelsCount; i++) { + var resolution = component.resolutions[i]; + + var width = resolution.trx1 - resolution.trx0; + var height = resolution.try1 - resolution.try0; + // Allocate space for the whole sublevel. + var coefficients = new Float32Array(width * height); + + for (var j = 0, jj = resolution.subbands.length; j < jj; j++) { + var mu, epsilon; + if (!scalarExpounded) { + // formula E-5 + mu = spqcds[0].mu; + epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0); + } else { + mu = spqcds[b].mu; + epsilon = spqcds[b].epsilon; + b++; + } + + var subband = resolution.subbands[j]; + var gainLog2 = SubbandsGainLog2[subband.type]; + + // calulate quantization coefficient (Section E.1.1.1) + var delta = (reversible ? 1 : + Math.pow(2, precision + gainLog2 - epsilon) * (1 + mu / 2048)); + var mb = (guardBits + epsilon - 1); + + // In the first resolution level, copyCoefficients will fill the + // whole array with coefficients. In the succeding passes, + // copyCoefficients will consecutively fill in the values that belong + // to the interleaved positions of the HL, LH, and HH coefficients. + // The LL coefficients will then be interleaved in Transform.iterate(). + copyCoefficients(coefficients, width, height, subband, delta, mb, + reversible, segmentationSymbolUsed); + } + subbandCoefficients.push({ + width: width, + height: height, + items: coefficients + }); + } + + var result = transform.calculate(subbandCoefficients, + component.tcx0, component.tcy0); + return { + left: component.tcx0, + top: component.tcy0, + width: result.width, + height: result.height, + items: result.items + }; + } + function transformComponents(context) { + var siz = context.SIZ; + var components = context.components; + var componentsCount = siz.Csiz; + var resultImages = []; + for (var i = 0, ii = context.tiles.length; i < ii; i++) { + var tile = context.tiles[i]; + var transformedTiles = []; + var c; + for (c = 0; c < componentsCount; c++) { + transformedTiles[c] = transformTile(context, tile, c); + } + var tile0 = transformedTiles[0]; + var out = new Uint8Array(tile0.items.length * componentsCount); + var result = { + left: tile0.left, + top: tile0.top, + width: tile0.width, + height: tile0.height, + items: out + }; + + // Section G.2.2 Inverse multi component transform + var shift, offset, max, min, maxK; + var pos = 0, j, jj, y0, y1, y2, r, g, b, k, val; + if (tile.codingStyleDefaultParameters.multipleComponentTransform) { + var fourComponents = componentsCount === 4; + var y0items = transformedTiles[0].items; + var y1items = transformedTiles[1].items; + var y2items = transformedTiles[2].items; + var y3items = fourComponents ? transformedTiles[3].items : null; + + // HACK: The multiple component transform formulas below assume that + // all components have the same precision. With this in mind, we + // compute shift and offset only once. + shift = components[0].precision - 8; + offset = (128 << shift) + 0.5; + max = 255 * (1 << shift); + maxK = max * 0.5; + min = -maxK; + + var component0 = tile.components[0]; + var alpha01 = componentsCount - 3; + jj = y0items.length; + if (!component0.codingStyleParameters.reversibleTransformation) { + // inverse irreversible multiple component transform + for (j = 0; j < jj; j++, pos += alpha01) { + y0 = y0items[j] + offset; + y1 = y1items[j]; + y2 = y2items[j]; + r = y0 + 1.402 * y2; + g = y0 - 0.34413 * y1 - 0.71414 * y2; + b = y0 + 1.772 * y1; + out[pos++] = r <= 0 ? 0 : r >= max ? 255 : r >> shift; + out[pos++] = g <= 0 ? 0 : g >= max ? 255 : g >> shift; + out[pos++] = b <= 0 ? 0 : b >= max ? 255 : b >> shift; + } + } else { + // inverse reversible multiple component transform + for (j = 0; j < jj; j++, pos += alpha01) { + y0 = y0items[j] + offset; + y1 = y1items[j]; + y2 = y2items[j]; + g = y0 - ((y2 + y1) >> 2); + r = g + y2; + b = g + y1; + out[pos++] = r <= 0 ? 0 : r >= max ? 255 : r >> shift; + out[pos++] = g <= 0 ? 0 : g >= max ? 255 : g >> shift; + out[pos++] = b <= 0 ? 0 : b >= max ? 255 : b >> shift; + } + } + if (fourComponents) { + for (j = 0, pos = 3; j < jj; j++, pos += 4) { + k = y3items[j]; + out[pos] = k <= min ? 0 : k >= maxK ? 255 : (k + offset) >> shift; + } + } + } else { // no multi-component transform + for (c = 0; c < componentsCount; c++) { + var items = transformedTiles[c].items; + shift = components[c].precision - 8; + offset = (128 << shift) + 0.5; + max = (127.5 * (1 << shift)); + min = -max; + for (pos = c, j = 0, jj = items.length; j < jj; j++) { + val = items[j]; + out[pos] = val <= min ? 0 : + val >= max ? 255 : (val + offset) >> shift; + pos += componentsCount; + } + } + } + resultImages.push(result); + } + return resultImages; + } + function initializeTile(context, tileIndex) { + var siz = context.SIZ; + var componentsCount = siz.Csiz; + var tile = context.tiles[tileIndex]; + for (var c = 0; c < componentsCount; c++) { + var component = tile.components[c]; + var qcdOrQcc = (context.currentTile.QCC[c] !== undefined ? + context.currentTile.QCC[c] : context.currentTile.QCD); + component.quantizationParameters = qcdOrQcc; + var codOrCoc = (context.currentTile.COC[c] !== undefined ? + context.currentTile.COC[c] : context.currentTile.COD); + component.codingStyleParameters = codOrCoc; + } + tile.codingStyleDefaultParameters = context.currentTile.COD; + } + + // Section B.10.2 Tag trees + var TagTree = (function TagTreeClosure() { + function TagTree(width, height) { + var levelsLength = log2(Math.max(width, height)) + 1; + this.levels = []; + for (var i = 0; i < levelsLength; i++) { + var level = { + width: width, + height: height, + items: [] + }; + this.levels.push(level); + width = Math.ceil(width / 2); + height = Math.ceil(height / 2); + } + } + TagTree.prototype = { + reset: function TagTree_reset(i, j) { + var currentLevel = 0, value = 0, level; + while (currentLevel < this.levels.length) { + level = this.levels[currentLevel]; + var index = i + j * level.width; + if (level.items[index] !== undefined) { + value = level.items[index]; + break; + } + level.index = index; + i >>= 1; + j >>= 1; + currentLevel++; + } + currentLevel--; + level = this.levels[currentLevel]; + level.items[level.index] = value; + this.currentLevel = currentLevel; + delete this.value; + }, + incrementValue: function TagTree_incrementValue() { + var level = this.levels[this.currentLevel]; + level.items[level.index]++; + }, + nextLevel: function TagTree_nextLevel() { + var currentLevel = this.currentLevel; + var level = this.levels[currentLevel]; + var value = level.items[level.index]; + currentLevel--; + if (currentLevel < 0) { + this.value = value; + return false; + } + + this.currentLevel = currentLevel; + level = this.levels[currentLevel]; + level.items[level.index] = value; + return true; + } + }; + return TagTree; + })(); + + var InclusionTree = (function InclusionTreeClosure() { + function InclusionTree(width, height, defaultValue) { + var levelsLength = log2(Math.max(width, height)) + 1; + this.levels = []; + for (var i = 0; i < levelsLength; i++) { + var items = new Uint8Array(width * height); + for (var j = 0, jj = items.length; j < jj; j++) { + items[j] = defaultValue; + } + + var level = { + width: width, + height: height, + items: items + }; + this.levels.push(level); + + width = Math.ceil(width / 2); + height = Math.ceil(height / 2); + } + } + InclusionTree.prototype = { + reset: function InclusionTree_reset(i, j, stopValue) { + var currentLevel = 0; + while (currentLevel < this.levels.length) { + var level = this.levels[currentLevel]; + var index = i + j * level.width; + level.index = index; + var value = level.items[index]; + + if (value === 0xFF) { + break; + } + + if (value > stopValue) { + this.currentLevel = currentLevel; + // already know about this one, propagating the value to top levels + this.propagateValues(); + return false; + } + + i >>= 1; + j >>= 1; + currentLevel++; + } + this.currentLevel = currentLevel - 1; + return true; + }, + incrementValue: function InclusionTree_incrementValue(stopValue) { + var level = this.levels[this.currentLevel]; + level.items[level.index] = stopValue + 1; + this.propagateValues(); + }, + propagateValues: function InclusionTree_propagateValues() { + var levelIndex = this.currentLevel; + var level = this.levels[levelIndex]; + var currentValue = level.items[level.index]; + while (--levelIndex >= 0) { + level = this.levels[levelIndex]; + level.items[level.index] = currentValue; + } + }, + nextLevel: function InclusionTree_nextLevel() { + var currentLevel = this.currentLevel; + var level = this.levels[currentLevel]; + var value = level.items[level.index]; + level.items[level.index] = 0xFF; + currentLevel--; + if (currentLevel < 0) { + return false; + } + + this.currentLevel = currentLevel; + level = this.levels[currentLevel]; + level.items[level.index] = value; + return true; + } + }; + return InclusionTree; + })(); + + // Section D. Coefficient bit modeling + var BitModel = (function BitModelClosure() { + var UNIFORM_CONTEXT = 17; + var RUNLENGTH_CONTEXT = 18; + // Table D-1 + // The index is binary presentation: 0dddvvhh, ddd - sum of Di (0..4), + // vv - sum of Vi (0..2), and hh - sum of Hi (0..2) + var LLAndLHContextsLabel = new Uint8Array([ + 0, 5, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 1, 6, 8, 0, 3, 7, 8, 0, 4, + 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, + 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8 + ]); + var HLContextLabel = new Uint8Array([ + 0, 3, 4, 0, 5, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 1, 3, 4, 0, 6, 7, 7, 0, 8, + 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, + 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8 + ]); + var HHContextLabel = new Uint8Array([ + 0, 1, 2, 0, 1, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 3, 4, 5, 0, 4, 5, 5, 0, 5, + 5, 5, 0, 0, 0, 0, 0, 6, 7, 7, 0, 7, 7, 7, 0, 7, 7, 7, 0, 0, 0, 0, 0, 8, 8, + 8, 0, 8, 8, 8, 0, 8, 8, 8, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8 + ]); + + function BitModel(width, height, subband, zeroBitPlanes, mb) { + this.width = width; + this.height = height; + + this.contextLabelTable = (subband === 'HH' ? HHContextLabel : + (subband === 'HL' ? HLContextLabel : LLAndLHContextsLabel)); + + var coefficientCount = width * height; + + // coefficients outside the encoding region treated as insignificant + // add border state cells for significanceState + this.neighborsSignificance = new Uint8Array(coefficientCount); + this.coefficentsSign = new Uint8Array(coefficientCount); + this.coefficentsMagnitude = mb > 14 ? new Uint32Array(coefficientCount) : + mb > 6 ? new Uint16Array(coefficientCount) : + new Uint8Array(coefficientCount); + this.processingFlags = new Uint8Array(coefficientCount); + + var bitsDecoded = new Uint8Array(coefficientCount); + if (zeroBitPlanes !== 0) { + for (var i = 0; i < coefficientCount; i++) { + bitsDecoded[i] = zeroBitPlanes; + } + } + this.bitsDecoded = bitsDecoded; + + this.reset(); + } + + BitModel.prototype = { + setDecoder: function BitModel_setDecoder(decoder) { + this.decoder = decoder; + }, + reset: function BitModel_reset() { + // We have 17 contexts that are accessed via context labels, + // plus the uniform and runlength context. + this.contexts = new Int8Array(19); + + // Contexts are packed into 1 byte: + // highest 7 bits carry the index, lowest bit carries mps + this.contexts[0] = (4 << 1) | 0; + this.contexts[UNIFORM_CONTEXT] = (46 << 1) | 0; + this.contexts[RUNLENGTH_CONTEXT] = (3 << 1) | 0; + }, + setNeighborsSignificance: + function BitModel_setNeighborsSignificance(row, column, index) { + var neighborsSignificance = this.neighborsSignificance; + var width = this.width, height = this.height; + var left = (column > 0); + var right = (column + 1 < width); + var i; + + if (row > 0) { + i = index - width; + if (left) { + neighborsSignificance[i - 1] += 0x10; + } + if (right) { + neighborsSignificance[i + 1] += 0x10; + } + neighborsSignificance[i] += 0x04; + } + + if (row + 1 < height) { + i = index + width; + if (left) { + neighborsSignificance[i - 1] += 0x10; + } + if (right) { + neighborsSignificance[i + 1] += 0x10; + } + neighborsSignificance[i] += 0x04; + } + + if (left) { + neighborsSignificance[index - 1] += 0x01; + } + if (right) { + neighborsSignificance[index + 1] += 0x01; + } + neighborsSignificance[index] |= 0x80; + }, + runSignificancePropogationPass: + function BitModel_runSignificancePropogationPass() { + var decoder = this.decoder; + var width = this.width, height = this.height; + var coefficentsMagnitude = this.coefficentsMagnitude; + var coefficentsSign = this.coefficentsSign; + var neighborsSignificance = this.neighborsSignificance; + var processingFlags = this.processingFlags; + var contexts = this.contexts; + var labels = this.contextLabelTable; + var bitsDecoded = this.bitsDecoded; + var processedInverseMask = ~1; + var processedMask = 1; + var firstMagnitudeBitMask = 2; + + for (var i0 = 0; i0 < height; i0 += 4) { + for (var j = 0; j < width; j++) { + var index = i0 * width + j; + for (var i1 = 0; i1 < 4; i1++, index += width) { + var i = i0 + i1; + if (i >= height) { + break; + } + // clear processed flag first + processingFlags[index] &= processedInverseMask; + + if (coefficentsMagnitude[index] || + !neighborsSignificance[index]) { + continue; + } + + var contextLabel = labels[neighborsSignificance[index]]; + var decision = decoder.readBit(contexts, contextLabel); + if (decision) { + var sign = this.decodeSignBit(i, j, index); + coefficentsSign[index] = sign; + coefficentsMagnitude[index] = 1; + this.setNeighborsSignificance(i, j, index); + processingFlags[index] |= firstMagnitudeBitMask; + } + bitsDecoded[index]++; + processingFlags[index] |= processedMask; + } + } + } + }, + decodeSignBit: function BitModel_decodeSignBit(row, column, index) { + var width = this.width, height = this.height; + var coefficentsMagnitude = this.coefficentsMagnitude; + var coefficentsSign = this.coefficentsSign; + var contribution, sign0, sign1, significance1; + var contextLabel, decoded; + + // calculate horizontal contribution + significance1 = (column > 0 && coefficentsMagnitude[index - 1] !== 0); + if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) { + sign1 = coefficentsSign[index + 1]; + if (significance1) { + sign0 = coefficentsSign[index - 1]; + contribution = 1 - sign1 - sign0; + } else { + contribution = 1 - sign1 - sign1; + } + } else if (significance1) { + sign0 = coefficentsSign[index - 1]; + contribution = 1 - sign0 - sign0; + } else { + contribution = 0; + } + var horizontalContribution = 3 * contribution; + + // calculate vertical contribution and combine with the horizontal + significance1 = (row > 0 && coefficentsMagnitude[index - width] !== 0); + if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) { + sign1 = coefficentsSign[index + width]; + if (significance1) { + sign0 = coefficentsSign[index - width]; + contribution = 1 - sign1 - sign0 + horizontalContribution; + } else { + contribution = 1 - sign1 - sign1 + horizontalContribution; + } + } else if (significance1) { + sign0 = coefficentsSign[index - width]; + contribution = 1 - sign0 - sign0 + horizontalContribution; + } else { + contribution = horizontalContribution; + } + + if (contribution >= 0) { + contextLabel = 9 + contribution; + decoded = this.decoder.readBit(this.contexts, contextLabel); + } else { + contextLabel = 9 - contribution; + decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1; + } + return decoded; + }, + runMagnitudeRefinementPass: + function BitModel_runMagnitudeRefinementPass() { + var decoder = this.decoder; + var width = this.width, height = this.height; + var coefficentsMagnitude = this.coefficentsMagnitude; + var neighborsSignificance = this.neighborsSignificance; + var contexts = this.contexts; + var bitsDecoded = this.bitsDecoded; + var processingFlags = this.processingFlags; + var processedMask = 1; + var firstMagnitudeBitMask = 2; + var length = width * height; + var width4 = width * 4; + + for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) { + indexNext = Math.min(length, index0 + width4); + for (var j = 0; j < width; j++) { + for (var index = index0 + j; index < indexNext; index += width) { + + // significant but not those that have just become + if (!coefficentsMagnitude[index] || + (processingFlags[index] & processedMask) !== 0) { + continue; + } + + var contextLabel = 16; + if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) { + processingFlags[index] ^= firstMagnitudeBitMask; + // first refinement + var significance = neighborsSignificance[index] & 127; + contextLabel = significance === 0 ? 15 : 14; + } + + var bit = decoder.readBit(contexts, contextLabel); + coefficentsMagnitude[index] = + (coefficentsMagnitude[index] << 1) | bit; + bitsDecoded[index]++; + processingFlags[index] |= processedMask; + } + } + } + }, + runCleanupPass: function BitModel_runCleanupPass() { + var decoder = this.decoder; + var width = this.width, height = this.height; + var neighborsSignificance = this.neighborsSignificance; + var coefficentsMagnitude = this.coefficentsMagnitude; + var coefficentsSign = this.coefficentsSign; + var contexts = this.contexts; + var labels = this.contextLabelTable; + var bitsDecoded = this.bitsDecoded; + var processingFlags = this.processingFlags; + var processedMask = 1; + var firstMagnitudeBitMask = 2; + var oneRowDown = width; + var twoRowsDown = width * 2; + var threeRowsDown = width * 3; + var iNext; + for (var i0 = 0; i0 < height; i0 = iNext) { + iNext = Math.min(i0 + 4, height); + var indexBase = i0 * width; + var checkAllEmpty = i0 + 3 < height; + for (var j = 0; j < width; j++) { + var index0 = indexBase + j; + // using the property: labels[neighborsSignificance[index]] === 0 + // when neighborsSignificance[index] === 0 + var allEmpty = (checkAllEmpty && + processingFlags[index0] === 0 && + processingFlags[index0 + oneRowDown] === 0 && + processingFlags[index0 + twoRowsDown] === 0 && + processingFlags[index0 + threeRowsDown] === 0 && + neighborsSignificance[index0] === 0 && + neighborsSignificance[index0 + oneRowDown] === 0 && + neighborsSignificance[index0 + twoRowsDown] === 0 && + neighborsSignificance[index0 + threeRowsDown] === 0); + var i1 = 0, index = index0; + var i = i0, sign; + if (allEmpty) { + var hasSignificantCoefficent = + decoder.readBit(contexts, RUNLENGTH_CONTEXT); + if (!hasSignificantCoefficent) { + bitsDecoded[index0]++; + bitsDecoded[index0 + oneRowDown]++; + bitsDecoded[index0 + twoRowsDown]++; + bitsDecoded[index0 + threeRowsDown]++; + continue; // next column + } + i1 = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) | + decoder.readBit(contexts, UNIFORM_CONTEXT); + if (i1 !== 0) { + i = i0 + i1; + index += i1 * width; + } + + sign = this.decodeSignBit(i, j, index); + coefficentsSign[index] = sign; + coefficentsMagnitude[index] = 1; + this.setNeighborsSignificance(i, j, index); + processingFlags[index] |= firstMagnitudeBitMask; + + index = index0; + for (var i2 = i0; i2 <= i; i2++, index += width) { + bitsDecoded[index]++; + } + + i1++; + } + for (i = i0 + i1; i < iNext; i++, index += width) { + if (coefficentsMagnitude[index] || + (processingFlags[index] & processedMask) !== 0) { + continue; + } + + var contextLabel = labels[neighborsSignificance[index]]; + var decision = decoder.readBit(contexts, contextLabel); + if (decision === 1) { + sign = this.decodeSignBit(i, j, index); + coefficentsSign[index] = sign; + coefficentsMagnitude[index] = 1; + this.setNeighborsSignificance(i, j, index); + processingFlags[index] |= firstMagnitudeBitMask; + } + bitsDecoded[index]++; + } + } + } + }, + checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() { + var decoder = this.decoder; + var contexts = this.contexts; + var symbol = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 3) | + (decoder.readBit(contexts, UNIFORM_CONTEXT) << 2) | + (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) | + decoder.readBit(contexts, UNIFORM_CONTEXT); + if (symbol !== 0xA) { + throw new Error('JPX Error: Invalid segmentation symbol'); + } + } + }; + + return BitModel; + })(); + + // Section F, Discrete wavelet transformation + var Transform = (function TransformClosure() { + function Transform() {} + + Transform.prototype.calculate = + function transformCalculate(subbands, u0, v0) { + var ll = subbands[0]; + for (var i = 1, ii = subbands.length; i < ii; i++) { + ll = this.iterate(ll, subbands[i], u0, v0); + } + return ll; + }; + Transform.prototype.extend = function extend(buffer, offset, size) { + // Section F.3.7 extending... using max extension of 4 + var i1 = offset - 1, j1 = offset + 1; + var i2 = offset + size - 2, j2 = offset + size; + buffer[i1--] = buffer[j1++]; + buffer[j2++] = buffer[i2--]; + buffer[i1--] = buffer[j1++]; + buffer[j2++] = buffer[i2--]; + buffer[i1--] = buffer[j1++]; + buffer[j2++] = buffer[i2--]; + buffer[i1] = buffer[j1]; + buffer[j2] = buffer[i2]; + }; + Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh, + u0, v0) { + var llWidth = ll.width, llHeight = ll.height, llItems = ll.items; + var width = hl_lh_hh.width; + var height = hl_lh_hh.height; + var items = hl_lh_hh.items; + var i, j, k, l, u, v; + + // Interleave LL according to Section F.3.3 + for (k = 0, i = 0; i < llHeight; i++) { + l = i * 2 * width; + for (j = 0; j < llWidth; j++, k++, l += 2) { + items[l] = llItems[k]; + } + } + // The LL band is not needed anymore. + llItems = ll.items = null; + + var bufferPadding = 4; + var rowBuffer = new Float32Array(width + 2 * bufferPadding); + + // Section F.3.4 HOR_SR + if (width === 1) { + // if width = 1, when u0 even keep items as is, when odd divide by 2 + if ((u0 & 1) !== 0) { + for (v = 0, k = 0; v < height; v++, k += width) { + items[k] *= 0.5; + } + } + } else { + for (v = 0, k = 0; v < height; v++, k += width) { + rowBuffer.set(items.subarray(k, k + width), bufferPadding); + + this.extend(rowBuffer, bufferPadding, width); + this.filter(rowBuffer, bufferPadding, width); + + items.set( + rowBuffer.subarray(bufferPadding, bufferPadding + width), + k); + } + } + + // Accesses to the items array can take long, because it may not fit into + // CPU cache and has to be fetched from main memory. Since subsequent + // accesses to the items array are not local when reading columns, we + // have a cache miss every time. To reduce cache misses, get up to + // 'numBuffers' items at a time and store them into the individual + // buffers. The colBuffers should be small enough to fit into CPU cache. + var numBuffers = 16; + var colBuffers = []; + for (i = 0; i < numBuffers; i++) { + colBuffers.push(new Float32Array(height + 2 * bufferPadding)); + } + var b, currentBuffer = 0; + ll = bufferPadding + height; + + // Section F.3.5 VER_SR + if (height === 1) { + // if height = 1, when v0 even keep items as is, when odd divide by 2 + if ((v0 & 1) !== 0) { + for (u = 0; u < width; u++) { + items[u] *= 0.5; + } + } + } else { + for (u = 0; u < width; u++) { + // if we ran out of buffers, copy several image columns at once + if (currentBuffer === 0) { + numBuffers = Math.min(width - u, numBuffers); + for (k = u, l = bufferPadding; l < ll; k += width, l++) { + for (b = 0; b < numBuffers; b++) { + colBuffers[b][l] = items[k + b]; + } + } + currentBuffer = numBuffers; + } + + currentBuffer--; + var buffer = colBuffers[currentBuffer]; + this.extend(buffer, bufferPadding, height); + this.filter(buffer, bufferPadding, height); + + // If this is last buffer in this group of buffers, flush all buffers. + if (currentBuffer === 0) { + k = u - numBuffers + 1; + for (l = bufferPadding; l < ll; k += width, l++) { + for (b = 0; b < numBuffers; b++) { + items[k + b] = colBuffers[b][l]; + } + } + } + } + } + + return { + width: width, + height: height, + items: items + }; + }; + return Transform; + })(); + + // Section 3.8.2 Irreversible 9-7 filter + var IrreversibleTransform = (function IrreversibleTransformClosure() { + function IrreversibleTransform() { + Transform.call(this); + } + + IrreversibleTransform.prototype = Object.create(Transform.prototype); + IrreversibleTransform.prototype.filter = + function irreversibleTransformFilter(x, offset, length) { + var len = length >> 1; + offset = offset | 0; + var j, n, current, next; + + var alpha = -1.586134342059924; + var beta = -0.052980118572961; + var gamma = 0.882911075530934; + var delta = 0.443506852043971; + var K = 1.230174104914001; + var K_ = 1 / K; + + // step 1 is combined with step 3 + + // step 2 + j = offset - 3; + for (n = len + 4; n--; j += 2) { + x[j] *= K_; + } + + // step 1 & 3 + j = offset - 2; + current = delta * x[j -1]; + for (n = len + 3; n--; j += 2) { + next = delta * x[j + 1]; + x[j] = K * x[j] - current - next; + if (n--) { + j += 2; + current = delta * x[j + 1]; + x[j] = K * x[j] - current - next; + } else { + break; + } + } + + // step 4 + j = offset - 1; + current = gamma * x[j - 1]; + for (n = len + 2; n--; j += 2) { + next = gamma * x[j + 1]; + x[j] -= current + next; + if (n--) { + j += 2; + current = gamma * x[j + 1]; + x[j] -= current + next; + } else { + break; + } + } + + // step 5 + j = offset; + current = beta * x[j - 1]; + for (n = len + 1; n--; j += 2) { + next = beta * x[j + 1]; + x[j] -= current + next; + if (n--) { + j += 2; + current = beta * x[j + 1]; + x[j] -= current + next; + } else { + break; + } + } + + // step 6 + if (len !== 0) { + j = offset + 1; + current = alpha * x[j - 1]; + for (n = len; n--; j += 2) { + next = alpha * x[j + 1]; + x[j] -= current + next; + if (n--) { + j += 2; + current = alpha * x[j + 1]; + x[j] -= current + next; + } else { + break; + } + } + } + }; + + return IrreversibleTransform; + })(); + + // Section 3.8.1 Reversible 5-3 filter + var ReversibleTransform = (function ReversibleTransformClosure() { + function ReversibleTransform() { + Transform.call(this); + } + + ReversibleTransform.prototype = Object.create(Transform.prototype); + ReversibleTransform.prototype.filter = + function reversibleTransformFilter(x, offset, length) { + var len = length >> 1; + offset = offset | 0; + var j, n; + + for (j = offset, n = len + 1; n--; j += 2) { + x[j] -= (x[j - 1] + x[j + 1] + 2) >> 2; + } + + for (j = offset + 1, n = len; n--; j += 2) { + x[j] += (x[j - 1] + x[j + 1]) >> 1; + } + }; + + return ReversibleTransform; + })(); + + return JpxImage; +})(); + +exports.JpxImage = JpxImage; +})); + + + +(function (root, factory) { + { + factory((root.pdfjsCoreMurmurHash3 = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var Uint32ArrayView = sharedUtil.Uint32ArrayView; + +var MurmurHash3_64 = (function MurmurHash3_64Closure (seed) { + // Workaround for missing math precison in JS. + var MASK_HIGH = 0xffff0000; + var MASK_LOW = 0xffff; + + function MurmurHash3_64 (seed) { + var SEED = 0xc3d2e1f0; + this.h1 = seed ? seed & 0xffffffff : SEED; + this.h2 = seed ? seed & 0xffffffff : SEED; + } + + var alwaysUseUint32ArrayView = false; + // old webkits have issues with non-aligned arrays + try { + new Uint32Array(new Uint8Array(5).buffer, 0, 1); + } catch (e) { + alwaysUseUint32ArrayView = true; + } + + MurmurHash3_64.prototype = { + update: function MurmurHash3_64_update(input) { + var useUint32ArrayView = alwaysUseUint32ArrayView; + var i; + if (typeof input === 'string') { + var data = new Uint8Array(input.length * 2); + var length = 0; + for (i = 0; i < input.length; i++) { + var code = input.charCodeAt(i); + if (code <= 0xff) { + data[length++] = code; + } + else { + data[length++] = code >>> 8; + data[length++] = code & 0xff; + } + } + } else if (input instanceof Uint8Array) { + data = input; + length = data.length; + } else if (typeof input === 'object' && ('length' in input)) { + // processing regular arrays as well, e.g. for IE9 + data = input; + length = data.length; + useUint32ArrayView = true; + } else { + throw new Error('Wrong data format in MurmurHash3_64_update. ' + + 'Input must be a string or array.'); + } + + var blockCounts = length >> 2; + var tailLength = length - blockCounts * 4; + // we don't care about endianness here + var dataUint32 = useUint32ArrayView ? + new Uint32ArrayView(data, blockCounts) : + new Uint32Array(data.buffer, 0, blockCounts); + var k1 = 0; + var k2 = 0; + var h1 = this.h1; + var h2 = this.h2; + var C1 = 0xcc9e2d51; + var C2 = 0x1b873593; + var C1_LOW = C1 & MASK_LOW; + var C2_LOW = C2 & MASK_LOW; + + for (i = 0; i < blockCounts; i++) { + if (i & 1) { + k1 = dataUint32[i]; + k1 = (k1 * C1 & MASK_HIGH) | (k1 * C1_LOW & MASK_LOW); + k1 = k1 << 15 | k1 >>> 17; + k1 = (k1 * C2 & MASK_HIGH) | (k1 * C2_LOW & MASK_LOW); + h1 ^= k1; + h1 = h1 << 13 | h1 >>> 19; + h1 = h1 * 5 + 0xe6546b64; + } else { + k2 = dataUint32[i]; + k2 = (k2 * C1 & MASK_HIGH) | (k2 * C1_LOW & MASK_LOW); + k2 = k2 << 15 | k2 >>> 17; + k2 = (k2 * C2 & MASK_HIGH) | (k2 * C2_LOW & MASK_LOW); + h2 ^= k2; + h2 = h2 << 13 | h2 >>> 19; + h2 = h2 * 5 + 0xe6546b64; + } + } + + k1 = 0; + + switch (tailLength) { + case 3: + k1 ^= data[blockCounts * 4 + 2] << 16; + /* falls through */ + case 2: + k1 ^= data[blockCounts * 4 + 1] << 8; + /* falls through */ + case 1: + k1 ^= data[blockCounts * 4]; + /* falls through */ + k1 = (k1 * C1 & MASK_HIGH) | (k1 * C1_LOW & MASK_LOW); + k1 = k1 << 15 | k1 >>> 17; + k1 = (k1 * C2 & MASK_HIGH) | (k1 * C2_LOW & MASK_LOW); + if (blockCounts & 1) { + h1 ^= k1; + } else { + h2 ^= k1; + } + } + + this.h1 = h1; + this.h2 = h2; + return this; + }, + + hexdigest: function MurmurHash3_64_hexdigest () { + var h1 = this.h1; + var h2 = this.h2; + + h1 ^= h2 >>> 1; + h1 = (h1 * 0xed558ccd & MASK_HIGH) | (h1 * 0x8ccd & MASK_LOW); + h2 = (h2 * 0xff51afd7 & MASK_HIGH) | + (((h2 << 16 | h1 >>> 16) * 0xafd7ed55 & MASK_HIGH) >>> 16); + h1 ^= h2 >>> 1; + h1 = (h1 * 0x1a85ec53 & MASK_HIGH) | (h1 * 0xec53 & MASK_LOW); + h2 = (h2 * 0xc4ceb9fe & MASK_HIGH) | + (((h2 << 16 | h1 >>> 16) * 0xb9fe1a85 & MASK_HIGH) >>> 16); + h1 ^= h2 >>> 1; + + for (var i = 0, arr = [h1, h2], str = ''; i < arr.length; i++) { + var hex = (arr[i] >>> 0).toString(16); + while (hex.length < 8) { + hex = '0' + hex; + } + str += hex; + } + + return str; + } + }; + + return MurmurHash3_64; +})(); + +exports.MurmurHash3_64 = MurmurHash3_64; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCorePrimitives = {}), root.pdfjsSharedUtil); + } +}(this, function (exports, sharedUtil) { + +var isArray = sharedUtil.isArray; + +var Name = (function NameClosure() { + function Name(name) { + this.name = name; + } + + Name.prototype = {}; + + var nameCache = {}; + + Name.get = function Name_get(name) { + var nameValue = nameCache[name]; + return (nameValue ? nameValue : (nameCache[name] = new Name(name))); + }; + + return Name; +})(); + +var Cmd = (function CmdClosure() { + function Cmd(cmd) { + this.cmd = cmd; + } + + Cmd.prototype = {}; + + var cmdCache = {}; + + Cmd.get = function Cmd_get(cmd) { + var cmdValue = cmdCache[cmd]; + return (cmdValue ? cmdValue : (cmdCache[cmd] = new Cmd(cmd))); + }; + + return Cmd; +})(); + +var Dict = (function DictClosure() { + var nonSerializable = function nonSerializableClosure() { + return nonSerializable; // creating closure on some variable + }; + + var GETALL_DICTIONARY_TYPES_WHITELIST = { + 'Background': true, + 'ExtGState': true, + 'Halftone': true, + 'Layout': true, + 'Mask': true, + 'Pagination': true, + 'Printing': true + }; + + function isRecursionAllowedFor(dict) { + if (!isName(dict.Type)) { + return true; + } + var dictType = dict.Type.name; + return GETALL_DICTIONARY_TYPES_WHITELIST[dictType] === true; + } + + // xref is optional + function Dict(xref) { + // Map should only be used internally, use functions below to access. + this.map = Object.create(null); + this.xref = xref; + this.objId = null; + this.__nonSerializable__ = nonSerializable; // disable cloning of the Dict + } + + Dict.prototype = { + assignXref: function Dict_assignXref(newXref) { + this.xref = newXref; + }, + + // automatically dereferences Ref objects + get: function Dict_get(key1, key2, key3) { + var value; + var xref = this.xref; + if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || + typeof key2 === 'undefined') { + return xref ? xref.fetchIfRef(value) : value; + } + if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || + typeof key3 === 'undefined') { + return xref ? xref.fetchIfRef(value) : value; + } + value = this.map[key3] || null; + return xref ? xref.fetchIfRef(value) : value; + }, + + // Same as get(), but returns a promise and uses fetchIfRefAsync(). + getAsync: function Dict_getAsync(key1, key2, key3) { + var value; + var xref = this.xref; + if (typeof (value = this.map[key1]) !== 'undefined' || key1 in this.map || + typeof key2 === 'undefined') { + if (xref) { + return xref.fetchIfRefAsync(value); + } + return Promise.resolve(value); + } + if (typeof (value = this.map[key2]) !== 'undefined' || key2 in this.map || + typeof key3 === 'undefined') { + if (xref) { + return xref.fetchIfRefAsync(value); + } + return Promise.resolve(value); + } + value = this.map[key3] || null; + if (xref) { + return xref.fetchIfRefAsync(value); + } + return Promise.resolve(value); + }, + + // Same as get(), but dereferences all elements if the result is an Array. + getArray: function Dict_getArray(key1, key2, key3) { + var value = this.get(key1, key2, key3); + var xref = this.xref; + if (!isArray(value) || !xref) { + return value; + } + value = value.slice(); // Ensure that we don't modify the Dict data. + for (var i = 0, ii = value.length; i < ii; i++) { + if (!isRef(value[i])) { + continue; + } + value[i] = xref.fetch(value[i]); + } + return value; + }, + + // no dereferencing + getRaw: function Dict_getRaw(key) { + return this.map[key]; + }, + + // creates new map and dereferences all Refs + getAll: function Dict_getAll() { + var all = Object.create(null); + var queue = null; + var key, obj; + for (key in this.map) { + obj = this.get(key); + if (obj instanceof Dict) { + if (isRecursionAllowedFor(obj)) { + (queue || (queue = [])).push({target: all, key: key, obj: obj}); + } else { + all[key] = this.getRaw(key); + } + } else { + all[key] = obj; + } + } + if (!queue) { + return all; + } + + // trying to take cyclic references into the account + var processed = Object.create(null); + while (queue.length > 0) { + var item = queue.shift(); + var itemObj = item.obj; + var objId = itemObj.objId; + if (objId && objId in processed) { + item.target[item.key] = processed[objId]; + continue; + } + var dereferenced = Object.create(null); + for (key in itemObj.map) { + obj = itemObj.get(key); + if (obj instanceof Dict) { + if (isRecursionAllowedFor(obj)) { + queue.push({target: dereferenced, key: key, obj: obj}); + } else { + dereferenced[key] = itemObj.getRaw(key); + } + } else { + dereferenced[key] = obj; + } + } + if (objId) { + processed[objId] = dereferenced; + } + item.target[item.key] = dereferenced; + } + return all; + }, + + getKeys: function Dict_getKeys() { + return Object.keys(this.map); + }, + + set: function Dict_set(key, value) { + this.map[key] = value; + }, + + has: function Dict_has(key) { + return key in this.map; + }, + + forEach: function Dict_forEach(callback) { + for (var key in this.map) { + callback(key, this.get(key)); + } + } + }; + + Dict.empty = new Dict(null); + + Dict.merge = function Dict_merge(xref, dictArray) { + var mergedDict = new Dict(xref); + + for (var i = 0, ii = dictArray.length; i < ii; i++) { + var dict = dictArray[i]; + if (!isDict(dict)) { + continue; + } + for (var keyName in dict.map) { + if (mergedDict.map[keyName]) { + continue; + } + mergedDict.map[keyName] = dict.map[keyName]; + } + } + return mergedDict; + }; + + return Dict; +})(); + +var Ref = (function RefClosure() { + function Ref(num, gen) { + this.num = num; + this.gen = gen; + } + + Ref.prototype = { + toString: function Ref_toString() { + // This function is hot, so we make the string as compact as possible. + // |this.gen| is almost always zero, so we treat that case specially. + var str = this.num + 'R'; + if (this.gen !== 0) { + str += this.gen; + } + return str; + } + }; + + return Ref; +})(); + +// The reference is identified by number and generation. +// This structure stores only one instance of the reference. +var RefSet = (function RefSetClosure() { + function RefSet() { + this.dict = {}; + } + + RefSet.prototype = { + has: function RefSet_has(ref) { + return ref.toString() in this.dict; + }, + + put: function RefSet_put(ref) { + this.dict[ref.toString()] = true; + }, + + remove: function RefSet_remove(ref) { + delete this.dict[ref.toString()]; + } + }; + + return RefSet; +})(); + +var RefSetCache = (function RefSetCacheClosure() { + function RefSetCache() { + this.dict = Object.create(null); + } + + RefSetCache.prototype = { + get: function RefSetCache_get(ref) { + return this.dict[ref.toString()]; + }, + + has: function RefSetCache_has(ref) { + return ref.toString() in this.dict; + }, + + put: function RefSetCache_put(ref, obj) { + this.dict[ref.toString()] = obj; + }, + + putAlias: function RefSetCache_putAlias(ref, aliasRef) { + this.dict[ref.toString()] = this.get(aliasRef); + }, + + forEach: function RefSetCache_forEach(fn, thisArg) { + for (var i in this.dict) { + fn.call(thisArg, this.dict[i]); + } + }, + + clear: function RefSetCache_clear() { + this.dict = Object.create(null); + } + }; + + return RefSetCache; +})(); + +function isName(v) { + return v instanceof Name; +} + +function isCmd(v, cmd) { + return v instanceof Cmd && (cmd === undefined || 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 isRef(v) { + return v instanceof Ref; +} + +function isStream(v) { + return typeof v === 'object' && v !== null && v.getBytes !== undefined; +} + +exports.Cmd = Cmd; +exports.Dict = Dict; +exports.Name = Name; +exports.Ref = Ref; +exports.RefSet = RefSet; +exports.RefSetCache = RefSetCache; +exports.isCmd = isCmd; +exports.isDict = isDict; +exports.isName = isName; +exports.isRef = isRef; +exports.isStream = isStream; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreStream = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreJbig2, root.pdfjsCoreJpg, + root.pdfjsCoreJpx); + } +}(this, function (exports, sharedUtil, corePrimitives, coreJbig2, coreJpg, + coreJpx) { + +var Util = sharedUtil.Util; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var shadow = sharedUtil.shadow; +var warn = sharedUtil.warn; +var Dict = corePrimitives.Dict; +var Jbig2Image = coreJbig2.Jbig2Image; +var JpegImage = coreJpg.JpegImage; +var JpxImage = coreJpx.JpxImage; + +var coreParser; // see _setCoreParser below +var EOF; // = coreParser.EOF; +var Lexer; // = coreParser.Lexer; + +var coreColorSpace; // see _setCoreColorSpace below +var ColorSpace; // = coreColorSpace.ColorSpace; + +var Stream = (function StreamClosure() { + function Stream(arrayBuffer, start, length, dict) { + this.bytes = (arrayBuffer instanceof Uint8Array ? + arrayBuffer : new Uint8Array(arrayBuffer)); + this.start = start || 0; + this.pos = this.start; + this.end = (start + length) || this.bytes.length; + this.dict = dict; + } + + // required methods for a stream. if a particular stream does not + // implement these, an error should be thrown + Stream.prototype = { + get length() { + return this.end - this.start; + }, + get isEmpty() { + return this.length === 0; + }, + getByte: function Stream_getByte() { + if (this.pos >= this.end) { + return -1; + } + return this.bytes[this.pos++]; + }, + getUint16: function Stream_getUint16() { + var b0 = this.getByte(); + var b1 = this.getByte(); + if (b0 === -1 || b1 === -1) { + return -1; + } + return (b0 << 8) + b1; + }, + getInt32: function Stream_getInt32() { + var b0 = this.getByte(); + var b1 = this.getByte(); + var b2 = this.getByte(); + var b3 = this.getByte(); + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + }, + // returns subarray of original buffer + // should only be read + getBytes: function Stream_getBytes(length) { + var bytes = this.bytes; + var pos = this.pos; + var strEnd = this.end; + + if (!length) { + return bytes.subarray(pos, strEnd); + } + var end = pos + length; + if (end > strEnd) { + end = strEnd; + } + this.pos = end; + return bytes.subarray(pos, end); + }, + peekByte: function Stream_peekByte() { + var peekedByte = this.getByte(); + this.pos--; + return peekedByte; + }, + peekBytes: function Stream_peekBytes(length) { + var bytes = this.getBytes(length); + this.pos -= bytes.length; + return bytes; + }, + skip: function Stream_skip(n) { + if (!n) { + n = 1; + } + this.pos += n; + }, + reset: function Stream_reset() { + this.pos = this.start; + }, + moveStart: function Stream_moveStart() { + this.start = this.pos; + }, + makeSubStream: function Stream_makeSubStream(start, length, dict) { + return new Stream(this.bytes.buffer, start, length, dict); + }, + isStream: true + }; + + return Stream; +})(); + +var StringStream = (function StringStreamClosure() { + function StringStream(str) { + var length = str.length; + var bytes = new Uint8Array(length); + for (var n = 0; n < length; ++n) { + bytes[n] = str.charCodeAt(n); + } + Stream.call(this, bytes); + } + + StringStream.prototype = Stream.prototype; + + return StringStream; +})(); + +// super class for the decoding streams +var DecodeStream = (function DecodeStreamClosure() { + // Lots of DecodeStreams are created whose buffers are never used. For these + // we share a single empty buffer. This is (a) space-efficient and (b) avoids + // having special cases that would be required if we used |null| for an empty + // buffer. + var emptyBuffer = new Uint8Array(0); + + function DecodeStream(maybeMinBufferLength) { + this.pos = 0; + this.bufferLength = 0; + this.eof = false; + this.buffer = emptyBuffer; + this.minBufferLength = 512; + if (maybeMinBufferLength) { + // Compute the first power of two that is as big as maybeMinBufferLength. + while (this.minBufferLength < maybeMinBufferLength) { + this.minBufferLength *= 2; + } + } + } + + DecodeStream.prototype = { + get isEmpty() { + while (!this.eof && this.bufferLength === 0) { + this.readBlock(); + } + return this.bufferLength === 0; + }, + ensureBuffer: function DecodeStream_ensureBuffer(requested) { + var buffer = this.buffer; + if (requested <= buffer.byteLength) { + return buffer; + } + var size = this.minBufferLength; + while (size < requested) { + size *= 2; + } + var buffer2 = new Uint8Array(size); + buffer2.set(buffer); + return (this.buffer = buffer2); + }, + getByte: function DecodeStream_getByte() { + var pos = this.pos; + while (this.bufferLength <= pos) { + if (this.eof) { + return -1; + } + this.readBlock(); + } + return this.buffer[this.pos++]; + }, + getUint16: function DecodeStream_getUint16() { + var b0 = this.getByte(); + var b1 = this.getByte(); + if (b0 === -1 || b1 === -1) { + return -1; + } + return (b0 << 8) + b1; + }, + getInt32: function DecodeStream_getInt32() { + var b0 = this.getByte(); + var b1 = this.getByte(); + var b2 = this.getByte(); + var b3 = this.getByte(); + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + }, + getBytes: function DecodeStream_getBytes(length) { + var end, pos = this.pos; + + if (length) { + this.ensureBuffer(pos + length); + end = pos + length; + + while (!this.eof && this.bufferLength < end) { + this.readBlock(); + } + var bufEnd = this.bufferLength; + if (end > bufEnd) { + end = bufEnd; + } + } else { + while (!this.eof) { + this.readBlock(); + } + end = this.bufferLength; + } + + this.pos = end; + return this.buffer.subarray(pos, end); + }, + peekByte: function DecodeStream_peekByte() { + var peekedByte = this.getByte(); + this.pos--; + return peekedByte; + }, + peekBytes: function DecodeStream_peekBytes(length) { + var bytes = this.getBytes(length); + this.pos -= bytes.length; + return bytes; + }, + makeSubStream: function DecodeStream_makeSubStream(start, length, dict) { + var end = start + length; + while (this.bufferLength <= end && !this.eof) { + this.readBlock(); + } + return new Stream(this.buffer, start, length, dict); + }, + skip: function DecodeStream_skip(n) { + if (!n) { + n = 1; + } + this.pos += n; + }, + reset: function DecodeStream_reset() { + this.pos = 0; + }, + getBaseStreams: function DecodeStream_getBaseStreams() { + if (this.str && this.str.getBaseStreams) { + return this.str.getBaseStreams(); + } + return []; + } + }; + + return DecodeStream; +})(); + +var StreamsSequenceStream = (function StreamsSequenceStreamClosure() { + function StreamsSequenceStream(streams) { + this.streams = streams; + DecodeStream.call(this, /* maybeLength = */ null); + } + + StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype); + + StreamsSequenceStream.prototype.readBlock = + function streamSequenceStreamReadBlock() { + + var streams = this.streams; + if (streams.length === 0) { + this.eof = true; + return; + } + var stream = streams.shift(); + var chunk = stream.getBytes(); + var bufferLength = this.bufferLength; + var newLength = bufferLength + chunk.length; + var buffer = this.ensureBuffer(newLength); + buffer.set(chunk, bufferLength); + this.bufferLength = newLength; + }; + + StreamsSequenceStream.prototype.getBaseStreams = + function StreamsSequenceStream_getBaseStreams() { + + var baseStreams = []; + for (var i = 0, ii = this.streams.length; i < ii; i++) { + var stream = this.streams[i]; + if (stream.getBaseStreams) { + Util.appendToArray(baseStreams, stream.getBaseStreams()); + } + } + return baseStreams; + }; + + return StreamsSequenceStream; +})(); + +var FlateStream = (function FlateStreamClosure() { + var codeLenCodeMap = new Int32Array([ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 + ]); + + var lengthDecode = new Int32Array([ + 0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a, + 0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f, + 0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073, + 0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102 + ]); + + var distDecode = new Int32Array([ + 0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d, + 0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1, + 0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01, + 0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001 + ]); + + var fixedLitCodeTab = [new Int32Array([ + 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0, + 0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0, + 0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0, + 0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0, + 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8, + 0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8, + 0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8, + 0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8, + 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4, + 0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4, + 0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4, + 0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4, + 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc, + 0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec, + 0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc, + 0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc, + 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2, + 0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2, + 0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2, + 0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2, + 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca, + 0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea, + 0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da, + 0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa, + 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6, + 0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6, + 0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6, + 0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6, + 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce, + 0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee, + 0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de, + 0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe, + 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1, + 0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1, + 0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1, + 0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1, + 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9, + 0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9, + 0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9, + 0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9, + 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5, + 0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5, + 0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5, + 0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5, + 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd, + 0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed, + 0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd, + 0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd, + 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3, + 0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3, + 0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3, + 0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3, + 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb, + 0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb, + 0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db, + 0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb, + 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7, + 0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7, + 0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7, + 0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7, + 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf, + 0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef, + 0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df, + 0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff + ]), 9]; + + var fixedDistCodeTab = [new Int32Array([ + 0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c, + 0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000, + 0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d, + 0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000 + ]), 5]; + + function FlateStream(str, maybeLength) { + this.str = str; + this.dict = str.dict; + + var cmf = str.getByte(); + var flg = str.getByte(); + if (cmf === -1 || flg === -1) { + error('Invalid header in flate stream: ' + cmf + ', ' + flg); + } + if ((cmf & 0x0f) !== 0x08) { + error('Unknown compression method in flate stream: ' + cmf + ', ' + flg); + } + if ((((cmf << 8) + flg) % 31) !== 0) { + error('Bad FCHECK in flate stream: ' + cmf + ', ' + flg); + } + if (flg & 0x20) { + error('FDICT bit set in flate stream: ' + cmf + ', ' + flg); + } + + this.codeSize = 0; + this.codeBuf = 0; + + DecodeStream.call(this, maybeLength); + } + + FlateStream.prototype = Object.create(DecodeStream.prototype); + + FlateStream.prototype.getBits = function FlateStream_getBits(bits) { + var str = this.str; + var codeSize = this.codeSize; + var codeBuf = this.codeBuf; + + var b; + while (codeSize < bits) { + if ((b = str.getByte()) === -1) { + error('Bad encoding in flate stream'); + } + codeBuf |= b << codeSize; + codeSize += 8; + } + b = codeBuf & ((1 << bits) - 1); + this.codeBuf = codeBuf >> bits; + this.codeSize = codeSize -= bits; + + return b; + }; + + FlateStream.prototype.getCode = function FlateStream_getCode(table) { + var str = this.str; + var codes = table[0]; + var maxLen = table[1]; + var codeSize = this.codeSize; + var codeBuf = this.codeBuf; + + var b; + while (codeSize < maxLen) { + if ((b = str.getByte()) === -1) { + // premature end of stream. code might however still be valid. + // codeSize < codeLen check below guards against incomplete codeVal. + break; + } + codeBuf |= (b << codeSize); + codeSize += 8; + } + var code = codes[codeBuf & ((1 << maxLen) - 1)]; + var codeLen = code >> 16; + var codeVal = code & 0xffff; + if (codeLen < 1 || codeSize < codeLen) { + error('Bad encoding in flate stream'); + } + this.codeBuf = (codeBuf >> codeLen); + this.codeSize = (codeSize - codeLen); + return codeVal; + }; + + FlateStream.prototype.generateHuffmanTable = + function flateStreamGenerateHuffmanTable(lengths) { + var n = lengths.length; + + // find max code length + var maxLen = 0; + var i; + for (i = 0; i < n; ++i) { + if (lengths[i] > maxLen) { + maxLen = lengths[i]; + } + } + + // build the table + var size = 1 << maxLen; + var codes = new Int32Array(size); + for (var len = 1, code = 0, skip = 2; + len <= maxLen; + ++len, code <<= 1, skip <<= 1) { + for (var val = 0; val < n; ++val) { + if (lengths[val] === len) { + // bit-reverse the code + var code2 = 0; + var t = code; + for (i = 0; i < len; ++i) { + code2 = (code2 << 1) | (t & 1); + t >>= 1; + } + + // fill the table entries + for (i = code2; i < size; i += skip) { + codes[i] = (len << 16) | val; + } + ++code; + } + } + } + + return [codes, maxLen]; + }; + + FlateStream.prototype.readBlock = function FlateStream_readBlock() { + var buffer, len; + var str = this.str; + // read block header + var hdr = this.getBits(3); + if (hdr & 1) { + this.eof = true; + } + hdr >>= 1; + + if (hdr === 0) { // uncompressed block + var b; + + if ((b = str.getByte()) === -1) { + error('Bad block header in flate stream'); + } + var blockLen = b; + if ((b = str.getByte()) === -1) { + error('Bad block header in flate stream'); + } + blockLen |= (b << 8); + if ((b = str.getByte()) === -1) { + error('Bad block header in flate stream'); + } + var check = b; + if ((b = str.getByte()) === -1) { + error('Bad block header in flate stream'); + } + check |= (b << 8); + if (check !== (~blockLen & 0xffff) && + (blockLen !== 0 || check !== 0)) { + // Ignoring error for bad "empty" block (see issue 1277) + error('Bad uncompressed block length in flate stream'); + } + + this.codeBuf = 0; + this.codeSize = 0; + + var bufferLength = this.bufferLength; + buffer = this.ensureBuffer(bufferLength + blockLen); + var end = bufferLength + blockLen; + this.bufferLength = end; + if (blockLen === 0) { + if (str.peekByte() === -1) { + this.eof = true; + } + } else { + for (var n = bufferLength; n < end; ++n) { + if ((b = str.getByte()) === -1) { + this.eof = true; + break; + } + buffer[n] = b; + } + } + return; + } + + var litCodeTable; + var distCodeTable; + if (hdr === 1) { // compressed block, fixed codes + litCodeTable = fixedLitCodeTab; + distCodeTable = fixedDistCodeTab; + } else if (hdr === 2) { // compressed block, dynamic codes + var numLitCodes = this.getBits(5) + 257; + var numDistCodes = this.getBits(5) + 1; + var numCodeLenCodes = this.getBits(4) + 4; + + // build the code lengths code table + var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length); + + var i; + for (i = 0; i < numCodeLenCodes; ++i) { + codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3); + } + var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths); + + // build the literal and distance code tables + len = 0; + i = 0; + var codes = numLitCodes + numDistCodes; + var codeLengths = new Uint8Array(codes); + var bitsLength, bitsOffset, what; + while (i < codes) { + var code = this.getCode(codeLenCodeTab); + if (code === 16) { + bitsLength = 2; bitsOffset = 3; what = len; + } else if (code === 17) { + bitsLength = 3; bitsOffset = 3; what = (len = 0); + } else if (code === 18) { + bitsLength = 7; bitsOffset = 11; what = (len = 0); + } else { + codeLengths[i++] = len = code; + continue; + } + + var repeatLength = this.getBits(bitsLength) + bitsOffset; + while (repeatLength-- > 0) { + codeLengths[i++] = what; + } + } + + litCodeTable = + this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes)); + distCodeTable = + this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes)); + } else { + error('Unknown block type in flate stream'); + } + + buffer = this.buffer; + var limit = buffer ? buffer.length : 0; + var pos = this.bufferLength; + while (true) { + var code1 = this.getCode(litCodeTable); + if (code1 < 256) { + if (pos + 1 >= limit) { + buffer = this.ensureBuffer(pos + 1); + limit = buffer.length; + } + buffer[pos++] = code1; + continue; + } + if (code1 === 256) { + this.bufferLength = pos; + return; + } + code1 -= 257; + code1 = lengthDecode[code1]; + var code2 = code1 >> 16; + if (code2 > 0) { + code2 = this.getBits(code2); + } + len = (code1 & 0xffff) + code2; + code1 = this.getCode(distCodeTable); + code1 = distDecode[code1]; + code2 = code1 >> 16; + if (code2 > 0) { + code2 = this.getBits(code2); + } + var dist = (code1 & 0xffff) + code2; + if (pos + len >= limit) { + buffer = this.ensureBuffer(pos + len); + limit = buffer.length; + } + for (var k = 0; k < len; ++k, ++pos) { + buffer[pos] = buffer[pos - dist]; + } + } + }; + + return FlateStream; +})(); + +var PredictorStream = (function PredictorStreamClosure() { + function PredictorStream(str, maybeLength, params) { + var predictor = this.predictor = params.get('Predictor') || 1; + + if (predictor <= 1) { + return str; // no prediction + } + if (predictor !== 2 && (predictor < 10 || predictor > 15)) { + error('Unsupported predictor: ' + predictor); + } + + if (predictor === 2) { + this.readBlock = this.readBlockTiff; + } else { + this.readBlock = this.readBlockPng; + } + + this.str = str; + this.dict = str.dict; + + var colors = this.colors = params.get('Colors') || 1; + var bits = this.bits = params.get('BitsPerComponent') || 8; + var columns = this.columns = params.get('Columns') || 1; + + this.pixBytes = (colors * bits + 7) >> 3; + this.rowBytes = (columns * colors * bits + 7) >> 3; + + DecodeStream.call(this, maybeLength); + return this; + } + + PredictorStream.prototype = Object.create(DecodeStream.prototype); + + PredictorStream.prototype.readBlockTiff = + function predictorStreamReadBlockTiff() { + var rowBytes = this.rowBytes; + + var bufferLength = this.bufferLength; + var buffer = this.ensureBuffer(bufferLength + rowBytes); + + var bits = this.bits; + var colors = this.colors; + + var rawBytes = this.str.getBytes(rowBytes); + this.eof = !rawBytes.length; + if (this.eof) { + return; + } + + var inbuf = 0, outbuf = 0; + var inbits = 0, outbits = 0; + var pos = bufferLength; + var i; + + if (bits === 1) { + for (i = 0; i < rowBytes; ++i) { + var c = rawBytes[i]; + inbuf = (inbuf << 8) | c; + // bitwise addition is exclusive or + // first shift inbuf and then add + buffer[pos++] = (c ^ (inbuf >> colors)) & 0xFF; + // truncate inbuf (assumes colors < 16) + inbuf &= 0xFFFF; + } + } else if (bits === 8) { + for (i = 0; i < colors; ++i) { + buffer[pos++] = rawBytes[i]; + } + for (; i < rowBytes; ++i) { + buffer[pos] = buffer[pos - colors] + rawBytes[i]; + pos++; + } + } else { + var compArray = new Uint8Array(colors + 1); + var bitMask = (1 << bits) - 1; + var j = 0, k = bufferLength; + var columns = this.columns; + for (i = 0; i < columns; ++i) { + for (var kk = 0; kk < colors; ++kk) { + if (inbits < bits) { + inbuf = (inbuf << 8) | (rawBytes[j++] & 0xFF); + inbits += 8; + } + compArray[kk] = (compArray[kk] + + (inbuf >> (inbits - bits))) & bitMask; + inbits -= bits; + outbuf = (outbuf << bits) | compArray[kk]; + outbits += bits; + if (outbits >= 8) { + buffer[k++] = (outbuf >> (outbits - 8)) & 0xFF; + outbits -= 8; + } + } + } + if (outbits > 0) { + buffer[k++] = (outbuf << (8 - outbits)) + + (inbuf & ((1 << (8 - outbits)) - 1)); + } + } + this.bufferLength += rowBytes; + }; + + PredictorStream.prototype.readBlockPng = + function predictorStreamReadBlockPng() { + + var rowBytes = this.rowBytes; + var pixBytes = this.pixBytes; + + var predictor = this.str.getByte(); + var rawBytes = this.str.getBytes(rowBytes); + this.eof = !rawBytes.length; + if (this.eof) { + return; + } + + var bufferLength = this.bufferLength; + var buffer = this.ensureBuffer(bufferLength + rowBytes); + + var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength); + if (prevRow.length === 0) { + prevRow = new Uint8Array(rowBytes); + } + + var i, j = bufferLength, up, c; + switch (predictor) { + case 0: + for (i = 0; i < rowBytes; ++i) { + buffer[j++] = rawBytes[i]; + } + break; + case 1: + for (i = 0; i < pixBytes; ++i) { + buffer[j++] = rawBytes[i]; + } + for (; i < rowBytes; ++i) { + buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xFF; + j++; + } + break; + case 2: + for (i = 0; i < rowBytes; ++i) { + buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xFF; + } + break; + case 3: + for (i = 0; i < pixBytes; ++i) { + buffer[j++] = (prevRow[i] >> 1) + rawBytes[i]; + } + for (; i < rowBytes; ++i) { + buffer[j] = (((prevRow[i] + buffer[j - pixBytes]) >> 1) + + rawBytes[i]) & 0xFF; + j++; + } + break; + case 4: + // we need to save the up left pixels values. the simplest way + // is to create a new buffer + for (i = 0; i < pixBytes; ++i) { + up = prevRow[i]; + c = rawBytes[i]; + buffer[j++] = up + c; + } + for (; i < rowBytes; ++i) { + up = prevRow[i]; + var upLeft = prevRow[i - pixBytes]; + var left = buffer[j - pixBytes]; + var p = left + up - upLeft; + + var pa = p - left; + if (pa < 0) { + pa = -pa; + } + var pb = p - up; + if (pb < 0) { + pb = -pb; + } + var pc = p - upLeft; + if (pc < 0) { + pc = -pc; + } + + c = rawBytes[i]; + if (pa <= pb && pa <= pc) { + buffer[j++] = left + c; + } else if (pb <= pc) { + buffer[j++] = up + c; + } else { + buffer[j++] = upLeft + c; + } + } + break; + default: + error('Unsupported predictor: ' + predictor); + } + this.bufferLength += rowBytes; + }; + + return PredictorStream; +})(); + +/** + * Depending on the type of JPEG a JpegStream is handled in different ways. For + * JPEG's that are supported natively such as DeviceGray and DeviceRGB the image + * data is stored and then loaded by the browser. For unsupported JPEG's we use + * a library to decode these images and the stream behaves like all the other + * DecodeStreams. + */ +var JpegStream = (function JpegStreamClosure() { + function JpegStream(stream, maybeLength, dict, xref) { + // Some images may contain 'junk' before the SOI (start-of-image) marker. + // Note: this seems to mainly affect inline images. + var ch; + while ((ch = stream.getByte()) !== -1) { + if (ch === 0xFF) { // Find the first byte of the SOI marker (0xFFD8). + stream.skip(-1); // Reset the stream position to the SOI. + break; + } + } + this.stream = stream; + this.maybeLength = maybeLength; + this.dict = dict; + + DecodeStream.call(this, maybeLength); + } + + JpegStream.prototype = Object.create(DecodeStream.prototype); + + Object.defineProperty(JpegStream.prototype, 'bytes', { + get: function JpegStream_bytes() { + // If this.maybeLength is null, we'll get the entire stream. + return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength)); + }, + configurable: true + }); + + JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) { + if (this.bufferLength) { + return; + } + try { + var jpegImage = new JpegImage(); + + // checking if values needs to be transformed before conversion + if (this.forceRGB && this.dict && isArray(this.dict.get('Decode'))) { + var decodeArr = this.dict.get('Decode'); + var bitsPerComponent = this.dict.get('BitsPerComponent') || 8; + var decodeArrLength = decodeArr.length; + var transform = new Int32Array(decodeArrLength); + var transformNeeded = false; + var maxValue = (1 << bitsPerComponent) - 1; + for (var i = 0; i < decodeArrLength; i += 2) { + transform[i] = ((decodeArr[i + 1] - decodeArr[i]) * 256) | 0; + transform[i + 1] = (decodeArr[i] * maxValue) | 0; + if (transform[i] !== 256 || transform[i + 1] !== 0) { + transformNeeded = true; + } + } + if (transformNeeded) { + jpegImage.decodeTransform = transform; + } + } + + jpegImage.parse(this.bytes); + var data = jpegImage.getData(this.drawWidth, this.drawHeight, + this.forceRGB); + this.buffer = data; + this.bufferLength = data.length; + this.eof = true; + } catch (e) { + error('JPEG error: ' + e); + } + }; + + JpegStream.prototype.getBytes = function JpegStream_getBytes(length) { + this.ensureBuffer(); + return this.buffer; + }; + + JpegStream.prototype.getIR = function JpegStream_getIR() { + return PDFJS.createObjectURL(this.bytes, 'image/jpeg'); + }; + /** + * Checks if the image can be decoded and displayed by the browser without any + * further processing such as color space conversions. + */ + JpegStream.prototype.isNativelySupported = + function JpegStream_isNativelySupported(xref, res) { + var cs = ColorSpace.parse(this.dict.get('ColorSpace', 'CS'), xref, res); + return (cs.name === 'DeviceGray' || cs.name === 'DeviceRGB') && + cs.isDefaultDecode(this.dict.get('Decode', 'D')); + }; + /** + * Checks if the image can be decoded by the browser. + */ + JpegStream.prototype.isNativelyDecodable = + function JpegStream_isNativelyDecodable(xref, res) { + var cs = ColorSpace.parse(this.dict.get('ColorSpace', 'CS'), xref, res); + return (cs.numComps === 1 || cs.numComps === 3) && + cs.isDefaultDecode(this.dict.get('Decode', 'D')); + }; + + return JpegStream; +})(); + +/** + * For JPEG 2000's we use a library to decode these images and + * the stream behaves like all the other DecodeStreams. + */ +var JpxStream = (function JpxStreamClosure() { + function JpxStream(stream, maybeLength, dict) { + this.stream = stream; + this.maybeLength = maybeLength; + this.dict = dict; + + DecodeStream.call(this, maybeLength); + } + + JpxStream.prototype = Object.create(DecodeStream.prototype); + + Object.defineProperty(JpxStream.prototype, 'bytes', { + get: function JpxStream_bytes() { + // If this.maybeLength is null, we'll get the entire stream. + return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength)); + }, + configurable: true + }); + + JpxStream.prototype.ensureBuffer = function JpxStream_ensureBuffer(req) { + if (this.bufferLength) { + return; + } + + var jpxImage = new JpxImage(); + jpxImage.parse(this.bytes); + + var width = jpxImage.width; + var height = jpxImage.height; + var componentsCount = jpxImage.componentsCount; + var tileCount = jpxImage.tiles.length; + if (tileCount === 1) { + this.buffer = jpxImage.tiles[0].items; + } else { + var data = new Uint8Array(width * height * componentsCount); + + for (var k = 0; k < tileCount; k++) { + var tileComponents = jpxImage.tiles[k]; + var tileWidth = tileComponents.width; + var tileHeight = tileComponents.height; + var tileLeft = tileComponents.left; + var tileTop = tileComponents.top; + + var src = tileComponents.items; + var srcPosition = 0; + var dataPosition = (width * tileTop + tileLeft) * componentsCount; + var imgRowSize = width * componentsCount; + var tileRowSize = tileWidth * componentsCount; + + for (var j = 0; j < tileHeight; j++) { + var rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize); + data.set(rowBytes, dataPosition); + srcPosition += tileRowSize; + dataPosition += imgRowSize; + } + } + this.buffer = data; + } + this.bufferLength = this.buffer.length; + this.eof = true; + }; + + return JpxStream; +})(); + +/** + * For JBIG2's we use a library to decode these images and + * the stream behaves like all the other DecodeStreams. + */ +var Jbig2Stream = (function Jbig2StreamClosure() { + function Jbig2Stream(stream, maybeLength, dict) { + this.stream = stream; + this.maybeLength = maybeLength; + this.dict = dict; + + DecodeStream.call(this, maybeLength); + } + + Jbig2Stream.prototype = Object.create(DecodeStream.prototype); + + Object.defineProperty(Jbig2Stream.prototype, 'bytes', { + get: function Jbig2Stream_bytes() { + // If this.maybeLength is null, we'll get the entire stream. + return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength)); + }, + configurable: true + }); + + Jbig2Stream.prototype.ensureBuffer = function Jbig2Stream_ensureBuffer(req) { + if (this.bufferLength) { + return; + } + + var jbig2Image = new Jbig2Image(); + + var chunks = [], xref = this.dict.xref; + var decodeParams = xref.fetchIfRef(this.dict.get('DecodeParms')); + + // According to the PDF specification, DecodeParms can be either + // a dictionary, or an array whose elements are dictionaries. + if (isArray(decodeParams)) { + if (decodeParams.length > 1) { + warn('JBIG2 - \'DecodeParms\' array with multiple elements ' + + 'not supported.'); + } + decodeParams = xref.fetchIfRef(decodeParams[0]); + } + if (decodeParams && decodeParams.has('JBIG2Globals')) { + var globalsStream = decodeParams.get('JBIG2Globals'); + var globals = globalsStream.getBytes(); + chunks.push({data: globals, start: 0, end: globals.length}); + } + chunks.push({data: this.bytes, start: 0, end: this.bytes.length}); + var data = jbig2Image.parseChunks(chunks); + var dataLength = data.length; + + // JBIG2 had black as 1 and white as 0, inverting the colors + for (var i = 0; i < dataLength; i++) { + data[i] ^= 0xFF; + } + + this.buffer = data; + this.bufferLength = dataLength; + this.eof = true; + }; + + return Jbig2Stream; +})(); + +var DecryptStream = (function DecryptStreamClosure() { + function DecryptStream(str, maybeLength, decrypt) { + this.str = str; + this.dict = str.dict; + this.decrypt = decrypt; + this.nextChunk = null; + this.initialized = false; + + DecodeStream.call(this, maybeLength); + } + + var chunkSize = 512; + + DecryptStream.prototype = Object.create(DecodeStream.prototype); + + DecryptStream.prototype.readBlock = function DecryptStream_readBlock() { + var chunk; + if (this.initialized) { + chunk = this.nextChunk; + } else { + chunk = this.str.getBytes(chunkSize); + this.initialized = true; + } + if (!chunk || chunk.length === 0) { + this.eof = true; + return; + } + this.nextChunk = this.str.getBytes(chunkSize); + var hasMoreData = this.nextChunk && this.nextChunk.length > 0; + + var decrypt = this.decrypt; + chunk = decrypt(chunk, !hasMoreData); + + var bufferLength = this.bufferLength; + var i, n = chunk.length; + var buffer = this.ensureBuffer(bufferLength + n); + for (i = 0; i < n; i++) { + buffer[bufferLength++] = chunk[i]; + } + this.bufferLength = bufferLength; + }; + + return DecryptStream; +})(); + +var Ascii85Stream = (function Ascii85StreamClosure() { + function Ascii85Stream(str, maybeLength) { + this.str = str; + this.dict = str.dict; + this.input = new Uint8Array(5); + + // Most streams increase in size when decoded, but Ascii85 streams + // typically shrink by ~20%. + if (maybeLength) { + maybeLength = 0.8 * maybeLength; + } + DecodeStream.call(this, maybeLength); + } + + Ascii85Stream.prototype = Object.create(DecodeStream.prototype); + + Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() { + var TILDA_CHAR = 0x7E; // '~' + var Z_LOWER_CHAR = 0x7A; // 'z' + var EOF = -1; + + var str = this.str; + + var c = str.getByte(); + while (Lexer.isSpace(c)) { + c = str.getByte(); + } + + if (c === EOF || c === TILDA_CHAR) { + this.eof = true; + return; + } + + var bufferLength = this.bufferLength, buffer; + var i; + + // special code for z + if (c === Z_LOWER_CHAR) { + buffer = this.ensureBuffer(bufferLength + 4); + for (i = 0; i < 4; ++i) { + buffer[bufferLength + i] = 0; + } + this.bufferLength += 4; + } else { + var input = this.input; + input[0] = c; + for (i = 1; i < 5; ++i) { + c = str.getByte(); + while (Lexer.isSpace(c)) { + c = str.getByte(); + } + + input[i] = c; + + if (c === EOF || c === TILDA_CHAR) { + break; + } + } + buffer = this.ensureBuffer(bufferLength + i - 1); + this.bufferLength += i - 1; + + // partial ending; + if (i < 5) { + for (; i < 5; ++i) { + input[i] = 0x21 + 84; + } + this.eof = true; + } + var t = 0; + for (i = 0; i < 5; ++i) { + t = t * 85 + (input[i] - 0x21); + } + + for (i = 3; i >= 0; --i) { + buffer[bufferLength + i] = t & 0xFF; + t >>= 8; + } + } + }; + + return Ascii85Stream; +})(); + +var AsciiHexStream = (function AsciiHexStreamClosure() { + function AsciiHexStream(str, maybeLength) { + this.str = str; + this.dict = str.dict; + + this.firstDigit = -1; + + // Most streams increase in size when decoded, but AsciiHex streams shrink + // by 50%. + if (maybeLength) { + maybeLength = 0.5 * maybeLength; + } + DecodeStream.call(this, maybeLength); + } + + AsciiHexStream.prototype = Object.create(DecodeStream.prototype); + + AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() { + var UPSTREAM_BLOCK_SIZE = 8000; + var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE); + if (!bytes.length) { + this.eof = true; + return; + } + + var maxDecodeLength = (bytes.length + 1) >> 1; + var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength); + var bufferLength = this.bufferLength; + + var firstDigit = this.firstDigit; + for (var i = 0, ii = bytes.length; i < ii; i++) { + var ch = bytes[i], digit; + if (ch >= 0x30 && ch <= 0x39) { // '0'-'9' + digit = ch & 0x0F; + } else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) { + // 'A'-'Z', 'a'-'z' + digit = (ch & 0x0F) + 9; + } else if (ch === 0x3E) { // '>' + this.eof = true; + break; + } else { // probably whitespace + continue; // ignoring + } + if (firstDigit < 0) { + firstDigit = digit; + } else { + buffer[bufferLength++] = (firstDigit << 4) | digit; + firstDigit = -1; + } + } + if (firstDigit >= 0 && this.eof) { + // incomplete byte + buffer[bufferLength++] = (firstDigit << 4); + firstDigit = -1; + } + this.firstDigit = firstDigit; + this.bufferLength = bufferLength; + }; + + return AsciiHexStream; +})(); + +var RunLengthStream = (function RunLengthStreamClosure() { + function RunLengthStream(str, maybeLength) { + this.str = str; + this.dict = str.dict; + + DecodeStream.call(this, maybeLength); + } + + RunLengthStream.prototype = Object.create(DecodeStream.prototype); + + RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() { + // The repeatHeader has following format. The first byte defines type of run + // and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes + // (in addition to the second byte from the header), n = 129 through 255 - + // duplicate the second byte from the header (257 - n) times, n = 128 - end. + var repeatHeader = this.str.getBytes(2); + if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) { + this.eof = true; + return; + } + + var buffer; + var bufferLength = this.bufferLength; + var n = repeatHeader[0]; + if (n < 128) { + // copy n bytes + buffer = this.ensureBuffer(bufferLength + n + 1); + buffer[bufferLength++] = repeatHeader[1]; + if (n > 0) { + var source = this.str.getBytes(n); + buffer.set(source, bufferLength); + bufferLength += n; + } + } else { + n = 257 - n; + var b = repeatHeader[1]; + buffer = this.ensureBuffer(bufferLength + n + 1); + for (var i = 0; i < n; i++) { + buffer[bufferLength++] = b; + } + } + this.bufferLength = bufferLength; + }; + + return RunLengthStream; +})(); + +var CCITTFaxStream = (function CCITTFaxStreamClosure() { + + var ccittEOL = -2; + var twoDimPass = 0; + var twoDimHoriz = 1; + var twoDimVert0 = 2; + var twoDimVertR1 = 3; + var twoDimVertL1 = 4; + var twoDimVertR2 = 5; + var twoDimVertL2 = 6; + var twoDimVertR3 = 7; + var twoDimVertL3 = 8; + + var twoDimTable = [ + [-1, -1], [-1, -1], // 000000x + [7, twoDimVertL3], // 0000010 + [7, twoDimVertR3], // 0000011 + [6, twoDimVertL2], [6, twoDimVertL2], // 000010x + [6, twoDimVertR2], [6, twoDimVertR2], // 000011x + [4, twoDimPass], [4, twoDimPass], // 0001xxx + [4, twoDimPass], [4, twoDimPass], + [4, twoDimPass], [4, twoDimPass], + [4, twoDimPass], [4, twoDimPass], + [3, twoDimHoriz], [3, twoDimHoriz], // 001xxxx + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimHoriz], [3, twoDimHoriz], + [3, twoDimVertL1], [3, twoDimVertL1], // 010xxxx + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertL1], [3, twoDimVertL1], + [3, twoDimVertR1], [3, twoDimVertR1], // 011xxxx + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [3, twoDimVertR1], [3, twoDimVertR1], + [1, twoDimVert0], [1, twoDimVert0], // 1xxxxxx + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0], + [1, twoDimVert0], [1, twoDimVert0] + ]; + + var whiteTable1 = [ + [-1, -1], // 00000 + [12, ccittEOL], // 00001 + [-1, -1], [-1, -1], // 0001x + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 001xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 010xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 011xx + [11, 1792], [11, 1792], // 1000x + [12, 1984], // 10010 + [12, 2048], // 10011 + [12, 2112], // 10100 + [12, 2176], // 10101 + [12, 2240], // 10110 + [12, 2304], // 10111 + [11, 1856], [11, 1856], // 1100x + [11, 1920], [11, 1920], // 1101x + [12, 2368], // 11100 + [12, 2432], // 11101 + [12, 2496], // 11110 + [12, 2560] // 11111 + ]; + + var whiteTable2 = [ + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 0000000xx + [8, 29], [8, 29], // 00000010x + [8, 30], [8, 30], // 00000011x + [8, 45], [8, 45], // 00000100x + [8, 46], [8, 46], // 00000101x + [7, 22], [7, 22], [7, 22], [7, 22], // 0000011xx + [7, 23], [7, 23], [7, 23], [7, 23], // 0000100xx + [8, 47], [8, 47], // 00001010x + [8, 48], [8, 48], // 00001011x + [6, 13], [6, 13], [6, 13], [6, 13], // 000011xxx + [6, 13], [6, 13], [6, 13], [6, 13], + [7, 20], [7, 20], [7, 20], [7, 20], // 0001000xx + [8, 33], [8, 33], // 00010010x + [8, 34], [8, 34], // 00010011x + [8, 35], [8, 35], // 00010100x + [8, 36], [8, 36], // 00010101x + [8, 37], [8, 37], // 00010110x + [8, 38], [8, 38], // 00010111x + [7, 19], [7, 19], [7, 19], [7, 19], // 0001100xx + [8, 31], [8, 31], // 00011010x + [8, 32], [8, 32], // 00011011x + [6, 1], [6, 1], [6, 1], [6, 1], // 000111xxx + [6, 1], [6, 1], [6, 1], [6, 1], + [6, 12], [6, 12], [6, 12], [6, 12], // 001000xxx + [6, 12], [6, 12], [6, 12], [6, 12], + [8, 53], [8, 53], // 00100100x + [8, 54], [8, 54], // 00100101x + [7, 26], [7, 26], [7, 26], [7, 26], // 0010011xx + [8, 39], [8, 39], // 00101000x + [8, 40], [8, 40], // 00101001x + [8, 41], [8, 41], // 00101010x + [8, 42], [8, 42], // 00101011x + [8, 43], [8, 43], // 00101100x + [8, 44], [8, 44], // 00101101x + [7, 21], [7, 21], [7, 21], [7, 21], // 0010111xx + [7, 28], [7, 28], [7, 28], [7, 28], // 0011000xx + [8, 61], [8, 61], // 00110010x + [8, 62], [8, 62], // 00110011x + [8, 63], [8, 63], // 00110100x + [8, 0], [8, 0], // 00110101x + [8, 320], [8, 320], // 00110110x + [8, 384], [8, 384], // 00110111x + [5, 10], [5, 10], [5, 10], [5, 10], // 00111xxxx + [5, 10], [5, 10], [5, 10], [5, 10], + [5, 10], [5, 10], [5, 10], [5, 10], + [5, 10], [5, 10], [5, 10], [5, 10], + [5, 11], [5, 11], [5, 11], [5, 11], // 01000xxxx + [5, 11], [5, 11], [5, 11], [5, 11], + [5, 11], [5, 11], [5, 11], [5, 11], + [5, 11], [5, 11], [5, 11], [5, 11], + [7, 27], [7, 27], [7, 27], [7, 27], // 0100100xx + [8, 59], [8, 59], // 01001010x + [8, 60], [8, 60], // 01001011x + [9, 1472], // 010011000 + [9, 1536], // 010011001 + [9, 1600], // 010011010 + [9, 1728], // 010011011 + [7, 18], [7, 18], [7, 18], [7, 18], // 0100111xx + [7, 24], [7, 24], [7, 24], [7, 24], // 0101000xx + [8, 49], [8, 49], // 01010010x + [8, 50], [8, 50], // 01010011x + [8, 51], [8, 51], // 01010100x + [8, 52], [8, 52], // 01010101x + [7, 25], [7, 25], [7, 25], [7, 25], // 0101011xx + [8, 55], [8, 55], // 01011000x + [8, 56], [8, 56], // 01011001x + [8, 57], [8, 57], // 01011010x + [8, 58], [8, 58], // 01011011x + [6, 192], [6, 192], [6, 192], [6, 192], // 010111xxx + [6, 192], [6, 192], [6, 192], [6, 192], + [6, 1664], [6, 1664], [6, 1664], [6, 1664], // 011000xxx + [6, 1664], [6, 1664], [6, 1664], [6, 1664], + [8, 448], [8, 448], // 01100100x + [8, 512], [8, 512], // 01100101x + [9, 704], // 011001100 + [9, 768], // 011001101 + [8, 640], [8, 640], // 01100111x + [8, 576], [8, 576], // 01101000x + [9, 832], // 011010010 + [9, 896], // 011010011 + [9, 960], // 011010100 + [9, 1024], // 011010101 + [9, 1088], // 011010110 + [9, 1152], // 011010111 + [9, 1216], // 011011000 + [9, 1280], // 011011001 + [9, 1344], // 011011010 + [9, 1408], // 011011011 + [7, 256], [7, 256], [7, 256], [7, 256], // 0110111xx + [4, 2], [4, 2], [4, 2], [4, 2], // 0111xxxxx + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 2], [4, 2], [4, 2], [4, 2], + [4, 3], [4, 3], [4, 3], [4, 3], // 1000xxxxx + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [4, 3], [4, 3], [4, 3], [4, 3], + [5, 128], [5, 128], [5, 128], [5, 128], // 10010xxxx + [5, 128], [5, 128], [5, 128], [5, 128], + [5, 128], [5, 128], [5, 128], [5, 128], + [5, 128], [5, 128], [5, 128], [5, 128], + [5, 8], [5, 8], [5, 8], [5, 8], // 10011xxxx + [5, 8], [5, 8], [5, 8], [5, 8], + [5, 8], [5, 8], [5, 8], [5, 8], + [5, 8], [5, 8], [5, 8], [5, 8], + [5, 9], [5, 9], [5, 9], [5, 9], // 10100xxxx + [5, 9], [5, 9], [5, 9], [5, 9], + [5, 9], [5, 9], [5, 9], [5, 9], + [5, 9], [5, 9], [5, 9], [5, 9], + [6, 16], [6, 16], [6, 16], [6, 16], // 101010xxx + [6, 16], [6, 16], [6, 16], [6, 16], + [6, 17], [6, 17], [6, 17], [6, 17], // 101011xxx + [6, 17], [6, 17], [6, 17], [6, 17], + [4, 4], [4, 4], [4, 4], [4, 4], // 1011xxxxx + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 4], [4, 4], [4, 4], [4, 4], + [4, 5], [4, 5], [4, 5], [4, 5], // 1100xxxxx + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [4, 5], [4, 5], [4, 5], [4, 5], + [6, 14], [6, 14], [6, 14], [6, 14], // 110100xxx + [6, 14], [6, 14], [6, 14], [6, 14], + [6, 15], [6, 15], [6, 15], [6, 15], // 110101xxx + [6, 15], [6, 15], [6, 15], [6, 15], + [5, 64], [5, 64], [5, 64], [5, 64], // 11011xxxx + [5, 64], [5, 64], [5, 64], [5, 64], + [5, 64], [5, 64], [5, 64], [5, 64], + [5, 64], [5, 64], [5, 64], [5, 64], + [4, 6], [4, 6], [4, 6], [4, 6], // 1110xxxxx + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 6], [4, 6], [4, 6], [4, 6], + [4, 7], [4, 7], [4, 7], [4, 7], // 1111xxxxx + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7], + [4, 7], [4, 7], [4, 7], [4, 7] + ]; + + var blackTable1 = [ + [-1, -1], [-1, -1], // 000000000000x + [12, ccittEOL], [12, ccittEOL], // 000000000001x + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000001xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000010xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000011xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000100xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000101xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000110xx + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 00000000111xx + [11, 1792], [11, 1792], [11, 1792], [11, 1792], // 00000001000xx + [12, 1984], [12, 1984], // 000000010010x + [12, 2048], [12, 2048], // 000000010011x + [12, 2112], [12, 2112], // 000000010100x + [12, 2176], [12, 2176], // 000000010101x + [12, 2240], [12, 2240], // 000000010110x + [12, 2304], [12, 2304], // 000000010111x + [11, 1856], [11, 1856], [11, 1856], [11, 1856], // 00000001100xx + [11, 1920], [11, 1920], [11, 1920], [11, 1920], // 00000001101xx + [12, 2368], [12, 2368], // 000000011100x + [12, 2432], [12, 2432], // 000000011101x + [12, 2496], [12, 2496], // 000000011110x + [12, 2560], [12, 2560], // 000000011111x + [10, 18], [10, 18], [10, 18], [10, 18], // 0000001000xxx + [10, 18], [10, 18], [10, 18], [10, 18], + [12, 52], [12, 52], // 000000100100x + [13, 640], // 0000001001010 + [13, 704], // 0000001001011 + [13, 768], // 0000001001100 + [13, 832], // 0000001001101 + [12, 55], [12, 55], // 000000100111x + [12, 56], [12, 56], // 000000101000x + [13, 1280], // 0000001010010 + [13, 1344], // 0000001010011 + [13, 1408], // 0000001010100 + [13, 1472], // 0000001010101 + [12, 59], [12, 59], // 000000101011x + [12, 60], [12, 60], // 000000101100x + [13, 1536], // 0000001011010 + [13, 1600], // 0000001011011 + [11, 24], [11, 24], [11, 24], [11, 24], // 00000010111xx + [11, 25], [11, 25], [11, 25], [11, 25], // 00000011000xx + [13, 1664], // 0000001100100 + [13, 1728], // 0000001100101 + [12, 320], [12, 320], // 000000110011x + [12, 384], [12, 384], // 000000110100x + [12, 448], [12, 448], // 000000110101x + [13, 512], // 0000001101100 + [13, 576], // 0000001101101 + [12, 53], [12, 53], // 000000110111x + [12, 54], [12, 54], // 000000111000x + [13, 896], // 0000001110010 + [13, 960], // 0000001110011 + [13, 1024], // 0000001110100 + [13, 1088], // 0000001110101 + [13, 1152], // 0000001110110 + [13, 1216], // 0000001110111 + [10, 64], [10, 64], [10, 64], [10, 64], // 0000001111xxx + [10, 64], [10, 64], [10, 64], [10, 64] + ]; + + var blackTable2 = [ + [8, 13], [8, 13], [8, 13], [8, 13], // 00000100xxxx + [8, 13], [8, 13], [8, 13], [8, 13], + [8, 13], [8, 13], [8, 13], [8, 13], + [8, 13], [8, 13], [8, 13], [8, 13], + [11, 23], [11, 23], // 00000101000x + [12, 50], // 000001010010 + [12, 51], // 000001010011 + [12, 44], // 000001010100 + [12, 45], // 000001010101 + [12, 46], // 000001010110 + [12, 47], // 000001010111 + [12, 57], // 000001011000 + [12, 58], // 000001011001 + [12, 61], // 000001011010 + [12, 256], // 000001011011 + [10, 16], [10, 16], [10, 16], [10, 16], // 0000010111xx + [10, 17], [10, 17], [10, 17], [10, 17], // 0000011000xx + [12, 48], // 000001100100 + [12, 49], // 000001100101 + [12, 62], // 000001100110 + [12, 63], // 000001100111 + [12, 30], // 000001101000 + [12, 31], // 000001101001 + [12, 32], // 000001101010 + [12, 33], // 000001101011 + [12, 40], // 000001101100 + [12, 41], // 000001101101 + [11, 22], [11, 22], // 00000110111x + [8, 14], [8, 14], [8, 14], [8, 14], // 00000111xxxx + [8, 14], [8, 14], [8, 14], [8, 14], + [8, 14], [8, 14], [8, 14], [8, 14], + [8, 14], [8, 14], [8, 14], [8, 14], + [7, 10], [7, 10], [7, 10], [7, 10], // 0000100xxxxx + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 10], [7, 10], [7, 10], [7, 10], + [7, 11], [7, 11], [7, 11], [7, 11], // 0000101xxxxx + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [7, 11], [7, 11], [7, 11], [7, 11], + [9, 15], [9, 15], [9, 15], [9, 15], // 000011000xxx + [9, 15], [9, 15], [9, 15], [9, 15], + [12, 128], // 000011001000 + [12, 192], // 000011001001 + [12, 26], // 000011001010 + [12, 27], // 000011001011 + [12, 28], // 000011001100 + [12, 29], // 000011001101 + [11, 19], [11, 19], // 00001100111x + [11, 20], [11, 20], // 00001101000x + [12, 34], // 000011010010 + [12, 35], // 000011010011 + [12, 36], // 000011010100 + [12, 37], // 000011010101 + [12, 38], // 000011010110 + [12, 39], // 000011010111 + [11, 21], [11, 21], // 00001101100x + [12, 42], // 000011011010 + [12, 43], // 000011011011 + [10, 0], [10, 0], [10, 0], [10, 0], // 0000110111xx + [7, 12], [7, 12], [7, 12], [7, 12], // 0000111xxxxx + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12], + [7, 12], [7, 12], [7, 12], [7, 12] + ]; + + var blackTable3 = [ + [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 0000xx + [6, 9], // 000100 + [6, 8], // 000101 + [5, 7], [5, 7], // 00011x + [4, 6], [4, 6], [4, 6], [4, 6], // 0010xx + [4, 5], [4, 5], [4, 5], [4, 5], // 0011xx + [3, 1], [3, 1], [3, 1], [3, 1], // 010xxx + [3, 1], [3, 1], [3, 1], [3, 1], + [3, 4], [3, 4], [3, 4], [3, 4], // 011xxx + [3, 4], [3, 4], [3, 4], [3, 4], + [2, 3], [2, 3], [2, 3], [2, 3], // 10xxxx + [2, 3], [2, 3], [2, 3], [2, 3], + [2, 3], [2, 3], [2, 3], [2, 3], + [2, 3], [2, 3], [2, 3], [2, 3], + [2, 2], [2, 2], [2, 2], [2, 2], // 11xxxx + [2, 2], [2, 2], [2, 2], [2, 2], + [2, 2], [2, 2], [2, 2], [2, 2], + [2, 2], [2, 2], [2, 2], [2, 2] + ]; + + function CCITTFaxStream(str, maybeLength, params) { + this.str = str; + this.dict = str.dict; + + params = params || Dict.empty; + + this.encoding = params.get('K') || 0; + this.eoline = params.get('EndOfLine') || false; + this.byteAlign = params.get('EncodedByteAlign') || false; + this.columns = params.get('Columns') || 1728; + this.rows = params.get('Rows') || 0; + var eoblock = params.get('EndOfBlock'); + if (eoblock === null || eoblock === undefined) { + eoblock = true; + } + this.eoblock = eoblock; + this.black = params.get('BlackIs1') || false; + + this.codingLine = new Uint32Array(this.columns + 1); + this.refLine = new Uint32Array(this.columns + 2); + + this.codingLine[0] = this.columns; + this.codingPos = 0; + + this.row = 0; + this.nextLine2D = this.encoding < 0; + this.inputBits = 0; + this.inputBuf = 0; + this.outputBits = 0; + + var code1; + while ((code1 = this.lookBits(12)) === 0) { + this.eatBits(1); + } + if (code1 === 1) { + this.eatBits(12); + } + if (this.encoding > 0) { + this.nextLine2D = !this.lookBits(1); + this.eatBits(1); + } + + DecodeStream.call(this, maybeLength); + } + + CCITTFaxStream.prototype = Object.create(DecodeStream.prototype); + + CCITTFaxStream.prototype.readBlock = function CCITTFaxStream_readBlock() { + while (!this.eof) { + var c = this.lookChar(); + this.ensureBuffer(this.bufferLength + 1); + this.buffer[this.bufferLength++] = c; + } + }; + + CCITTFaxStream.prototype.addPixels = + function ccittFaxStreamAddPixels(a1, blackPixels) { + var codingLine = this.codingLine; + var codingPos = this.codingPos; + + if (a1 > codingLine[codingPos]) { + if (a1 > this.columns) { + info('row is wrong length'); + this.err = true; + a1 = this.columns; + } + if ((codingPos & 1) ^ blackPixels) { + ++codingPos; + } + + codingLine[codingPos] = a1; + } + this.codingPos = codingPos; + }; + + CCITTFaxStream.prototype.addPixelsNeg = + function ccittFaxStreamAddPixelsNeg(a1, blackPixels) { + var codingLine = this.codingLine; + var codingPos = this.codingPos; + + if (a1 > codingLine[codingPos]) { + if (a1 > this.columns) { + info('row is wrong length'); + this.err = true; + a1 = this.columns; + } + if ((codingPos & 1) ^ blackPixels) { + ++codingPos; + } + + codingLine[codingPos] = a1; + } else if (a1 < codingLine[codingPos]) { + if (a1 < 0) { + info('invalid code'); + this.err = true; + a1 = 0; + } + while (codingPos > 0 && a1 < codingLine[codingPos - 1]) { + --codingPos; + } + codingLine[codingPos] = a1; + } + + this.codingPos = codingPos; + }; + + CCITTFaxStream.prototype.lookChar = function CCITTFaxStream_lookChar() { + var refLine = this.refLine; + var codingLine = this.codingLine; + var columns = this.columns; + + var refPos, blackPixels, bits, i; + + if (this.outputBits === 0) { + if (this.eof) { + return null; + } + this.err = false; + + var code1, code2, code3; + if (this.nextLine2D) { + for (i = 0; codingLine[i] < columns; ++i) { + refLine[i] = codingLine[i]; + } + refLine[i++] = columns; + refLine[i] = columns; + codingLine[0] = 0; + this.codingPos = 0; + refPos = 0; + blackPixels = 0; + + while (codingLine[this.codingPos] < columns) { + code1 = this.getTwoDimCode(); + switch (code1) { + case twoDimPass: + this.addPixels(refLine[refPos + 1], blackPixels); + if (refLine[refPos + 1] < columns) { + refPos += 2; + } + break; + case twoDimHoriz: + code1 = code2 = 0; + if (blackPixels) { + do { + code1 += (code3 = this.getBlackCode()); + } while (code3 >= 64); + do { + code2 += (code3 = this.getWhiteCode()); + } while (code3 >= 64); + } else { + do { + code1 += (code3 = this.getWhiteCode()); + } while (code3 >= 64); + do { + code2 += (code3 = this.getBlackCode()); + } while (code3 >= 64); + } + this.addPixels(codingLine[this.codingPos] + + code1, blackPixels); + if (codingLine[this.codingPos] < columns) { + this.addPixels(codingLine[this.codingPos] + code2, + blackPixels ^ 1); + } + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + break; + case twoDimVertR3: + this.addPixels(refLine[refPos] + 3, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + ++refPos; + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVertR2: + this.addPixels(refLine[refPos] + 2, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + ++refPos; + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVertR1: + this.addPixels(refLine[refPos] + 1, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + ++refPos; + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVert0: + this.addPixels(refLine[refPos], blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + ++refPos; + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVertL3: + this.addPixelsNeg(refLine[refPos] - 3, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + if (refPos > 0) { + --refPos; + } else { + ++refPos; + } + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVertL2: + this.addPixelsNeg(refLine[refPos] - 2, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + if (refPos > 0) { + --refPos; + } else { + ++refPos; + } + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case twoDimVertL1: + this.addPixelsNeg(refLine[refPos] - 1, blackPixels); + blackPixels ^= 1; + if (codingLine[this.codingPos] < columns) { + if (refPos > 0) { + --refPos; + } else { + ++refPos; + } + while (refLine[refPos] <= codingLine[this.codingPos] && + refLine[refPos] < columns) { + refPos += 2; + } + } + break; + case EOF: + this.addPixels(columns, 0); + this.eof = true; + break; + default: + info('bad 2d code'); + this.addPixels(columns, 0); + this.err = true; + } + } + } else { + codingLine[0] = 0; + this.codingPos = 0; + blackPixels = 0; + while (codingLine[this.codingPos] < columns) { + code1 = 0; + if (blackPixels) { + do { + code1 += (code3 = this.getBlackCode()); + } while (code3 >= 64); + } else { + do { + code1 += (code3 = this.getWhiteCode()); + } while (code3 >= 64); + } + this.addPixels(codingLine[this.codingPos] + code1, blackPixels); + blackPixels ^= 1; + } + } + + var gotEOL = false; + + if (this.byteAlign) { + this.inputBits &= ~7; + } + + if (!this.eoblock && this.row === this.rows - 1) { + this.eof = true; + } else { + code1 = this.lookBits(12); + if (this.eoline) { + while (code1 !== EOF && code1 !== 1) { + this.eatBits(1); + code1 = this.lookBits(12); + } + } else { + while (code1 === 0) { + this.eatBits(1); + code1 = this.lookBits(12); + } + } + if (code1 === 1) { + this.eatBits(12); + gotEOL = true; + } else if (code1 === EOF) { + this.eof = true; + } + } + + if (!this.eof && this.encoding > 0) { + this.nextLine2D = !this.lookBits(1); + this.eatBits(1); + } + + if (this.eoblock && gotEOL && this.byteAlign) { + code1 = this.lookBits(12); + if (code1 === 1) { + this.eatBits(12); + if (this.encoding > 0) { + this.lookBits(1); + this.eatBits(1); + } + if (this.encoding >= 0) { + for (i = 0; i < 4; ++i) { + code1 = this.lookBits(12); + if (code1 !== 1) { + info('bad rtc code: ' + code1); + } + this.eatBits(12); + if (this.encoding > 0) { + this.lookBits(1); + this.eatBits(1); + } + } + } + this.eof = true; + } + } else if (this.err && this.eoline) { + while (true) { + code1 = this.lookBits(13); + if (code1 === EOF) { + this.eof = true; + return null; + } + if ((code1 >> 1) === 1) { + break; + } + this.eatBits(1); + } + this.eatBits(12); + if (this.encoding > 0) { + this.eatBits(1); + this.nextLine2D = !(code1 & 1); + } + } + + if (codingLine[0] > 0) { + this.outputBits = codingLine[this.codingPos = 0]; + } else { + this.outputBits = codingLine[this.codingPos = 1]; + } + this.row++; + } + + var c; + if (this.outputBits >= 8) { + c = (this.codingPos & 1) ? 0 : 0xFF; + this.outputBits -= 8; + if (this.outputBits === 0 && codingLine[this.codingPos] < columns) { + this.codingPos++; + this.outputBits = (codingLine[this.codingPos] - + codingLine[this.codingPos - 1]); + } + } else { + bits = 8; + c = 0; + do { + if (this.outputBits > bits) { + c <<= bits; + if (!(this.codingPos & 1)) { + c |= 0xFF >> (8 - bits); + } + this.outputBits -= bits; + bits = 0; + } else { + c <<= this.outputBits; + if (!(this.codingPos & 1)) { + c |= 0xFF >> (8 - this.outputBits); + } + bits -= this.outputBits; + this.outputBits = 0; + if (codingLine[this.codingPos] < columns) { + this.codingPos++; + this.outputBits = (codingLine[this.codingPos] - + codingLine[this.codingPos - 1]); + } else if (bits > 0) { + c <<= bits; + bits = 0; + } + } + } while (bits); + } + if (this.black) { + c ^= 0xFF; + } + return c; + }; + + // This functions returns the code found from the table. + // The start and end parameters set the boundaries for searching the table. + // The limit parameter is optional. Function returns an array with three + // values. The first array element indicates whether a valid code is being + // returned. The second array element is the actual code. The third array + // element indicates whether EOF was reached. + CCITTFaxStream.prototype.findTableCode = + function ccittFaxStreamFindTableCode(start, end, table, limit) { + + var limitValue = limit || 0; + for (var i = start; i <= end; ++i) { + var code = this.lookBits(i); + if (code === EOF) { + return [true, 1, false]; + } + if (i < end) { + code <<= end - i; + } + if (!limitValue || code >= limitValue) { + var p = table[code - limitValue]; + if (p[0] === i) { + this.eatBits(i); + return [true, p[1], true]; + } + } + } + return [false, 0, false]; + }; + + CCITTFaxStream.prototype.getTwoDimCode = + function ccittFaxStreamGetTwoDimCode() { + + var code = 0; + var p; + if (this.eoblock) { + code = this.lookBits(7); + p = twoDimTable[code]; + if (p && p[0] > 0) { + this.eatBits(p[0]); + return p[1]; + } + } else { + var result = this.findTableCode(1, 7, twoDimTable); + if (result[0] && result[2]) { + return result[1]; + } + } + info('Bad two dim code'); + return EOF; + }; + + CCITTFaxStream.prototype.getWhiteCode = + function ccittFaxStreamGetWhiteCode() { + + var code = 0; + var p; + if (this.eoblock) { + code = this.lookBits(12); + if (code === EOF) { + return 1; + } + + if ((code >> 5) === 0) { + p = whiteTable1[code]; + } else { + p = whiteTable2[code >> 3]; + } + + if (p[0] > 0) { + this.eatBits(p[0]); + return p[1]; + } + } else { + var result = this.findTableCode(1, 9, whiteTable2); + if (result[0]) { + return result[1]; + } + + result = this.findTableCode(11, 12, whiteTable1); + if (result[0]) { + return result[1]; + } + } + info('bad white code'); + this.eatBits(1); + return 1; + }; + + CCITTFaxStream.prototype.getBlackCode = + function ccittFaxStreamGetBlackCode() { + + var code, p; + if (this.eoblock) { + code = this.lookBits(13); + if (code === EOF) { + return 1; + } + if ((code >> 7) === 0) { + p = blackTable1[code]; + } else if ((code >> 9) === 0 && (code >> 7) !== 0) { + p = blackTable2[(code >> 1) - 64]; + } else { + p = blackTable3[code >> 7]; + } + + if (p[0] > 0) { + this.eatBits(p[0]); + return p[1]; + } + } else { + var result = this.findTableCode(2, 6, blackTable3); + if (result[0]) { + return result[1]; + } + + result = this.findTableCode(7, 12, blackTable2, 64); + if (result[0]) { + return result[1]; + } + + result = this.findTableCode(10, 13, blackTable1); + if (result[0]) { + return result[1]; + } + } + info('bad black code'); + this.eatBits(1); + return 1; + }; + + CCITTFaxStream.prototype.lookBits = function CCITTFaxStream_lookBits(n) { + var c; + while (this.inputBits < n) { + if ((c = this.str.getByte()) === -1) { + if (this.inputBits === 0) { + return EOF; + } + return ((this.inputBuf << (n - this.inputBits)) & + (0xFFFF >> (16 - n))); + } + this.inputBuf = (this.inputBuf << 8) + c; + this.inputBits += 8; + } + return (this.inputBuf >> (this.inputBits - n)) & (0xFFFF >> (16 - n)); + }; + + CCITTFaxStream.prototype.eatBits = function CCITTFaxStream_eatBits(n) { + if ((this.inputBits -= n) < 0) { + this.inputBits = 0; + } + }; + + return CCITTFaxStream; +})(); + +var LZWStream = (function LZWStreamClosure() { + function LZWStream(str, maybeLength, earlyChange) { + this.str = str; + this.dict = str.dict; + this.cachedData = 0; + this.bitsCached = 0; + + var maxLzwDictionarySize = 4096; + var lzwState = { + earlyChange: earlyChange, + codeLength: 9, + nextCode: 258, + dictionaryValues: new Uint8Array(maxLzwDictionarySize), + dictionaryLengths: new Uint16Array(maxLzwDictionarySize), + dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize), + currentSequence: new Uint8Array(maxLzwDictionarySize), + currentSequenceLength: 0 + }; + for (var i = 0; i < 256; ++i) { + lzwState.dictionaryValues[i] = i; + lzwState.dictionaryLengths[i] = 1; + } + this.lzwState = lzwState; + + DecodeStream.call(this, maybeLength); + } + + LZWStream.prototype = Object.create(DecodeStream.prototype); + + LZWStream.prototype.readBits = function LZWStream_readBits(n) { + var bitsCached = this.bitsCached; + var cachedData = this.cachedData; + while (bitsCached < n) { + var c = this.str.getByte(); + if (c === -1) { + this.eof = true; + return null; + } + cachedData = (cachedData << 8) | c; + bitsCached += 8; + } + this.bitsCached = (bitsCached -= n); + this.cachedData = cachedData; + this.lastCode = null; + return (cachedData >>> bitsCached) & ((1 << n) - 1); + }; + + LZWStream.prototype.readBlock = function LZWStream_readBlock() { + var blockSize = 512; + var estimatedDecodedSize = blockSize * 2, decodedSizeDelta = blockSize; + var i, j, q; + + var lzwState = this.lzwState; + if (!lzwState) { + return; // eof was found + } + + var earlyChange = lzwState.earlyChange; + var nextCode = lzwState.nextCode; + var dictionaryValues = lzwState.dictionaryValues; + var dictionaryLengths = lzwState.dictionaryLengths; + var dictionaryPrevCodes = lzwState.dictionaryPrevCodes; + var codeLength = lzwState.codeLength; + var prevCode = lzwState.prevCode; + var currentSequence = lzwState.currentSequence; + var currentSequenceLength = lzwState.currentSequenceLength; + + var decodedLength = 0; + var currentBufferLength = this.bufferLength; + var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize); + + for (i = 0; i < blockSize; i++) { + var code = this.readBits(codeLength); + var hasPrev = currentSequenceLength > 0; + if (code < 256) { + currentSequence[0] = code; + currentSequenceLength = 1; + } else if (code >= 258) { + if (code < nextCode) { + currentSequenceLength = dictionaryLengths[code]; + for (j = currentSequenceLength - 1, q = code; j >= 0; j--) { + currentSequence[j] = dictionaryValues[q]; + q = dictionaryPrevCodes[q]; + } + } else { + currentSequence[currentSequenceLength++] = currentSequence[0]; + } + } else if (code === 256) { + codeLength = 9; + nextCode = 258; + currentSequenceLength = 0; + continue; + } else { + this.eof = true; + delete this.lzwState; + break; + } + + if (hasPrev) { + dictionaryPrevCodes[nextCode] = prevCode; + dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1; + dictionaryValues[nextCode] = currentSequence[0]; + nextCode++; + codeLength = (nextCode + earlyChange) & (nextCode + earlyChange - 1) ? + codeLength : Math.min(Math.log(nextCode + earlyChange) / + 0.6931471805599453 + 1, 12) | 0; + } + prevCode = code; + + decodedLength += currentSequenceLength; + if (estimatedDecodedSize < decodedLength) { + do { + estimatedDecodedSize += decodedSizeDelta; + } while (estimatedDecodedSize < decodedLength); + buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize); + } + for (j = 0; j < currentSequenceLength; j++) { + buffer[currentBufferLength++] = currentSequence[j]; + } + } + lzwState.nextCode = nextCode; + lzwState.codeLength = codeLength; + lzwState.prevCode = prevCode; + lzwState.currentSequenceLength = currentSequenceLength; + + this.bufferLength = currentBufferLength; + }; + + return LZWStream; +})(); + +var NullStream = (function NullStreamClosure() { + function NullStream() { + Stream.call(this, new Uint8Array(0)); + } + + NullStream.prototype = Stream.prototype; + + return NullStream; +})(); + +// TODO refactor to remove dependency on parser.js +function _setCoreParser(coreParser_) { + coreParser = coreParser_; + EOF = coreParser_.EOF; + Lexer = coreParser_.Lexer; +} +exports._setCoreParser = _setCoreParser; + +// TODO refactor to remove dependency on colorspace.js +function _setCoreColorSpace(coreColorSpace_) { + coreColorSpace = coreColorSpace_; + ColorSpace = coreColorSpace_.ColorSpace; +} +exports._setCoreColorSpace = _setCoreColorSpace; + +exports.Ascii85Stream = Ascii85Stream; +exports.AsciiHexStream = AsciiHexStream; +exports.CCITTFaxStream = CCITTFaxStream; +exports.DecryptStream = DecryptStream; +exports.DecodeStream = DecodeStream; +exports.FlateStream = FlateStream; +exports.Jbig2Stream = Jbig2Stream; +exports.JpegStream = JpegStream; +exports.JpxStream = JpxStream; +exports.NullStream = NullStream; +exports.PredictorStream = PredictorStream; +exports.RunLengthStream = RunLengthStream; +exports.Stream = Stream; +exports.StreamsSequenceStream = StreamsSequenceStream; +exports.StringStream = StringStream; +exports.LZWStream = LZWStream; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreCrypto = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream) { + +var PasswordException = sharedUtil.PasswordException; +var PasswordResponses = sharedUtil.PasswordResponses; +var bytesToString = sharedUtil.bytesToString; +var error = sharedUtil.error; +var isInt = sharedUtil.isInt; +var stringToBytes = sharedUtil.stringToBytes; +var utf8StringToString = sharedUtil.utf8StringToString; +var warn = sharedUtil.warn; +var Name = corePrimitives.Name; +var isName = corePrimitives.isName; +var isDict = corePrimitives.isDict; +var DecryptStream = coreStream.DecryptStream; + +var ARCFourCipher = (function ARCFourCipherClosure() { + function ARCFourCipher(key) { + this.a = 0; + this.b = 0; + var s = new Uint8Array(256); + var i, j = 0, tmp, keyLength = key.length; + for (i = 0; i < 256; ++i) { + s[i] = i; + } + for (i = 0; i < 256; ++i) { + tmp = s[i]; + j = (j + tmp + key[i % keyLength]) & 0xFF; + s[i] = s[j]; + s[j] = tmp; + } + this.s = s; + } + + ARCFourCipher.prototype = { + encryptBlock: function ARCFourCipher_encryptBlock(data) { + var i, n = data.length, tmp, tmp2; + var a = this.a, b = this.b, s = this.s; + var output = new Uint8Array(n); + for (i = 0; i < n; ++i) { + a = (a + 1) & 0xFF; + tmp = s[a]; + b = (b + tmp) & 0xFF; + tmp2 = s[b]; + s[a] = tmp2; + s[b] = tmp; + output[i] = data[i] ^ s[(tmp + tmp2) & 0xFF]; + } + this.a = a; + this.b = b; + return output; + } + }; + ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock; + + return ARCFourCipher; +})(); + +var calculateMD5 = (function calculateMD5Closure() { + var r = new Uint8Array([ + 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, + 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, + 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, + 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]); + + var k = new Int32Array([ + -680876936, -389564586, 606105819, -1044525330, -176418897, 1200080426, + -1473231341, -45705983, 1770035416, -1958414417, -42063, -1990404162, + 1804603682, -40341101, -1502002290, 1236535329, -165796510, -1069501632, + 643717713, -373897302, -701558691, 38016083, -660478335, -405537848, + 568446438, -1019803690, -187363961, 1163531501, -1444681467, -51403784, + 1735328473, -1926607734, -378558, -2022574463, 1839030562, -35309556, + -1530992060, 1272893353, -155497632, -1094730640, 681279174, -358537222, + -722521979, 76029189, -640364487, -421815835, 530742520, -995338651, + -198630844, 1126891415, -1416354905, -57434055, 1700485571, -1894986606, + -1051523, -2054922799, 1873313359, -30611744, -1560198380, 1309151649, + -145523070, -1120210379, 718787259, -343485551]); + + function hash(data, offset, length) { + var h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878; + // pre-processing + var paddedLength = (length + 72) & ~63; // data + 9 extra bytes + var padded = new Uint8Array(paddedLength); + var i, j, n; + for (i = 0; i < length; ++i) { + padded[i] = data[offset++]; + } + padded[i++] = 0x80; + n = paddedLength - 8; + while (i < n) { + padded[i++] = 0; + } + padded[i++] = (length << 3) & 0xFF; + padded[i++] = (length >> 5) & 0xFF; + padded[i++] = (length >> 13) & 0xFF; + padded[i++] = (length >> 21) & 0xFF; + padded[i++] = (length >>> 29) & 0xFF; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + var w = new Int32Array(16); + for (i = 0; i < paddedLength;) { + for (j = 0; j < 16; ++j, i += 4) { + w[j] = (padded[i] | (padded[i + 1] << 8) | + (padded[i + 2] << 16) | (padded[i + 3] << 24)); + } + var a = h0, b = h1, c = h2, d = h3, f, g; + for (j = 0; j < 64; ++j) { + if (j < 16) { + f = (b & c) | ((~b) & d); + g = j; + } else if (j < 32) { + f = (d & b) | ((~d) & c); + g = (5 * j + 1) & 15; + } else if (j < 48) { + f = b ^ c ^ d; + g = (3 * j + 5) & 15; + } else { + f = c ^ (b | (~d)); + g = (7 * j) & 15; + } + var tmp = d, rotateArg = (a + f + k[j] + w[g]) | 0, rotate = r[j]; + d = c; + c = b; + b = (b + ((rotateArg << rotate) | (rotateArg >>> (32 - rotate)))) | 0; + a = tmp; + } + h0 = (h0 + a) | 0; + h1 = (h1 + b) | 0; + h2 = (h2 + c) | 0; + h3 = (h3 + d) | 0; + } + return new Uint8Array([ + h0 & 0xFF, (h0 >> 8) & 0xFF, (h0 >> 16) & 0xFF, (h0 >>> 24) & 0xFF, + h1 & 0xFF, (h1 >> 8) & 0xFF, (h1 >> 16) & 0xFF, (h1 >>> 24) & 0xFF, + h2 & 0xFF, (h2 >> 8) & 0xFF, (h2 >> 16) & 0xFF, (h2 >>> 24) & 0xFF, + h3 & 0xFF, (h3 >> 8) & 0xFF, (h3 >> 16) & 0xFF, (h3 >>> 24) & 0xFF + ]); + } + + return hash; +})(); +var Word64 = (function Word64Closure() { + function Word64(highInteger, lowInteger) { + this.high = highInteger | 0; + this.low = lowInteger | 0; + } + Word64.prototype = { + and: function Word64_and(word) { + this.high &= word.high; + this.low &= word.low; + }, + xor: function Word64_xor(word) { + this.high ^= word.high; + this.low ^= word.low; + }, + + or: function Word64_or(word) { + this.high |= word.high; + this.low |= word.low; + }, + + shiftRight: function Word64_shiftRight(places) { + if (places >= 32) { + this.low = (this.high >>> (places - 32)) | 0; + this.high = 0; + } else { + this.low = (this.low >>> places) | (this.high << (32 - places)); + this.high = (this.high >>> places) | 0; + } + }, + + shiftLeft: function Word64_shiftLeft(places) { + if (places >= 32) { + this.high = this.low << (places - 32); + this.low = 0; + } else { + this.high = (this.high << places) | (this.low >>> (32 - places)); + this.low = this.low << places; + } + }, + + rotateRight: function Word64_rotateRight(places) { + var low, high; + if (places & 32) { + high = this.low; + low = this.high; + } else { + low = this.low; + high = this.high; + } + places &= 31; + this.low = (low >>> places) | (high << (32 - places)); + this.high = (high >>> places) | (low << (32 - places)); + }, + + not: function Word64_not() { + this.high = ~this.high; + this.low = ~this.low; + }, + + add: function Word64_add(word) { + var lowAdd = (this.low >>> 0) + (word.low >>> 0); + var highAdd = (this.high >>> 0) + (word.high >>> 0); + if (lowAdd > 0xFFFFFFFF) { + highAdd += 1; + } + this.low = lowAdd | 0; + this.high = highAdd | 0; + }, + + copyTo: function Word64_copyTo(bytes, offset) { + bytes[offset] = (this.high >>> 24) & 0xFF; + bytes[offset + 1] = (this.high >> 16) & 0xFF; + bytes[offset + 2] = (this.high >> 8) & 0xFF; + bytes[offset + 3] = this.high & 0xFF; + bytes[offset + 4] = (this.low >>> 24) & 0xFF; + bytes[offset + 5] = (this.low >> 16) & 0xFF; + bytes[offset + 6] = (this.low >> 8) & 0xFF; + bytes[offset + 7] = this.low & 0xFF; + }, + + assign: function Word64_assign(word) { + this.high = word.high; + this.low = word.low; + } + }; + return Word64; +})(); + +var calculateSHA256 = (function calculateSHA256Closure() { + function rotr(x, n) { + return (x >>> n) | (x << 32 - n); + } + + function ch(x, y, z) { + return (x & y) ^ (~x & z); + } + + function maj(x, y, z) { + return (x & y) ^ (x & z) ^ (y & z); + } + + function sigma(x) { + return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); + } + + function sigmaPrime(x) { + return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); + } + + function littleSigma(x) { + return rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3; + } + + function littleSigmaPrime(x) { + return rotr(x, 17) ^ rotr(x, 19) ^ x >>> 10; + } + + var k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]; + + function hash(data, offset, length) { + // initial hash values + var h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, + h3 = 0xa54ff53a, h4 = 0x510e527f, h5 = 0x9b05688c, + h6 = 0x1f83d9ab, h7 = 0x5be0cd19; + // pre-processing + var paddedLength = Math.ceil((length + 9) / 64) * 64; + var padded = new Uint8Array(paddedLength); + var i, j, n; + for (i = 0; i < length; ++i) { + padded[i] = data[offset++]; + } + padded[i++] = 0x80; + n = paddedLength - 8; + while (i < n) { + padded[i++] = 0; + } + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = (length >>> 29) & 0xFF; + padded[i++] = (length >> 21) & 0xFF; + padded[i++] = (length >> 13) & 0xFF; + padded[i++] = (length >> 5) & 0xFF; + padded[i++] = (length << 3) & 0xFF; + var w = new Uint32Array(64); + // for each 512 bit block + for (i = 0; i < paddedLength;) { + for (j = 0; j < 16; ++j) { + w[j] = (padded[i] << 24 | (padded[i + 1] << 16) | + (padded[i + 2] << 8) | (padded[i + 3])); + i += 4; + } + + for (j = 16; j < 64; ++j) { + w[j] = littleSigmaPrime(w[j - 2]) + w[j - 7] + + littleSigma(w[j - 15]) + w[j - 16] | 0; + } + var a = h0, b = h1, c = h2, d = h3, e = h4, + f = h5, g = h6, h = h7, t1, t2; + for (j = 0; j < 64; ++j) { + t1 = h + sigmaPrime(e) + ch(e, f, g) + k[j] + w[j]; + t2 = sigma(a) + maj(a, b, c); + h = g; + g = f; + f = e; + e = (d + t1) | 0; + d = c; + c = b; + b = a; + a = (t1 + t2) | 0; + } + h0 = (h0 + a) | 0; + h1 = (h1 + b) | 0; + h2 = (h2 + c) | 0; + h3 = (h3 + d) | 0; + h4 = (h4 + e) | 0; + h5 = (h5 + f) | 0; + h6 = (h6 + g) | 0; + h7 = (h7 + h) | 0; + } + return new Uint8Array([ + (h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, (h0) & 0xFF, + (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, (h1) & 0xFF, + (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, (h2) & 0xFF, + (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, (h3) & 0xFF, + (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, (h4) & 0xFF, + (h5 >> 24) & 0xFF, (h5 >> 16) & 0xFF, (h5 >> 8) & 0xFF, (h5) & 0xFF, + (h6 >> 24) & 0xFF, (h6 >> 16) & 0xFF, (h6 >> 8) & 0xFF, (h6) & 0xFF, + (h7 >> 24) & 0xFF, (h7 >> 16) & 0xFF, (h7 >> 8) & 0xFF, (h7) & 0xFF + ]); + } + + return hash; +})(); + +var calculateSHA512 = (function calculateSHA512Closure() { + function ch(result, x, y, z, tmp) { + result.assign(x); + result.and(y); + tmp.assign(x); + tmp.not(); + tmp.and(z); + result.xor(tmp); + } + + function maj(result, x, y, z, tmp) { + result.assign(x); + result.and(y); + tmp.assign(x); + tmp.and(z); + result.xor(tmp); + tmp.assign(y); + tmp.and(z); + result.xor(tmp); + } + + function sigma(result, x, tmp) { + result.assign(x); + result.rotateRight(28); + tmp.assign(x); + tmp.rotateRight(34); + result.xor(tmp); + tmp.assign(x); + tmp.rotateRight(39); + result.xor(tmp); + } + + function sigmaPrime(result, x, tmp) { + result.assign(x); + result.rotateRight(14); + tmp.assign(x); + tmp.rotateRight(18); + result.xor(tmp); + tmp.assign(x); + tmp.rotateRight(41); + result.xor(tmp); + } + + function littleSigma(result, x, tmp) { + result.assign(x); + result.rotateRight(1); + tmp.assign(x); + tmp.rotateRight(8); + result.xor(tmp); + tmp.assign(x); + tmp.shiftRight(7); + result.xor(tmp); + } + + function littleSigmaPrime(result, x, tmp) { + result.assign(x); + result.rotateRight(19); + tmp.assign(x); + tmp.rotateRight(61); + result.xor(tmp); + tmp.assign(x); + tmp.shiftRight(6); + result.xor(tmp); + } + + var k = [ + new Word64(0x428a2f98, 0xd728ae22), new Word64(0x71374491, 0x23ef65cd), + new Word64(0xb5c0fbcf, 0xec4d3b2f), new Word64(0xe9b5dba5, 0x8189dbbc), + new Word64(0x3956c25b, 0xf348b538), new Word64(0x59f111f1, 0xb605d019), + new Word64(0x923f82a4, 0xaf194f9b), new Word64(0xab1c5ed5, 0xda6d8118), + new Word64(0xd807aa98, 0xa3030242), new Word64(0x12835b01, 0x45706fbe), + new Word64(0x243185be, 0x4ee4b28c), new Word64(0x550c7dc3, 0xd5ffb4e2), + new Word64(0x72be5d74, 0xf27b896f), new Word64(0x80deb1fe, 0x3b1696b1), + new Word64(0x9bdc06a7, 0x25c71235), new Word64(0xc19bf174, 0xcf692694), + new Word64(0xe49b69c1, 0x9ef14ad2), new Word64(0xefbe4786, 0x384f25e3), + new Word64(0x0fc19dc6, 0x8b8cd5b5), new Word64(0x240ca1cc, 0x77ac9c65), + new Word64(0x2de92c6f, 0x592b0275), new Word64(0x4a7484aa, 0x6ea6e483), + new Word64(0x5cb0a9dc, 0xbd41fbd4), new Word64(0x76f988da, 0x831153b5), + new Word64(0x983e5152, 0xee66dfab), new Word64(0xa831c66d, 0x2db43210), + new Word64(0xb00327c8, 0x98fb213f), new Word64(0xbf597fc7, 0xbeef0ee4), + new Word64(0xc6e00bf3, 0x3da88fc2), new Word64(0xd5a79147, 0x930aa725), + new Word64(0x06ca6351, 0xe003826f), new Word64(0x14292967, 0x0a0e6e70), + new Word64(0x27b70a85, 0x46d22ffc), new Word64(0x2e1b2138, 0x5c26c926), + new Word64(0x4d2c6dfc, 0x5ac42aed), new Word64(0x53380d13, 0x9d95b3df), + new Word64(0x650a7354, 0x8baf63de), new Word64(0x766a0abb, 0x3c77b2a8), + new Word64(0x81c2c92e, 0x47edaee6), new Word64(0x92722c85, 0x1482353b), + new Word64(0xa2bfe8a1, 0x4cf10364), new Word64(0xa81a664b, 0xbc423001), + new Word64(0xc24b8b70, 0xd0f89791), new Word64(0xc76c51a3, 0x0654be30), + new Word64(0xd192e819, 0xd6ef5218), new Word64(0xd6990624, 0x5565a910), + new Word64(0xf40e3585, 0x5771202a), new Word64(0x106aa070, 0x32bbd1b8), + new Word64(0x19a4c116, 0xb8d2d0c8), new Word64(0x1e376c08, 0x5141ab53), + new Word64(0x2748774c, 0xdf8eeb99), new Word64(0x34b0bcb5, 0xe19b48a8), + new Word64(0x391c0cb3, 0xc5c95a63), new Word64(0x4ed8aa4a, 0xe3418acb), + new Word64(0x5b9cca4f, 0x7763e373), new Word64(0x682e6ff3, 0xd6b2b8a3), + new Word64(0x748f82ee, 0x5defb2fc), new Word64(0x78a5636f, 0x43172f60), + new Word64(0x84c87814, 0xa1f0ab72), new Word64(0x8cc70208, 0x1a6439ec), + new Word64(0x90befffa, 0x23631e28), new Word64(0xa4506ceb, 0xde82bde9), + new Word64(0xbef9a3f7, 0xb2c67915), new Word64(0xc67178f2, 0xe372532b), + new Word64(0xca273ece, 0xea26619c), new Word64(0xd186b8c7, 0x21c0c207), + new Word64(0xeada7dd6, 0xcde0eb1e), new Word64(0xf57d4f7f, 0xee6ed178), + new Word64(0x06f067aa, 0x72176fba), new Word64(0x0a637dc5, 0xa2c898a6), + new Word64(0x113f9804, 0xbef90dae), new Word64(0x1b710b35, 0x131c471b), + new Word64(0x28db77f5, 0x23047d84), new Word64(0x32caab7b, 0x40c72493), + new Word64(0x3c9ebe0a, 0x15c9bebc), new Word64(0x431d67c4, 0x9c100d4c), + new Word64(0x4cc5d4be, 0xcb3e42b6), new Word64(0x597f299c, 0xfc657e2a), + new Word64(0x5fcb6fab, 0x3ad6faec), new Word64(0x6c44198c, 0x4a475817)]; + + function hash(data, offset, length, mode384) { + mode384 = !!mode384; + // initial hash values + var h0, h1, h2, h3, h4, h5, h6, h7; + if (!mode384) { + h0 = new Word64(0x6a09e667, 0xf3bcc908); + h1 = new Word64(0xbb67ae85, 0x84caa73b); + h2 = new Word64(0x3c6ef372, 0xfe94f82b); + h3 = new Word64(0xa54ff53a, 0x5f1d36f1); + h4 = new Word64(0x510e527f, 0xade682d1); + h5 = new Word64(0x9b05688c, 0x2b3e6c1f); + h6 = new Word64(0x1f83d9ab, 0xfb41bd6b); + h7 = new Word64(0x5be0cd19, 0x137e2179); + } + else { + // SHA384 is exactly the same + // except with different starting values and a trimmed result + h0 = new Word64(0xcbbb9d5d, 0xc1059ed8); + h1 = new Word64(0x629a292a, 0x367cd507); + h2 = new Word64(0x9159015a, 0x3070dd17); + h3 = new Word64(0x152fecd8, 0xf70e5939); + h4 = new Word64(0x67332667, 0xffc00b31); + h5 = new Word64(0x8eb44a87, 0x68581511); + h6 = new Word64(0xdb0c2e0d, 0x64f98fa7); + h7 = new Word64(0x47b5481d, 0xbefa4fa4); + } + + // pre-processing + var paddedLength = Math.ceil((length + 17) / 128) * 128; + var padded = new Uint8Array(paddedLength); + var i, j, n; + for (i = 0; i < length; ++i) { + padded[i] = data[offset++]; + } + padded[i++] = 0x80; + n = paddedLength - 16; + while (i < n) { + padded[i++] = 0; + } + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = 0; + padded[i++] = (length >>> 29) & 0xFF; + padded[i++] = (length >> 21) & 0xFF; + padded[i++] = (length >> 13) & 0xFF; + padded[i++] = (length >> 5) & 0xFF; + padded[i++] = (length << 3) & 0xFF; + + var w = new Array(80); + for (i = 0; i < 80; i++) { + w[i] = new Word64(0, 0); + } + var a = new Word64(0, 0), b = new Word64(0, 0), c = new Word64(0, 0); + var d = new Word64(0, 0), e = new Word64(0, 0), f = new Word64(0, 0); + var g = new Word64(0, 0), h = new Word64(0, 0); + var t1 = new Word64(0, 0), t2 = new Word64(0, 0); + var tmp1 = new Word64(0, 0), tmp2 = new Word64(0, 0), tmp3; + + // for each 1024 bit block + for (i = 0; i < paddedLength;) { + for (j = 0; j < 16; ++j) { + w[j].high = (padded[i] << 24) | (padded[i + 1] << 16) | + (padded[i + 2] << 8) | (padded[i + 3]); + w[j].low = (padded[i + 4]) << 24 | (padded[i + 5]) << 16 | + (padded[i + 6]) << 8 | (padded[i + 7]); + i += 8; + } + for (j = 16; j < 80; ++j) { + tmp3 = w[j]; + littleSigmaPrime(tmp3, w[j - 2], tmp2); + tmp3.add(w[j - 7]); + littleSigma(tmp1, w[j - 15], tmp2); + tmp3.add(tmp1); + tmp3.add(w[j - 16]); + } + + a.assign(h0); b.assign(h1); c.assign(h2); d.assign(h3); + e.assign(h4); f.assign(h5); g.assign(h6); h.assign(h7); + for (j = 0; j < 80; ++j) { + t1.assign(h); + sigmaPrime(tmp1, e, tmp2); + t1.add(tmp1); + ch(tmp1, e, f, g, tmp2); + t1.add(tmp1); + t1.add(k[j]); + t1.add(w[j]); + + sigma(t2, a, tmp2); + maj(tmp1, a, b, c, tmp2); + t2.add(tmp1); + + tmp3 = h; + h = g; + g = f; + f = e; + d.add(t1); + e = d; + d = c; + c = b; + b = a; + tmp3.assign(t1); + tmp3.add(t2); + a = tmp3; + } + h0.add(a); + h1.add(b); + h2.add(c); + h3.add(d); + h4.add(e); + h5.add(f); + h6.add(g); + h7.add(h); + } + + var result; + if (!mode384) { + result = new Uint8Array(64); + h0.copyTo(result,0); + h1.copyTo(result,8); + h2.copyTo(result,16); + h3.copyTo(result,24); + h4.copyTo(result,32); + h5.copyTo(result,40); + h6.copyTo(result,48); + h7.copyTo(result,56); + } + else { + result = new Uint8Array(48); + h0.copyTo(result,0); + h1.copyTo(result,8); + h2.copyTo(result,16); + h3.copyTo(result,24); + h4.copyTo(result,32); + h5.copyTo(result,40); + } + return result; + } + + return hash; +})(); +var calculateSHA384 = (function calculateSHA384Closure() { + function hash(data, offset, length) { + return calculateSHA512(data, offset, length, true); + } + + return hash; +})(); +var NullCipher = (function NullCipherClosure() { + function NullCipher() { + } + + NullCipher.prototype = { + decryptBlock: function NullCipher_decryptBlock(data) { + return data; + } + }; + + return NullCipher; +})(); + +var AES128Cipher = (function AES128CipherClosure() { + var rcon = new Uint8Array([ + 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, + 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, + 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, + 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, + 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, + 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, + 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, + 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, + 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, + 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, + 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, + 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, + 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, + 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, + 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, + 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, + 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, + 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, + 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, + 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, + 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, + 0x74, 0xe8, 0xcb, 0x8d]); + + var s = new Uint8Array([ + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, + 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, + 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, + 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, + 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, + 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, + 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, + 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, + 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, + 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, + 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, + 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, + 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, + 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, + 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, + 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, + 0xb0, 0x54, 0xbb, 0x16]); + + var inv_s = new Uint8Array([ + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, + 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, + 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, + 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, + 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, + 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, + 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, + 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, + 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, + 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, + 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, + 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, + 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, + 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, + 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, + 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, + 0x55, 0x21, 0x0c, 0x7d]); + var mixCol = new Uint8Array(256); + for (var i = 0; i < 256; i++) { + if (i < 128) { + mixCol[i] = i << 1; + } else { + mixCol[i] = (i << 1) ^ 0x1b; + } + } + var mix = new Uint32Array([ + 0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, + 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, + 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, + 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, + 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, + 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, + 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, + 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, + 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, + 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, + 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, + 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, + 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, + 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, + 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, + 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, + 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, + 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, + 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, + 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, + 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, + 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, + 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, + 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, + 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, + 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, + 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, + 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, + 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, + 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, + 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, + 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, + 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, + 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, + 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, + 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, + 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, + 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, + 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, + 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, + 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, + 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, + 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]); + + function expandKey128(cipherKey) { + var b = 176, result = new Uint8Array(b); + result.set(cipherKey); + for (var j = 16, i = 1; j < b; ++i) { + // RotWord + var t1 = result[j - 3], t2 = result[j - 2], + t3 = result[j - 1], t4 = result[j - 4]; + // SubWord + t1 = s[t1]; + t2 = s[t2]; + t3 = s[t3]; + t4 = s[t4]; + // Rcon + t1 = t1 ^ rcon[i]; + for (var n = 0; n < 4; ++n) { + result[j] = (t1 ^= result[j - 16]); + j++; + result[j] = (t2 ^= result[j - 16]); + j++; + result[j] = (t3 ^= result[j - 16]); + j++; + result[j] = (t4 ^= result[j - 16]); + j++; + } + } + return result; + } + + function decrypt128(input, key) { + var state = new Uint8Array(16); + state.set(input); + var i, j, k; + var t, u, v; + // AddRoundKey + for (j = 0, k = 160; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + for (i = 9; i >= 1; --i) { + // InvShiftRows + t = state[13]; + state[13] = state[9]; + state[9] = state[5]; + state[5] = state[1]; + state[1] = t; + t = state[14]; + u = state[10]; + state[14] = state[6]; + state[10] = state[2]; + state[6] = t; + state[2] = u; + t = state[15]; + u = state[11]; + v = state[7]; + state[15] = state[3]; + state[11] = t; + state[7] = u; + state[3] = v; + // InvSubBytes + for (j = 0; j < 16; ++j) { + state[j] = inv_s[state[j]]; + } + // AddRoundKey + for (j = 0, k = i * 16; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + // InvMixColumns + for (j = 0; j < 16; j += 4) { + var s0 = mix[state[j]], s1 = mix[state[j + 1]], + s2 = mix[state[j + 2]], s3 = mix[state[j + 3]]; + t = (s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^ + (s3 >>> 24) ^ (s3 << 8)); + state[j] = (t >>> 24) & 0xFF; + state[j + 1] = (t >> 16) & 0xFF; + state[j + 2] = (t >> 8) & 0xFF; + state[j + 3] = t & 0xFF; + } + } + // InvShiftRows + t = state[13]; + state[13] = state[9]; + state[9] = state[5]; + state[5] = state[1]; + state[1] = t; + t = state[14]; + u = state[10]; + state[14] = state[6]; + state[10] = state[2]; + state[6] = t; + state[2] = u; + t = state[15]; + u = state[11]; + v = state[7]; + state[15] = state[3]; + state[11] = t; + state[7] = u; + state[3] = v; + for (j = 0; j < 16; ++j) { + // InvSubBytes + state[j] = inv_s[state[j]]; + // AddRoundKey + state[j] ^= key[j]; + } + return state; + } + + function encrypt128(input, key) { + var t, u, v, k; + var state = new Uint8Array(16); + state.set(input); + for (j = 0; j < 16; ++j) { + // AddRoundKey + state[j] ^= key[j]; + } + + for (i = 1; i < 10; i++) { + //SubBytes + for (j = 0; j < 16; ++j) { + state[j] = s[state[j]]; + } + //ShiftRows + v = state[1]; + state[1] = state[5]; + state[5] = state[9]; + state[9] = state[13]; + state[13] = v; + v = state[2]; + u = state[6]; + state[2] = state[10]; + state[6] = state[14]; + state[10] = v; + state[14] = u; + v = state[3]; + u = state[7]; + t = state[11]; + state[3] = state[15]; + state[7] = v; + state[11] = u; + state[15] = t; + //MixColumns + for (var j = 0; j < 16; j += 4) { + var s0 = state[j + 0], s1 = state[j + 1]; + var s2 = state[j + 2], s3 = state[j + 3]; + t = s0 ^ s1 ^ s2 ^ s3; + state[j + 0] ^= t ^ mixCol[s0 ^ s1]; + state[j + 1] ^= t ^ mixCol[s1 ^ s2]; + state[j + 2] ^= t ^ mixCol[s2 ^ s3]; + state[j + 3] ^= t ^ mixCol[s3 ^ s0]; + } + //AddRoundKey + for (j = 0, k = i * 16; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + } + + //SubBytes + for (j = 0; j < 16; ++j) { + state[j] = s[state[j]]; + } + //ShiftRows + v = state[1]; + state[1] = state[5]; + state[5] = state[9]; + state[9] = state[13]; + state[13] = v; + v = state[2]; + u = state[6]; + state[2] = state[10]; + state[6] = state[14]; + state[10] = v; + state[14] = u; + v = state[3]; + u = state[7]; + t = state[11]; + state[3] = state[15]; + state[7] = v; + state[11] = u; + state[15] = t; + //AddRoundKey + for (j = 0, k = 160; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + return state; + } + + function AES128Cipher(key) { + this.key = expandKey128(key); + this.buffer = new Uint8Array(16); + this.bufferPosition = 0; + } + + function decryptBlock2(data, finalize) { + var i, j, ii, sourceLength = data.length, + buffer = this.buffer, bufferLength = this.bufferPosition, + result = [], iv = this.iv; + for (i = 0; i < sourceLength; ++i) { + buffer[bufferLength] = data[i]; + ++bufferLength; + if (bufferLength < 16) { + continue; + } + // buffer is full, decrypting + var plain = decrypt128(buffer, this.key); + // xor-ing the IV vector to get plain text + for (j = 0; j < 16; ++j) { + plain[j] ^= iv[j]; + } + iv = buffer; + result.push(plain); + buffer = new Uint8Array(16); + bufferLength = 0; + } + // saving incomplete buffer + this.buffer = buffer; + this.bufferLength = bufferLength; + this.iv = iv; + if (result.length === 0) { + return new Uint8Array([]); + } + // combining plain text blocks into one + var outputLength = 16 * result.length; + if (finalize) { + // undo a padding that is described in RFC 2898 + var lastBlock = result[result.length - 1]; + var psLen = lastBlock[15]; + if (psLen <= 16) { + for (i = 15, ii = 16 - psLen; i >= ii; --i) { + if (lastBlock[i] !== psLen) { + // Invalid padding, assume that the block has no padding. + psLen = 0; + break; + } + } + outputLength -= psLen; + result[result.length - 1] = lastBlock.subarray(0, 16 - psLen); + } + } + var output = new Uint8Array(outputLength); + for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) { + output.set(result[i], j); + } + return output; + } + + AES128Cipher.prototype = { + decryptBlock: function AES128Cipher_decryptBlock(data, finalize) { + var i, sourceLength = data.length; + var buffer = this.buffer, bufferLength = this.bufferPosition; + // waiting for IV values -- they are at the start of the stream + for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) { + buffer[bufferLength] = data[i]; + } + if (bufferLength < 16) { + // need more data + this.bufferLength = bufferLength; + return new Uint8Array([]); + } + this.iv = buffer; + this.buffer = new Uint8Array(16); + this.bufferLength = 0; + // starting decryption + this.decryptBlock = decryptBlock2; + return this.decryptBlock(data.subarray(16), finalize); + }, + encrypt: function AES128Cipher_encrypt(data, iv) { + var i, j, ii, sourceLength = data.length, + buffer = this.buffer, bufferLength = this.bufferPosition, + result = []; + if (!iv) { + iv = new Uint8Array(16); + } + for (i = 0; i < sourceLength; ++i) { + buffer[bufferLength] = data[i]; + ++bufferLength; + if (bufferLength < 16) { + continue; + } + for (j = 0; j < 16; ++j) { + buffer[j] ^= iv[j]; + } + + // buffer is full, encrypting + var cipher = encrypt128(buffer, this.key); + iv = cipher; + result.push(cipher); + buffer = new Uint8Array(16); + bufferLength = 0; + } + // saving incomplete buffer + this.buffer = buffer; + this.bufferLength = bufferLength; + this.iv = iv; + if (result.length === 0) { + return new Uint8Array([]); + } + // combining plain text blocks into one + var outputLength = 16 * result.length; + var output = new Uint8Array(outputLength); + for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) { + output.set(result[i], j); + } + return output; + } + }; + + return AES128Cipher; +})(); + +var AES256Cipher = (function AES256CipherClosure() { + var rcon = new Uint8Array([ + 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, + 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, + 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, + 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, + 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, + 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, + 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, + 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, + 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, + 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, + 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, + 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, + 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, + 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, + 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, + 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, + 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, + 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, + 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, + 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, + 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, + 0x74, 0xe8, 0xcb, 0x8d]); + + var s = new Uint8Array([ + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, + 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, + 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, + 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, + 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, + 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, + 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, + 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, + 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, + 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, + 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, + 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, + 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, + 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, + 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, + 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, + 0xb0, 0x54, 0xbb, 0x16]); + + var inv_s = new Uint8Array([ + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, + 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, + 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, + 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, + 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, + 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, + 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, + 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, + 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, + 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, + 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, + 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, + 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, + 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, + 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, + 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, + 0x55, 0x21, 0x0c, 0x7d]); + + var mixCol = new Uint8Array(256); + for (var i = 0; i < 256; i++) { + if (i < 128) { + mixCol[i] = i << 1; + } else { + mixCol[i] = (i << 1) ^ 0x1b; + } + } + var mix = new Uint32Array([ + 0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, + 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, + 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, + 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, + 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, + 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, + 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, + 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, + 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, + 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, + 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, + 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, + 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, + 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, + 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, + 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, + 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, + 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, + 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, + 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, + 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, + 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, + 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, + 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, + 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, + 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, + 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, + 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, + 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, + 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, + 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, + 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, + 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, + 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, + 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, + 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, + 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, + 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, + 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, + 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, + 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, + 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, + 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]); + + function expandKey256(cipherKey) { + var b = 240, result = new Uint8Array(b); + var r = 1; + + result.set(cipherKey); + for (var j = 32, i = 1; j < b; ++i) { + if (j % 32 === 16) { + t1 = s[t1]; + t2 = s[t2]; + t3 = s[t3]; + t4 = s[t4]; + } else if (j % 32 === 0) { + // RotWord + var t1 = result[j - 3], t2 = result[j - 2], + t3 = result[j - 1], t4 = result[j - 4]; + // SubWord + t1 = s[t1]; + t2 = s[t2]; + t3 = s[t3]; + t4 = s[t4]; + // Rcon + t1 = t1 ^ r; + if ((r <<= 1) >= 256) { + r = (r ^ 0x1b) & 0xFF; + } + } + + for (var n = 0; n < 4; ++n) { + result[j] = (t1 ^= result[j - 32]); + j++; + result[j] = (t2 ^= result[j - 32]); + j++; + result[j] = (t3 ^= result[j - 32]); + j++; + result[j] = (t4 ^= result[j - 32]); + j++; + } + } + return result; + } + + function decrypt256(input, key) { + var state = new Uint8Array(16); + state.set(input); + var i, j, k; + var t, u, v; + // AddRoundKey + for (j = 0, k = 224; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + for (i = 13; i >= 1; --i) { + // InvShiftRows + t = state[13]; + state[13] = state[9]; + state[9] = state[5]; + state[5] = state[1]; + state[1] = t; + t = state[14]; + u = state[10]; + state[14] = state[6]; + state[10] = state[2]; + state[6] = t; + state[2] = u; + t = state[15]; + u = state[11]; + v = state[7]; + state[15] = state[3]; + state[11] = t; + state[7] = u; + state[3] = v; + // InvSubBytes + for (j = 0; j < 16; ++j) { + state[j] = inv_s[state[j]]; + } + // AddRoundKey + for (j = 0, k = i * 16; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + // InvMixColumns + for (j = 0; j < 16; j += 4) { + var s0 = mix[state[j]], s1 = mix[state[j + 1]], + s2 = mix[state[j + 2]], s3 = mix[state[j + 3]]; + t = (s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^ + (s3 >>> 24) ^ (s3 << 8)); + state[j] = (t >>> 24) & 0xFF; + state[j + 1] = (t >> 16) & 0xFF; + state[j + 2] = (t >> 8) & 0xFF; + state[j + 3] = t & 0xFF; + } + } + // InvShiftRows + t = state[13]; + state[13] = state[9]; + state[9] = state[5]; + state[5] = state[1]; + state[1] = t; + t = state[14]; + u = state[10]; + state[14] = state[6]; + state[10] = state[2]; + state[6] = t; + state[2] = u; + t = state[15]; + u = state[11]; + v = state[7]; + state[15] = state[3]; + state[11] = t; + state[7] = u; + state[3] = v; + for (j = 0; j < 16; ++j) { + // InvSubBytes + state[j] = inv_s[state[j]]; + // AddRoundKey + state[j] ^= key[j]; + } + return state; + } + + function encrypt256(input, key) { + var t, u, v, k; + var state = new Uint8Array(16); + state.set(input); + for (j = 0; j < 16; ++j) { + // AddRoundKey + state[j] ^= key[j]; + } + + for (i = 1; i < 14; i++) { + //SubBytes + for (j = 0; j < 16; ++j) { + state[j] = s[state[j]]; + } + //ShiftRows + v = state[1]; + state[1] = state[5]; + state[5] = state[9]; + state[9] = state[13]; + state[13] = v; + v = state[2]; + u = state[6]; + state[2] = state[10]; + state[6] = state[14]; + state[10] = v; + state[14] = u; + v = state[3]; + u = state[7]; + t = state[11]; + state[3] = state[15]; + state[7] = v; + state[11] = u; + state[15] = t; + //MixColumns + for (var j = 0; j < 16; j += 4) { + var s0 = state[j + 0], s1 = state[j + 1]; + var s2 = state[j + 2], s3 = state[j + 3]; + t = s0 ^ s1 ^ s2 ^ s3; + state[j + 0] ^= t ^ mixCol[s0 ^ s1]; + state[j + 1] ^= t ^ mixCol[s1 ^ s2]; + state[j + 2] ^= t ^ mixCol[s2 ^ s3]; + state[j + 3] ^= t ^ mixCol[s3 ^ s0]; + } + //AddRoundKey + for (j = 0, k = i * 16; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + } + + //SubBytes + for (j = 0; j < 16; ++j) { + state[j] = s[state[j]]; + } + //ShiftRows + v = state[1]; + state[1] = state[5]; + state[5] = state[9]; + state[9] = state[13]; + state[13] = v; + v = state[2]; + u = state[6]; + state[2] = state[10]; + state[6] = state[14]; + state[10] = v; + state[14] = u; + v = state[3]; + u = state[7]; + t = state[11]; + state[3] = state[15]; + state[7] = v; + state[11] = u; + state[15] = t; + //AddRoundKey + for (j = 0, k = 224; j < 16; ++j, ++k) { + state[j] ^= key[k]; + } + + return state; + + } + + function AES256Cipher(key) { + this.key = expandKey256(key); + this.buffer = new Uint8Array(16); + this.bufferPosition = 0; + } + + function decryptBlock2(data, finalize) { + var i, j, ii, sourceLength = data.length, + buffer = this.buffer, bufferLength = this.bufferPosition, + result = [], iv = this.iv; + + for (i = 0; i < sourceLength; ++i) { + buffer[bufferLength] = data[i]; + ++bufferLength; + if (bufferLength < 16) { + continue; + } + // buffer is full, decrypting + var plain = decrypt256(buffer, this.key); + // xor-ing the IV vector to get plain text + for (j = 0; j < 16; ++j) { + plain[j] ^= iv[j]; + } + iv = buffer; + result.push(plain); + buffer = new Uint8Array(16); + bufferLength = 0; + } + // saving incomplete buffer + this.buffer = buffer; + this.bufferLength = bufferLength; + this.iv = iv; + if (result.length === 0) { + return new Uint8Array([]); + } + // combining plain text blocks into one + var outputLength = 16 * result.length; + if (finalize) { + // undo a padding that is described in RFC 2898 + var lastBlock = result[result.length - 1]; + var psLen = lastBlock[15]; + if (psLen <= 16) { + for (i = 15, ii = 16 - psLen; i >= ii; --i) { + if (lastBlock[i] !== psLen) { + // Invalid padding, assume that the block has no padding. + psLen = 0; + break; + } + } + outputLength -= psLen; + result[result.length - 1] = lastBlock.subarray(0, 16 - psLen); + } + } + var output = new Uint8Array(outputLength); + for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) { + output.set(result[i], j); + } + return output; + + } + + AES256Cipher.prototype = { + decryptBlock: function AES256Cipher_decryptBlock(data, finalize, iv) { + var i, sourceLength = data.length; + var buffer = this.buffer, bufferLength = this.bufferPosition; + // if not supplied an IV wait for IV values + // they are at the start of the stream + if (iv) { + this.iv = iv; + } else { + for (i = 0; bufferLength < 16 && + i < sourceLength; ++i, ++bufferLength) { + buffer[bufferLength] = data[i]; + } + if (bufferLength < 16) { + //need more data + this.bufferLength = bufferLength; + return new Uint8Array([]); + } + this.iv = buffer; + data = data.subarray(16); + } + this.buffer = new Uint8Array(16); + this.bufferLength = 0; + // starting decryption + this.decryptBlock = decryptBlock2; + return this.decryptBlock(data, finalize); + }, + encrypt: function AES256Cipher_encrypt(data, iv) { + var i, j, ii, sourceLength = data.length, + buffer = this.buffer, bufferLength = this.bufferPosition, + result = []; + if (!iv) { + iv = new Uint8Array(16); + } + for (i = 0; i < sourceLength; ++i) { + buffer[bufferLength] = data[i]; + ++bufferLength; + if (bufferLength < 16) { + continue; + } + for (j = 0; j < 16; ++j) { + buffer[j] ^= iv[j]; + } + + // buffer is full, encrypting + var cipher = encrypt256(buffer, this.key); + this.iv = cipher; + result.push(cipher); + buffer = new Uint8Array(16); + bufferLength = 0; + } + // saving incomplete buffer + this.buffer = buffer; + this.bufferLength = bufferLength; + this.iv = iv; + if (result.length === 0) { + return new Uint8Array([]); + } + // combining plain text blocks into one + var outputLength = 16 * result.length; + var output = new Uint8Array(outputLength); + for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) { + output.set(result[i], j); + } + return output; + } + }; + + return AES256Cipher; +})(); + +var PDF17 = (function PDF17Closure() { + + function compareByteArrays(array1, array2) { + if (array1.length !== array2.length) { + return false; + } + for (var i = 0; i < array1.length; i++) { + if (array1[i] !== array2[i]) { + return false; + } + } + return true; + } + + function PDF17() { + } + + PDF17.prototype = { + checkOwnerPassword: function PDF17_checkOwnerPassword(password, + ownerValidationSalt, + userBytes, + ownerPassword) { + var hashData = new Uint8Array(password.length + 56); + hashData.set(password, 0); + hashData.set(ownerValidationSalt, password.length); + hashData.set(userBytes, password.length + ownerValidationSalt.length); + var result = calculateSHA256(hashData, 0, hashData.length); + return compareByteArrays(result, ownerPassword); + }, + checkUserPassword: function PDF17_checkUserPassword(password, + userValidationSalt, + userPassword) { + var hashData = new Uint8Array(password.length + 8); + hashData.set(password, 0); + hashData.set(userValidationSalt, password.length); + var result = calculateSHA256(hashData, 0, hashData.length); + return compareByteArrays(result, userPassword); + }, + getOwnerKey: function PDF17_getOwnerKey(password, ownerKeySalt, userBytes, + ownerEncryption) { + var hashData = new Uint8Array(password.length + 56); + hashData.set(password, 0); + hashData.set(ownerKeySalt, password.length); + hashData.set(userBytes, password.length + ownerKeySalt.length); + var key = calculateSHA256(hashData, 0, hashData.length); + var cipher = new AES256Cipher(key); + return cipher.decryptBlock(ownerEncryption, + false, + new Uint8Array(16)); + + }, + getUserKey: function PDF17_getUserKey(password, userKeySalt, + userEncryption) { + var hashData = new Uint8Array(password.length + 8); + hashData.set(password, 0); + hashData.set(userKeySalt, password.length); + //key is the decryption key for the UE string + var key = calculateSHA256(hashData, 0, hashData.length); + var cipher = new AES256Cipher(key); + return cipher.decryptBlock(userEncryption, + false, + new Uint8Array(16)); + } + }; + return PDF17; +})(); + +var PDF20 = (function PDF20Closure() { + + function concatArrays(array1, array2) { + var t = new Uint8Array(array1.length + array2.length); + t.set(array1, 0); + t.set(array2, array1.length); + return t; + } + + function calculatePDF20Hash(password, input, userBytes) { + //This refers to Algorithm 2.B as defined in ISO 32000-2 + var k = calculateSHA256(input, 0, input.length).subarray(0, 32); + var e = [0]; + var i = 0; + while (i < 64 || e[e.length - 1] > i - 32) { + var arrayLength = password.length + k.length + userBytes.length; + + var k1 = new Uint8Array(arrayLength * 64); + var array = concatArrays(password, k); + array = concatArrays(array, userBytes); + for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) { + k1.set(array, pos); + } + //AES128 CBC NO PADDING with + //first 16 bytes of k as the key and the second 16 as the iv. + var cipher = new AES128Cipher(k.subarray(0, 16)); + e = cipher.encrypt(k1, k.subarray(16, 32)); + //Now we have to take the first 16 bytes of an unsigned + //big endian integer... and compute the remainder + //modulo 3.... That is a fairly large number and + //JavaScript isn't going to handle that well... + //So we're using a trick that allows us to perform + //modulo math byte by byte + var remainder = 0; + for (var z = 0; z < 16; z++) { + remainder *= (256 % 3); + remainder %= 3; + remainder += ((e[z] >>> 0) % 3); + remainder %= 3; + } + if (remainder === 0) { + k = calculateSHA256(e, 0, e.length); + } + else if (remainder === 1) { + k = calculateSHA384(e, 0, e.length); + } + else if (remainder === 2) { + k = calculateSHA512(e, 0, e.length); + } + i++; + } + return k.subarray(0, 32); + } + + function PDF20() { + } + + function compareByteArrays(array1, array2) { + if (array1.length !== array2.length) { + return false; + } + for (var i = 0; i < array1.length; i++) { + if (array1[i] !== array2[i]) { + return false; + } + } + return true; + } + + PDF20.prototype = { + hash: function PDF20_hash(password, concatBytes, userBytes) { + return calculatePDF20Hash(password, concatBytes, userBytes); + }, + checkOwnerPassword: function PDF20_checkOwnerPassword(password, + ownerValidationSalt, + userBytes, + ownerPassword) { + var hashData = new Uint8Array(password.length + 56); + hashData.set(password, 0); + hashData.set(ownerValidationSalt, password.length); + hashData.set(userBytes, password.length + ownerValidationSalt.length); + var result = calculatePDF20Hash(password, hashData, userBytes); + return compareByteArrays(result, ownerPassword); + }, + checkUserPassword: function PDF20_checkUserPassword(password, + userValidationSalt, + userPassword) { + var hashData = new Uint8Array(password.length + 8); + hashData.set(password, 0); + hashData.set(userValidationSalt, password.length); + var result = calculatePDF20Hash(password, hashData, []); + return compareByteArrays(result, userPassword); + }, + getOwnerKey: function PDF20_getOwnerKey(password, ownerKeySalt, userBytes, + ownerEncryption) { + var hashData = new Uint8Array(password.length + 56); + hashData.set(password, 0); + hashData.set(ownerKeySalt, password.length); + hashData.set(userBytes, password.length + ownerKeySalt.length); + var key = calculatePDF20Hash(password, hashData, userBytes); + var cipher = new AES256Cipher(key); + return cipher.decryptBlock(ownerEncryption, + false, + new Uint8Array(16)); + + }, + getUserKey: function PDF20_getUserKey(password, userKeySalt, + userEncryption) { + var hashData = new Uint8Array(password.length + 8); + hashData.set(password, 0); + hashData.set(userKeySalt, password.length); + //key is the decryption key for the UE string + var key = calculatePDF20Hash(password, hashData, []); + var cipher = new AES256Cipher(key); + return cipher.decryptBlock(userEncryption, + false, + new Uint8Array(16)); + } + }; + return PDF20; +})(); + +var CipherTransform = (function CipherTransformClosure() { + function CipherTransform(stringCipherConstructor, streamCipherConstructor) { + this.stringCipherConstructor = stringCipherConstructor; + this.streamCipherConstructor = streamCipherConstructor; + } + + CipherTransform.prototype = { + createStream: function CipherTransform_createStream(stream, length) { + var cipher = new this.streamCipherConstructor(); + return new DecryptStream(stream, length, + function cipherTransformDecryptStream(data, finalize) { + return cipher.decryptBlock(data, finalize); + } + ); + }, + decryptString: function CipherTransform_decryptString(s) { + var cipher = new this.stringCipherConstructor(); + var data = stringToBytes(s); + data = cipher.decryptBlock(data, true); + return bytesToString(data); + } + }; + return CipherTransform; +})(); + +var CipherTransformFactory = (function CipherTransformFactoryClosure() { + var defaultPasswordBytes = new Uint8Array([ + 0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, + 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08, + 0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, + 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A]); + + function createEncryptionKey20(revision, password, ownerPassword, + ownerValidationSalt, ownerKeySalt, uBytes, + userPassword, userValidationSalt, userKeySalt, + ownerEncryption, userEncryption, perms) { + if (password) { + var passwordLength = Math.min(127, password.length); + password = password.subarray(0, passwordLength); + } else { + password = []; + } + var pdfAlgorithm; + if (revision === 6) { + pdfAlgorithm = new PDF20(); + } else { + pdfAlgorithm = new PDF17(); + } + + if (pdfAlgorithm) { + if (pdfAlgorithm.checkUserPassword(password, userValidationSalt, + userPassword)) { + return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption); + } else if (password.length && pdfAlgorithm.checkOwnerPassword(password, + ownerValidationSalt, + uBytes, + ownerPassword)) { + return pdfAlgorithm.getOwnerKey(password, ownerKeySalt, uBytes, + ownerEncryption); + } + } + + return null; + } + + function prepareKeyData(fileId, password, ownerPassword, userPassword, + flags, revision, keyLength, encryptMetadata) { + var hashDataSize = 40 + ownerPassword.length + fileId.length; + var hashData = new Uint8Array(hashDataSize), i = 0, j, n; + if (password) { + n = Math.min(32, password.length); + for (; i < n; ++i) { + hashData[i] = password[i]; + } + } + j = 0; + while (i < 32) { + hashData[i++] = defaultPasswordBytes[j++]; + } + // as now the padded password in the hashData[0..i] + for (j = 0, n = ownerPassword.length; j < n; ++j) { + hashData[i++] = ownerPassword[j]; + } + hashData[i++] = flags & 0xFF; + hashData[i++] = (flags >> 8) & 0xFF; + hashData[i++] = (flags >> 16) & 0xFF; + hashData[i++] = (flags >>> 24) & 0xFF; + for (j = 0, n = fileId.length; j < n; ++j) { + hashData[i++] = fileId[j]; + } + if (revision >= 4 && !encryptMetadata) { + hashData[i++] = 0xFF; + hashData[i++] = 0xFF; + hashData[i++] = 0xFF; + hashData[i++] = 0xFF; + } + var hash = calculateMD5(hashData, 0, i); + var keyLengthInBytes = keyLength >> 3; + if (revision >= 3) { + for (j = 0; j < 50; ++j) { + hash = calculateMD5(hash, 0, keyLengthInBytes); + } + } + var encryptionKey = hash.subarray(0, keyLengthInBytes); + var cipher, checkData; + + if (revision >= 3) { + for (i = 0; i < 32; ++i) { + hashData[i] = defaultPasswordBytes[i]; + } + for (j = 0, n = fileId.length; j < n; ++j) { + hashData[i++] = fileId[j]; + } + cipher = new ARCFourCipher(encryptionKey); + checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i)); + n = encryptionKey.length; + var derivedKey = new Uint8Array(n), k; + for (j = 1; j <= 19; ++j) { + for (k = 0; k < n; ++k) { + derivedKey[k] = encryptionKey[k] ^ j; + } + cipher = new ARCFourCipher(derivedKey); + checkData = cipher.encryptBlock(checkData); + } + for (j = 0, n = checkData.length; j < n; ++j) { + if (userPassword[j] !== checkData[j]) { + return null; + } + } + } else { + cipher = new ARCFourCipher(encryptionKey); + checkData = cipher.encryptBlock(defaultPasswordBytes); + for (j = 0, n = checkData.length; j < n; ++j) { + if (userPassword[j] !== checkData[j]) { + return null; + } + } + } + return encryptionKey; + } + + function decodeUserPassword(password, ownerPassword, revision, keyLength) { + var hashData = new Uint8Array(32), i = 0, j, n; + n = Math.min(32, password.length); + for (; i < n; ++i) { + hashData[i] = password[i]; + } + j = 0; + while (i < 32) { + hashData[i++] = defaultPasswordBytes[j++]; + } + var hash = calculateMD5(hashData, 0, i); + var keyLengthInBytes = keyLength >> 3; + if (revision >= 3) { + for (j = 0; j < 50; ++j) { + hash = calculateMD5(hash, 0, hash.length); + } + } + + var cipher, userPassword; + if (revision >= 3) { + userPassword = ownerPassword; + var derivedKey = new Uint8Array(keyLengthInBytes), k; + for (j = 19; j >= 0; j--) { + for (k = 0; k < keyLengthInBytes; ++k) { + derivedKey[k] = hash[k] ^ j; + } + cipher = new ARCFourCipher(derivedKey); + userPassword = cipher.encryptBlock(userPassword); + } + } else { + cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes)); + userPassword = cipher.encryptBlock(ownerPassword); + } + return userPassword; + } + + var identityName = Name.get('Identity'); + + function CipherTransformFactory(dict, fileId, password) { + var filter = dict.get('Filter'); + if (!isName(filter) || filter.name !== 'Standard') { + error('unknown encryption method'); + } + this.dict = dict; + var algorithm = dict.get('V'); + if (!isInt(algorithm) || + (algorithm !== 1 && algorithm !== 2 && algorithm !== 4 && + algorithm !== 5)) { + error('unsupported encryption algorithm'); + } + this.algorithm = algorithm; + var keyLength = dict.get('Length'); + if (!keyLength) { + // Spec asks to rely on encryption dictionary's Length entry, however + // some PDFs don't have it. Trying to recover. + if (algorithm <= 3) { + // For 1 and 2 it's fixed to 40-bit, for 3 40-bit is a minimal value. + keyLength = 40; + } else { + // Trying to find default handler -- it usually has Length. + var cfDict = dict.get('CF'); + var streamCryptoName = dict.get('StmF'); + if (isDict(cfDict) && isName(streamCryptoName)) { + var handlerDict = cfDict.get(streamCryptoName.name); + keyLength = (handlerDict && handlerDict.get('Length')) || 128; + if (keyLength < 40) { + // Sometimes it's incorrect value of bits, generators specify bytes. + keyLength <<= 3; + } + } + } + } + if (!isInt(keyLength) || + keyLength < 40 || (keyLength % 8) !== 0) { + error('invalid key length'); + } + + // prepare keys + var ownerPassword = stringToBytes(dict.get('O')).subarray(0, 32); + var userPassword = stringToBytes(dict.get('U')).subarray(0, 32); + var flags = dict.get('P'); + var revision = dict.get('R'); + // meaningful when V is 4 or 5 + var encryptMetadata = ((algorithm === 4 || algorithm === 5) && + dict.get('EncryptMetadata') !== false); + this.encryptMetadata = encryptMetadata; + + var fileIdBytes = stringToBytes(fileId); + var passwordBytes; + if (password) { + if (revision === 6) { + try { + password = utf8StringToString(password); + } catch (ex) { + warn('CipherTransformFactory: ' + + 'Unable to convert UTF8 encoded password.'); + } + } + passwordBytes = stringToBytes(password); + } + + var encryptionKey; + if (algorithm !== 5) { + encryptionKey = prepareKeyData(fileIdBytes, passwordBytes, + ownerPassword, userPassword, flags, + revision, keyLength, encryptMetadata); + } + else { + var ownerValidationSalt = stringToBytes(dict.get('O')).subarray(32, 40); + var ownerKeySalt = stringToBytes(dict.get('O')).subarray(40, 48); + var uBytes = stringToBytes(dict.get('U')).subarray(0, 48); + var userValidationSalt = stringToBytes(dict.get('U')).subarray(32, 40); + var userKeySalt = stringToBytes(dict.get('U')).subarray(40, 48); + var ownerEncryption = stringToBytes(dict.get('OE')); + var userEncryption = stringToBytes(dict.get('UE')); + var perms = stringToBytes(dict.get('Perms')); + encryptionKey = + createEncryptionKey20(revision, passwordBytes, + ownerPassword, ownerValidationSalt, + ownerKeySalt, uBytes, + userPassword, userValidationSalt, + userKeySalt, ownerEncryption, + userEncryption, perms); + } + if (!encryptionKey && !password) { + throw new PasswordException('No password given', + PasswordResponses.NEED_PASSWORD); + } else if (!encryptionKey && password) { + // Attempting use the password as an owner password + var decodedPassword = decodeUserPassword(passwordBytes, ownerPassword, + revision, keyLength); + encryptionKey = prepareKeyData(fileIdBytes, decodedPassword, + ownerPassword, userPassword, flags, + revision, keyLength, encryptMetadata); + } + + if (!encryptionKey) { + throw new PasswordException('Incorrect Password', + PasswordResponses.INCORRECT_PASSWORD); + } + + this.encryptionKey = encryptionKey; + + if (algorithm >= 4) { + this.cf = dict.get('CF'); + this.stmf = dict.get('StmF') || identityName; + this.strf = dict.get('StrF') || identityName; + this.eff = dict.get('EFF') || this.stmf; + } + } + + function buildObjectKey(num, gen, encryptionKey, isAes) { + var key = new Uint8Array(encryptionKey.length + 9), i, n; + for (i = 0, n = encryptionKey.length; i < n; ++i) { + key[i] = encryptionKey[i]; + } + key[i++] = num & 0xFF; + key[i++] = (num >> 8) & 0xFF; + key[i++] = (num >> 16) & 0xFF; + key[i++] = gen & 0xFF; + key[i++] = (gen >> 8) & 0xFF; + if (isAes) { + key[i++] = 0x73; + key[i++] = 0x41; + key[i++] = 0x6C; + key[i++] = 0x54; + } + var hash = calculateMD5(key, 0, i); + return hash.subarray(0, Math.min(encryptionKey.length + 5, 16)); + } + + function buildCipherConstructor(cf, name, num, gen, key) { + var cryptFilter = cf.get(name.name); + var cfm; + if (cryptFilter !== null && cryptFilter !== undefined) { + cfm = cryptFilter.get('CFM'); + } + if (!cfm || cfm.name === 'None') { + return function cipherTransformFactoryBuildCipherConstructorNone() { + return new NullCipher(); + }; + } + if ('V2' === cfm.name) { + return function cipherTransformFactoryBuildCipherConstructorV2() { + return new ARCFourCipher(buildObjectKey(num, gen, key, false)); + }; + } + if ('AESV2' === cfm.name) { + return function cipherTransformFactoryBuildCipherConstructorAESV2() { + return new AES128Cipher(buildObjectKey(num, gen, key, true)); + }; + } + if ('AESV3' === cfm.name) { + return function cipherTransformFactoryBuildCipherConstructorAESV3() { + return new AES256Cipher(key); + }; + } + error('Unknown crypto method'); + } + + CipherTransformFactory.prototype = { + createCipherTransform: + function CipherTransformFactory_createCipherTransform(num, gen) { + if (this.algorithm === 4 || this.algorithm === 5) { + return new CipherTransform( + buildCipherConstructor(this.cf, this.stmf, + num, gen, this.encryptionKey), + buildCipherConstructor(this.cf, this.strf, + num, gen, this.encryptionKey)); + } + // algorithms 1 and 2 + var key = buildObjectKey(num, gen, this.encryptionKey, false); + var cipherConstructor = function buildCipherCipherConstructor() { + return new ARCFourCipher(key); + }; + return new CipherTransform(cipherConstructor, cipherConstructor); + } + }; + + return CipherTransformFactory; +})(); + +exports.AES128Cipher = AES128Cipher; +exports.AES256Cipher = AES256Cipher; +exports.ARCFourCipher = ARCFourCipher; +exports.CipherTransformFactory = CipherTransformFactory; +exports.PDF17 = PDF17; +exports.PDF20 = PDF20; +exports.calculateMD5 = calculateMD5; +exports.calculateSHA256 = calculateSHA256; +exports.calculateSHA384 = calculateSHA384; +exports.calculateSHA512 = calculateSHA512; +})); + +(function (root, factory) { + { + factory((root.pdfjsCoreFontRenderer = {}), root.pdfjsSharedUtil, + root.pdfjsCoreStream, root.pdfjsCoreGlyphList); + } +}(this, function (exports, sharedUtil, coreStream, coreGlyphList) { + +var Util = sharedUtil.Util; +var bytesToString = sharedUtil.bytesToString; +var error = sharedUtil.error; +var Stream = coreStream.Stream; +var GlyphsUnicode = coreGlyphList.GlyphsUnicode; + +var coreFonts; // see _setCoreFonts below +var CFFParser; // = coreFonts.CFFParser; +var Encodings; // = coreFonts.Encodings; + +var FontRendererFactory = (function FontRendererFactoryClosure() { + function getLong(data, offset) { + return (data[offset] << 24) | (data[offset + 1] << 16) | + (data[offset + 2] << 8) | data[offset + 3]; + } + + function getUshort(data, offset) { + return (data[offset] << 8) | data[offset + 1]; + } + + function parseCmap(data, start, end) { + var offset = (getUshort(data, start + 2) === 1 ? + getLong(data, start + 8) : getLong(data, start + 16)); + var format = getUshort(data, start + offset); + var length, ranges, p, i; + if (format === 4) { + length = getUshort(data, start + offset + 2); + var segCount = getUshort(data, start + offset + 6) >> 1; + p = start + offset + 14; + ranges = []; + for (i = 0; i < segCount; i++, p += 2) { + ranges[i] = {end: getUshort(data, p)}; + } + p += 2; + for (i = 0; i < segCount; i++, p += 2) { + ranges[i].start = getUshort(data, p); + } + for (i = 0; i < segCount; i++, p += 2) { + ranges[i].idDelta = getUshort(data, p); + } + for (i = 0; i < segCount; i++, p += 2) { + var idOffset = getUshort(data, p); + if (idOffset === 0) { + continue; + } + ranges[i].ids = []; + for (var j = 0, jj = ranges[i].end - ranges[i].start + 1; j < jj; j++) { + ranges[i].ids[j] = getUshort(data, p + idOffset); + idOffset += 2; + } + } + return ranges; + } else if (format === 12) { + length = getLong(data, start + offset + 4); + var groups = getLong(data, start + offset + 12); + p = start + offset + 16; + ranges = []; + for (i = 0; i < groups; i++) { + ranges.push({ + start: getLong(data, p), + end: getLong(data, p + 4), + idDelta: getLong(data, p + 8) - getLong(data, p) + }); + p += 12; + } + return ranges; + } + error('not supported cmap: ' + format); + } + + function parseCff(data, start, end) { + var properties = {}; + var parser = new CFFParser(new Stream(data, start, end - start), + properties); + var cff = parser.parse(); + return { + glyphs: cff.charStrings.objects, + subrs: (cff.topDict.privateDict && cff.topDict.privateDict.subrsIndex && + cff.topDict.privateDict.subrsIndex.objects), + gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects + }; + } + + function parseGlyfTable(glyf, loca, isGlyphLocationsLong) { + var itemSize, itemDecode; + if (isGlyphLocationsLong) { + itemSize = 4; + itemDecode = function fontItemDecodeLong(data, offset) { + return (data[offset] << 24) | (data[offset + 1] << 16) | + (data[offset + 2] << 8) | data[offset + 3]; + }; + } else { + itemSize = 2; + itemDecode = function fontItemDecode(data, offset) { + return (data[offset] << 9) | (data[offset + 1] << 1); + }; + } + var glyphs = []; + var startOffset = itemDecode(loca, 0); + for (var j = itemSize; j < loca.length; j += itemSize) { + var endOffset = itemDecode(loca, j); + glyphs.push(glyf.subarray(startOffset, endOffset)); + startOffset = endOffset; + } + return glyphs; + } + + function lookupCmap(ranges, unicode) { + var code = unicode.charCodeAt(0); + var l = 0, r = ranges.length - 1; + while (l < r) { + var c = (l + r + 1) >> 1; + if (code < ranges[c].start) { + r = c - 1; + } else { + l = c; + } + } + if (ranges[l].start <= code && code <= ranges[l].end) { + return (ranges[l].idDelta + (ranges[l].ids ? + ranges[l].ids[code - ranges[l].start] : code)) & 0xFFFF; + } + return 0; + } + + function compileGlyf(code, cmds, font) { + function moveTo(x, y) { + cmds.push({cmd: 'moveTo', args: [x, y]}); + } + function lineTo(x, y) { + cmds.push({cmd: 'lineTo', args: [x, y]}); + } + function quadraticCurveTo(xa, ya, x, y) { + cmds.push({cmd: 'quadraticCurveTo', args: [xa, ya, x, y]}); + } + + var i = 0; + var numberOfContours = ((code[i] << 24) | (code[i + 1] << 16)) >> 16; + var flags; + var x = 0, y = 0; + i += 10; + if (numberOfContours < 0) { + // composite glyph + do { + flags = (code[i] << 8) | code[i + 1]; + var glyphIndex = (code[i + 2] << 8) | code[i + 3]; + i += 4; + var arg1, arg2; + if ((flags & 0x01)) { + arg1 = ((code[i] << 24) | (code[i + 1] << 16)) >> 16; + arg2 = ((code[i + 2] << 24) | (code[i + 3] << 16)) >> 16; + i += 4; + } else { + arg1 = code[i++]; arg2 = code[i++]; + } + if ((flags & 0x02)) { + x = arg1; + y = arg2; + } else { + x = 0; y = 0; // TODO "they are points" ? + } + var scaleX = 1, scaleY = 1, scale01 = 0, scale10 = 0; + if ((flags & 0x08)) { + scaleX = + scaleY = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824; + i += 2; + } else if ((flags & 0x40)) { + scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824; + scaleY = ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824; + i += 4; + } else if ((flags & 0x80)) { + scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824; + scale01 = ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824; + scale10 = ((code[i + 4] << 24) | (code[i + 5] << 16)) / 1073741824; + scaleY = ((code[i + 6] << 24) | (code[i + 7] << 16)) / 1073741824; + i += 8; + } + var subglyph = font.glyphs[glyphIndex]; + if (subglyph) { + cmds.push({cmd: 'save'}); + cmds.push({cmd: 'transform', + args: [scaleX, scale01, scale10, scaleY, x, y]}); + compileGlyf(subglyph, cmds, font); + cmds.push({cmd: 'restore'}); + } + } while ((flags & 0x20)); + } else { + // simple glyph + var endPtsOfContours = []; + var j, jj; + for (j = 0; j < numberOfContours; j++) { + endPtsOfContours.push((code[i] << 8) | code[i + 1]); + i += 2; + } + var instructionLength = (code[i] << 8) | code[i + 1]; + i += 2 + instructionLength; // skipping the instructions + var numberOfPoints = endPtsOfContours[endPtsOfContours.length - 1] + 1; + var points = []; + while (points.length < numberOfPoints) { + flags = code[i++]; + var repeat = 1; + if ((flags & 0x08)) { + repeat += code[i++]; + } + while (repeat-- > 0) { + points.push({flags: flags}); + } + } + for (j = 0; j < numberOfPoints; j++) { + switch (points[j].flags & 0x12) { + case 0x00: + x += ((code[i] << 24) | (code[i + 1] << 16)) >> 16; + i += 2; + break; + case 0x02: + x -= code[i++]; + break; + case 0x12: + x += code[i++]; + break; + } + points[j].x = x; + } + for (j = 0; j < numberOfPoints; j++) { + switch (points[j].flags & 0x24) { + case 0x00: + y += ((code[i] << 24) | (code[i + 1] << 16)) >> 16; + i += 2; + break; + case 0x04: + y -= code[i++]; + break; + case 0x24: + y += code[i++]; + break; + } + points[j].y = y; + } + + var startPoint = 0; + for (i = 0; i < numberOfContours; i++) { + var endPoint = endPtsOfContours[i]; + // contours might have implicit points, which is located in the middle + // between two neighboring off-curve points + var contour = points.slice(startPoint, endPoint + 1); + if ((contour[0].flags & 1)) { + contour.push(contour[0]); // using start point at the contour end + } else if ((contour[contour.length - 1].flags & 1)) { + // first is off-curve point, trying to use one from the end + contour.unshift(contour[contour.length - 1]); + } else { + // start and end are off-curve points, creating implicit one + var p = { + flags: 1, + x: (contour[0].x + contour[contour.length - 1].x) / 2, + y: (contour[0].y + contour[contour.length - 1].y) / 2 + }; + contour.unshift(p); + contour.push(p); + } + moveTo(contour[0].x, contour[0].y); + for (j = 1, jj = contour.length; j < jj; j++) { + if ((contour[j].flags & 1)) { + lineTo(contour[j].x, contour[j].y); + } else if ((contour[j + 1].flags & 1)){ + quadraticCurveTo(contour[j].x, contour[j].y, + contour[j + 1].x, contour[j + 1].y); + j++; + } else { + quadraticCurveTo(contour[j].x, contour[j].y, + (contour[j].x + contour[j + 1].x) / 2, + (contour[j].y + contour[j + 1].y) / 2); + } + } + startPoint = endPoint + 1; + } + } + } + + function compileCharString(code, cmds, font) { + var stack = []; + var x = 0, y = 0; + var stems = 0; + + function moveTo(x, y) { + cmds.push({cmd: 'moveTo', args: [x, y]}); + } + function lineTo(x, y) { + cmds.push({cmd: 'lineTo', args: [x, y]}); + } + function bezierCurveTo(x1, y1, x2, y2, x, y) { + cmds.push({cmd: 'bezierCurveTo', args: [x1, y1, x2, y2, x, y]}); + } + + function parse(code) { + var i = 0; + while (i < code.length) { + var stackClean = false; + var v = code[i++]; + var xa, xb, ya, yb, y1, y2, y3, n, subrCode; + switch (v) { + case 1: // hstem + stems += stack.length >> 1; + stackClean = true; + break; + case 3: // vstem + stems += stack.length >> 1; + stackClean = true; + break; + case 4: // vmoveto + y += stack.pop(); + moveTo(x, y); + stackClean = true; + break; + case 5: // rlineto + while (stack.length > 0) { + x += stack.shift(); + y += stack.shift(); + lineTo(x, y); + } + break; + case 6: // hlineto + while (stack.length > 0) { + x += stack.shift(); + lineTo(x, y); + if (stack.length === 0) { + break; + } + y += stack.shift(); + lineTo(x, y); + } + break; + case 7: // vlineto + while (stack.length > 0) { + y += stack.shift(); + lineTo(x, y); + if (stack.length === 0) { + break; + } + x += stack.shift(); + lineTo(x, y); + } + break; + case 8: // rrcurveto + while (stack.length > 0) { + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + } + break; + case 10: // callsubr + n = stack.pop() + font.subrsBias; + subrCode = font.subrs[n]; + if (subrCode) { + parse(subrCode); + } + break; + case 11: // return + return; + case 12: + v = code[i++]; + switch (v) { + case 34: // flex + xa = x + stack.shift(); + xb = xa + stack.shift(); y1 = y + stack.shift(); + x = xb + stack.shift(); + bezierCurveTo(xa, y, xb, y1, x, y1); + xa = x + stack.shift(); + xb = xa + stack.shift(); + x = xb + stack.shift(); + bezierCurveTo(xa, y1, xb, y, x, y); + break; + case 35: // flex + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + stack.pop(); // fd + break; + case 36: // hflex1 + xa = x + stack.shift(); y1 = y + stack.shift(); + xb = xa + stack.shift(); y2 = y1 + stack.shift(); + x = xb + stack.shift(); + bezierCurveTo(xa, y1, xb, y2, x, y2); + xa = x + stack.shift(); + xb = xa + stack.shift(); y3 = y2 + stack.shift(); + x = xb + stack.shift(); + bezierCurveTo(xa, y2, xb, y3, x, y); + break; + case 37: // flex1 + var x0 = x, y0 = y; + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb; y = yb; + if (Math.abs(x - x0) > Math.abs(y - y0)) { + x += stack.shift(); + } else { + y += stack.shift(); + } + bezierCurveTo(xa, ya, xb, yb, x, y); + break; + default: + error('unknown operator: 12 ' + v); + } + break; + case 14: // endchar + if (stack.length >= 4) { + var achar = stack.pop(); + var bchar = stack.pop(); + y = stack.pop(); + x = stack.pop(); + cmds.push({cmd: 'save'}); + cmds.push({cmd: 'translate', args: [x, y]}); + var gid = lookupCmap(font.cmap, String.fromCharCode( + font.glyphNameMap[Encodings.StandardEncoding[achar]])); + compileCharString(font.glyphs[gid], cmds, font); + cmds.push({cmd: 'restore'}); + + gid = lookupCmap(font.cmap, String.fromCharCode( + font.glyphNameMap[Encodings.StandardEncoding[bchar]])); + compileCharString(font.glyphs[gid], cmds, font); + } + return; + case 18: // hstemhm + stems += stack.length >> 1; + stackClean = true; + break; + case 19: // hintmask + stems += stack.length >> 1; + i += (stems + 7) >> 3; + stackClean = true; + break; + case 20: // cntrmask + stems += stack.length >> 1; + i += (stems + 7) >> 3; + stackClean = true; + break; + case 21: // rmoveto + y += stack.pop(); + x += stack.pop(); + moveTo(x, y); + stackClean = true; + break; + case 22: // hmoveto + x += stack.pop(); + moveTo(x, y); + stackClean = true; + break; + case 23: // vstemhm + stems += stack.length >> 1; + stackClean = true; + break; + case 24: // rcurveline + while (stack.length > 2) { + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + } + x += stack.shift(); + y += stack.shift(); + lineTo(x, y); + break; + case 25: // rlinecurve + while (stack.length > 6) { + x += stack.shift(); + y += stack.shift(); + lineTo(x, y); + } + xa = x + stack.shift(); ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + break; + case 26: // vvcurveto + if (stack.length % 2) { + x += stack.shift(); + } + while (stack.length > 0) { + xa = x; ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb; y = yb + stack.shift(); + bezierCurveTo(xa, ya, xb, yb, x, y); + } + break; + case 27: // hhcurveto + if (stack.length % 2) { + y += stack.shift(); + } + while (stack.length > 0) { + xa = x + stack.shift(); ya = y; + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); y = yb; + bezierCurveTo(xa, ya, xb, yb, x, y); + } + break; + case 28: + stack.push(((code[i] << 24) | (code[i + 1] << 16)) >> 16); + i += 2; + break; + case 29: // callgsubr + n = stack.pop() + font.gsubrsBias; + subrCode = font.gsubrs[n]; + if (subrCode) { + parse(subrCode); + } + break; + case 30: // vhcurveto + while (stack.length > 0) { + xa = x; ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); + y = yb + (stack.length === 1 ? stack.shift() : 0); + bezierCurveTo(xa, ya, xb, yb, x, y); + if (stack.length === 0) { + break; + } + + xa = x + stack.shift(); ya = y; + xb = xa + stack.shift(); yb = ya + stack.shift(); + y = yb + stack.shift(); + x = xb + (stack.length === 1 ? stack.shift() : 0); + bezierCurveTo(xa, ya, xb, yb, x, y); + } + break; + case 31: // hvcurveto + while (stack.length > 0) { + xa = x + stack.shift(); ya = y; + xb = xa + stack.shift(); yb = ya + stack.shift(); + y = yb + stack.shift(); + x = xb + (stack.length === 1 ? stack.shift() : 0); + bezierCurveTo(xa, ya, xb, yb, x, y); + if (stack.length === 0) { + break; + } + + xa = x; ya = y + stack.shift(); + xb = xa + stack.shift(); yb = ya + stack.shift(); + x = xb + stack.shift(); + y = yb + (stack.length === 1 ? stack.shift() : 0); + bezierCurveTo(xa, ya, xb, yb, x, y); + } + break; + default: + if (v < 32) { + error('unknown operator: ' + v); + } + if (v < 247) { + stack.push(v - 139); + } else if (v < 251) { + stack.push((v - 247) * 256 + code[i++] + 108); + } else if (v < 255) { + stack.push(-(v - 251) * 256 - code[i++] - 108); + } else { + stack.push(((code[i] << 24) | (code[i + 1] << 16) | + (code[i + 2] << 8) | code[i + 3]) / 65536); + i += 4; + } + break; + } + if (stackClean) { + stack.length = 0; + } + } + } + parse(code); + } + + var noop = ''; + + function CompiledFont(fontMatrix) { + this.compiledGlyphs = {}; + this.fontMatrix = fontMatrix; + } + CompiledFont.prototype = { + getPathJs: function (unicode) { + var gid = lookupCmap(this.cmap, unicode); + var fn = this.compiledGlyphs[gid]; + if (!fn) { + this.compiledGlyphs[gid] = fn = this.compileGlyph(this.glyphs[gid]); + } + return fn; + }, + + compileGlyph: function (code) { + if (!code || code.length === 0 || code[0] === 14) { + return noop; + } + + var cmds = []; + cmds.push({cmd: 'save'}); + cmds.push({cmd: 'transform', args: this.fontMatrix.slice()}); + cmds.push({cmd: 'scale', args: ['size', '-size']}); + + this.compileGlyphImpl(code, cmds); + + cmds.push({cmd: 'restore'}); + + return cmds; + }, + + compileGlyphImpl: function () { + error('Children classes should implement this.'); + }, + + hasBuiltPath: function (unicode) { + var gid = lookupCmap(this.cmap, unicode); + return gid in this.compiledGlyphs; + } + }; + + function TrueTypeCompiled(glyphs, cmap, fontMatrix) { + fontMatrix = fontMatrix || [0.000488, 0, 0, 0.000488, 0, 0]; + CompiledFont.call(this, fontMatrix); + + this.glyphs = glyphs; + this.cmap = cmap; + + this.compiledGlyphs = []; + } + + Util.inherit(TrueTypeCompiled, CompiledFont, { + compileGlyphImpl: function (code, cmds) { + compileGlyf(code, cmds, this); + } + }); + + function Type2Compiled(cffInfo, cmap, fontMatrix, glyphNameMap) { + fontMatrix = fontMatrix || [0.001, 0, 0, 0.001, 0, 0]; + CompiledFont.call(this, fontMatrix); + this.glyphs = cffInfo.glyphs; + this.gsubrs = cffInfo.gsubrs || []; + this.subrs = cffInfo.subrs || []; + this.cmap = cmap; + this.glyphNameMap = glyphNameMap || GlyphsUnicode; + + this.compiledGlyphs = []; + this.gsubrsBias = (this.gsubrs.length < 1240 ? + 107 : (this.gsubrs.length < 33900 ? 1131 : 32768)); + this.subrsBias = (this.subrs.length < 1240 ? + 107 : (this.subrs.length < 33900 ? 1131 : 32768)); + } + + Util.inherit(Type2Compiled, CompiledFont, { + compileGlyphImpl: function (code, cmds) { + compileCharString(code, cmds, this); + } + }); + + + return { + create: function FontRendererFactory_create(font) { + var data = new Uint8Array(font.data); + var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm; + var numTables = getUshort(data, 4); + for (var i = 0, p = 12; i < numTables; i++, p += 16) { + var tag = bytesToString(data.subarray(p, p + 4)); + var offset = getLong(data, p + 8); + var length = getLong(data, p + 12); + switch (tag) { + case 'cmap': + cmap = parseCmap(data, offset, offset + length); + break; + case 'glyf': + glyf = data.subarray(offset, offset + length); + break; + case 'loca': + loca = data.subarray(offset, offset + length); + break; + case 'head': + unitsPerEm = getUshort(data, offset + 18); + indexToLocFormat = getUshort(data, offset + 50); + break; + case 'CFF ': + cff = parseCff(data, offset, offset + length); + break; + } + } + + if (glyf) { + var fontMatrix = (!unitsPerEm ? font.fontMatrix : + [1 / unitsPerEm, 0, 0, 1 / unitsPerEm, 0, 0]); + return new TrueTypeCompiled( + parseGlyfTable(glyf, loca, indexToLocFormat), cmap, fontMatrix); + } else { + return new Type2Compiled(cff, cmap, font.fontMatrix, font.glyphNameMap); + } + } + }; +})(); + + +// TODO refactor to remove cyclic dependency on fonts.js +function _setCoreFonts(coreFonts_) { + coreFonts = coreFonts_; + Encodings = coreFonts_.Encodings; + CFFParser = coreFonts_.CFFParser; +} +exports._setCoreFonts = _setCoreFonts; + +exports.FontRendererFactory = FontRendererFactory; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreParser = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream) { + +var MissingDataException = sharedUtil.MissingDataException; +var StreamType = sharedUtil.StreamType; +var assert = sharedUtil.assert; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isInt = sharedUtil.isInt; +var isNum = sharedUtil.isNum; +var isString = sharedUtil.isString; +var warn = sharedUtil.warn; +var Cmd = corePrimitives.Cmd; +var Dict = corePrimitives.Dict; +var Name = corePrimitives.Name; +var Ref = corePrimitives.Ref; +var isCmd = corePrimitives.isCmd; +var isDict = corePrimitives.isDict; +var isName = corePrimitives.isName; +var Ascii85Stream = coreStream.Ascii85Stream; +var AsciiHexStream = coreStream.AsciiHexStream; +var CCITTFaxStream = coreStream.CCITTFaxStream; +var FlateStream = coreStream.FlateStream; +var Jbig2Stream = coreStream.Jbig2Stream; +var JpegStream = coreStream.JpegStream; +var JpxStream = coreStream.JpxStream; +var LZWStream = coreStream.LZWStream; +var NullStream = coreStream.NullStream; +var PredictorStream = coreStream.PredictorStream; +var RunLengthStream = coreStream.RunLengthStream; + +var EOF = {}; + +function isEOF(v) { + return (v === EOF); +} + +var MAX_LENGTH_TO_CACHE = 1000; + +var Parser = (function ParserClosure() { + function Parser(lexer, allowStreams, xref) { + this.lexer = lexer; + this.allowStreams = allowStreams; + this.xref = xref; + this.imageCache = {}; + this.refill(); + } + + Parser.prototype = { + refill: function Parser_refill() { + this.buf1 = this.lexer.getObj(); + this.buf2 = this.lexer.getObj(); + }, + shift: function Parser_shift() { + if (isCmd(this.buf2, 'ID')) { + this.buf1 = this.buf2; + this.buf2 = null; + } else { + this.buf1 = this.buf2; + this.buf2 = this.lexer.getObj(); + } + }, + tryShift: function Parser_tryShift() { + try { + this.shift(); + return true; + } catch (e) { + if (e instanceof MissingDataException) { + throw e; + } + // Upon failure, the caller should reset this.lexer.pos to a known good + // state and call this.shift() twice to reset the buffers. + return false; + } + }, + getObj: function Parser_getObj(cipherTransform) { + var buf1 = this.buf1; + this.shift(); + + if (buf1 instanceof Cmd) { + switch (buf1.cmd) { + case 'BI': // inline image + return this.makeInlineImage(cipherTransform); + case '[': // array + var array = []; + while (!isCmd(this.buf1, ']') && !isEOF(this.buf1)) { + array.push(this.getObj(cipherTransform)); + } + if (isEOF(this.buf1)) { + error('End of file inside array'); + } + this.shift(); + return array; + case '<<': // dictionary or stream + var dict = new Dict(this.xref); + while (!isCmd(this.buf1, '>>') && !isEOF(this.buf1)) { + if (!isName(this.buf1)) { + info('Malformed dictionary: key must be a name object'); + this.shift(); + continue; + } + + var key = this.buf1.name; + this.shift(); + if (isEOF(this.buf1)) { + break; + } + dict.set(key, this.getObj(cipherTransform)); + } + if (isEOF(this.buf1)) { + error('End of file inside dictionary'); + } + + // Stream objects are not allowed inside content streams or + // object streams. + if (isCmd(this.buf2, 'stream')) { + return (this.allowStreams ? + this.makeStream(dict, cipherTransform) : dict); + } + this.shift(); + return dict; + default: // simple object + return buf1; + } + } + + if (isInt(buf1)) { // indirect reference or integer + var num = buf1; + if (isInt(this.buf1) && isCmd(this.buf2, 'R')) { + var ref = new Ref(num, this.buf1); + this.shift(); + this.shift(); + return ref; + } + return num; + } + + if (isString(buf1)) { // string + var str = buf1; + if (cipherTransform) { + str = cipherTransform.decryptString(str); + } + return str; + } + + // simple object + return buf1; + }, + /** + * Find the end of the stream by searching for the /EI\s/. + * @returns {number} The inline stream length. + */ + findDefaultInlineStreamEnd: + function Parser_findDefaultInlineStreamEnd(stream) { + var E = 0x45, I = 0x49, SPACE = 0x20, LF = 0xA, CR = 0xD; + var startPos = stream.pos, state = 0, ch, i, n, followingBytes; + while ((ch = stream.getByte()) !== -1) { + if (state === 0) { + state = (ch === E) ? 1 : 0; + } else if (state === 1) { + state = (ch === I) ? 2 : 0; + } else { + assert(state === 2); + if (ch === SPACE || ch === LF || ch === CR) { + // Let's check the next five bytes are ASCII... just be sure. + n = 5; + followingBytes = stream.peekBytes(n); + for (i = 0; i < n; i++) { + ch = followingBytes[i]; + if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7F)) { + // Not a LF, CR, SPACE or any visible ASCII character, i.e. + // it's binary stuff. Resetting the state. + state = 0; + break; + } + } + if (state === 2) { + break; // Finished! + } + } else { + state = 0; + } + } + } + return ((stream.pos - 4) - startPos); + }, + /** + * Find the EOI (end-of-image) marker 0xFFD9 of the stream. + * @returns {number} The inline stream length. + */ + findDCTDecodeInlineStreamEnd: + function Parser_findDCTDecodeInlineStreamEnd(stream) { + var startPos = stream.pos, foundEOI = false, b, markerLength, length; + while ((b = stream.getByte()) !== -1) { + if (b !== 0xFF) { // Not a valid marker. + continue; + } + switch (stream.getByte()) { + case 0x00: // Byte stuffing. + // 0xFF00 appears to be a very common byte sequence in JPEG images. + break; + + case 0xFF: // Fill byte. + // Avoid skipping a valid marker, resetting the stream position. + stream.skip(-1); + break; + + case 0xD9: // EOI + foundEOI = true; + break; + + case 0xC0: // SOF0 + case 0xC1: // SOF1 + case 0xC2: // SOF2 + case 0xC3: // SOF3 + + case 0xC5: // SOF5 + case 0xC6: // SOF6 + case 0xC7: // SOF7 + + case 0xC9: // SOF9 + case 0xCA: // SOF10 + case 0xCB: // SOF11 + + case 0xCD: // SOF13 + case 0xCE: // SOF14 + case 0xCF: // SOF15 + + case 0xC4: // DHT + case 0xCC: // DAC + + case 0xDA: // SOS + case 0xDB: // DQT + case 0xDC: // DNL + case 0xDD: // DRI + case 0xDE: // DHP + case 0xDF: // EXP + + case 0xE0: // APP0 + case 0xE1: // APP1 + case 0xE2: // APP2 + case 0xE3: // APP3 + case 0xE4: // APP4 + case 0xE5: // APP5 + case 0xE6: // APP6 + case 0xE7: // APP7 + case 0xE8: // APP8 + case 0xE9: // APP9 + case 0xEA: // APP10 + case 0xEB: // APP11 + case 0xEC: // APP12 + case 0xED: // APP13 + case 0xEE: // APP14 + case 0xEF: // APP15 + + case 0xFE: // COM + // The marker should be followed by the length of the segment. + markerLength = stream.getUint16(); + if (markerLength > 2) { + // |markerLength| contains the byte length of the marker segment, + // including its own length (2 bytes) and excluding the marker. + stream.skip(markerLength - 2); // Jump to the next marker. + } else { + // The marker length is invalid, resetting the stream position. + stream.skip(-2); + } + break; + } + if (foundEOI) { + break; + } + } + length = stream.pos - startPos; + if (b === -1) { + warn('Inline DCTDecode image stream: ' + + 'EOI marker not found, searching for /EI/ instead.'); + stream.skip(-length); // Reset the stream position. + return this.findDefaultInlineStreamEnd(stream); + } + this.inlineStreamSkipEI(stream); + return length; + }, + /** + * Find the EOD (end-of-data) marker '~>' (i.e. TILDE + GT) of the stream. + * @returns {number} The inline stream length. + */ + findASCII85DecodeInlineStreamEnd: + function Parser_findASCII85DecodeInlineStreamEnd(stream) { + var TILDE = 0x7E, GT = 0x3E; + var startPos = stream.pos, ch, length; + while ((ch = stream.getByte()) !== -1) { + if (ch === TILDE && stream.peekByte() === GT) { + stream.skip(); + break; + } + } + length = stream.pos - startPos; + if (ch === -1) { + warn('Inline ASCII85Decode image stream: ' + + 'EOD marker not found, searching for /EI/ instead.'); + stream.skip(-length); // Reset the stream position. + return this.findDefaultInlineStreamEnd(stream); + } + this.inlineStreamSkipEI(stream); + return length; + }, + /** + * Find the EOD (end-of-data) marker '>' (i.e. GT) of the stream. + * @returns {number} The inline stream length. + */ + findASCIIHexDecodeInlineStreamEnd: + function Parser_findASCIIHexDecodeInlineStreamEnd(stream) { + var GT = 0x3E; + var startPos = stream.pos, ch, length; + while ((ch = stream.getByte()) !== -1) { + if (ch === GT) { + break; + } + } + length = stream.pos - startPos; + if (ch === -1) { + warn('Inline ASCIIHexDecode image stream: ' + + 'EOD marker not found, searching for /EI/ instead.'); + stream.skip(-length); // Reset the stream position. + return this.findDefaultInlineStreamEnd(stream); + } + this.inlineStreamSkipEI(stream); + return length; + }, + /** + * Skip over the /EI/ for streams where we search for an EOD marker. + */ + inlineStreamSkipEI: function Parser_inlineStreamSkipEI(stream) { + var E = 0x45, I = 0x49; + var state = 0, ch; + while ((ch = stream.getByte()) !== -1) { + if (state === 0) { + state = (ch === E) ? 1 : 0; + } else if (state === 1) { + state = (ch === I) ? 2 : 0; + } else if (state === 2) { + break; + } + } + }, + makeInlineImage: function Parser_makeInlineImage(cipherTransform) { + var lexer = this.lexer; + var stream = lexer.stream; + + // Parse dictionary. + var dict = new Dict(this.xref); + while (!isCmd(this.buf1, 'ID') && !isEOF(this.buf1)) { + if (!isName(this.buf1)) { + error('Dictionary key must be a name object'); + } + var key = this.buf1.name; + this.shift(); + if (isEOF(this.buf1)) { + break; + } + dict.set(key, this.getObj(cipherTransform)); + } + + // Extract the name of the first (i.e. the current) image filter. + var filter = dict.get('Filter', 'F'), filterName; + if (isName(filter)) { + filterName = filter.name; + } else if (isArray(filter) && isName(filter[0])) { + filterName = filter[0].name; + } + + // Parse image stream. + var startPos = stream.pos, length, i, ii; + if (filterName === 'DCTDecode' || filterName === 'DCT') { + length = this.findDCTDecodeInlineStreamEnd(stream); + } else if (filterName === 'ASCII85Decide' || filterName === 'A85') { + length = this.findASCII85DecodeInlineStreamEnd(stream); + } else if (filterName === 'ASCIIHexDecode' || filterName === 'AHx') { + length = this.findASCIIHexDecodeInlineStreamEnd(stream); + } else { + length = this.findDefaultInlineStreamEnd(stream); + } + var imageStream = stream.makeSubStream(startPos, length, dict); + + // Cache all images below the MAX_LENGTH_TO_CACHE threshold by their + // adler32 checksum. + var adler32; + if (length < MAX_LENGTH_TO_CACHE) { + var imageBytes = imageStream.getBytes(); + imageStream.reset(); + + var a = 1; + var b = 0; + for (i = 0, ii = imageBytes.length; i < ii; ++i) { + // No modulo required in the loop if imageBytes.length < 5552. + a += imageBytes[i] & 0xff; + b += a; + } + adler32 = ((b % 65521) << 16) | (a % 65521); + + if (this.imageCache.adler32 === adler32) { + this.buf2 = Cmd.get('EI'); + this.shift(); + + this.imageCache[adler32].reset(); + return this.imageCache[adler32]; + } + } + + if (cipherTransform) { + imageStream = cipherTransform.createStream(imageStream, length); + } + + imageStream = this.filter(imageStream, dict, length); + imageStream.dict = dict; + if (adler32 !== undefined) { + imageStream.cacheKey = 'inline_' + length + '_' + adler32; + this.imageCache[adler32] = imageStream; + } + + this.buf2 = Cmd.get('EI'); + this.shift(); + + return imageStream; + }, + makeStream: function Parser_makeStream(dict, cipherTransform) { + var lexer = this.lexer; + var stream = lexer.stream; + + // get stream start position + lexer.skipToNextLine(); + var pos = stream.pos - 1; + + // get length + var length = dict.get('Length'); + if (!isInt(length)) { + info('Bad ' + length + ' attribute in stream'); + length = 0; + } + + // skip over the stream data + stream.pos = pos + length; + lexer.nextChar(); + + // Shift '>>' and check whether the new object marks the end of the stream + if (this.tryShift() && isCmd(this.buf2, 'endstream')) { + this.shift(); // 'stream' + } else { + // bad stream length, scanning for endstream + stream.pos = pos; + var SCAN_BLOCK_SIZE = 2048; + var ENDSTREAM_SIGNATURE_LENGTH = 9; + var ENDSTREAM_SIGNATURE = [0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, + 0x61, 0x6D]; + var skipped = 0, found = false, i, j; + while (stream.pos < stream.end) { + var scanBytes = stream.peekBytes(SCAN_BLOCK_SIZE); + var scanLength = scanBytes.length - ENDSTREAM_SIGNATURE_LENGTH; + if (scanLength <= 0) { + break; + } + found = false; + i = 0; + while (i < scanLength) { + j = 0; + while (j < ENDSTREAM_SIGNATURE_LENGTH && + scanBytes[i + j] === ENDSTREAM_SIGNATURE[j]) { + j++; + } + if (j >= ENDSTREAM_SIGNATURE_LENGTH) { + found = true; + break; + } + i++; + } + if (found) { + skipped += i; + stream.pos += i; + break; + } + skipped += scanLength; + stream.pos += scanLength; + } + if (!found) { + error('Missing endstream'); + } + length = skipped; + + lexer.nextChar(); + this.shift(); + this.shift(); + } + this.shift(); // 'endstream' + + stream = stream.makeSubStream(pos, length, dict); + if (cipherTransform) { + stream = cipherTransform.createStream(stream, length); + } + stream = this.filter(stream, dict, length); + stream.dict = dict; + return stream; + }, + filter: function Parser_filter(stream, dict, length) { + var filter = dict.get('Filter', 'F'); + var params = dict.get('DecodeParms', 'DP'); + if (isName(filter)) { + return this.makeFilter(stream, filter.name, length, params); + } + + var maybeLength = length; + if (isArray(filter)) { + var filterArray = filter; + var paramsArray = params; + for (var i = 0, ii = filterArray.length; i < ii; ++i) { + filter = filterArray[i]; + if (!isName(filter)) { + error('Bad filter name: ' + filter); + } + + params = null; + if (isArray(paramsArray) && (i in paramsArray)) { + params = paramsArray[i]; + } + stream = this.makeFilter(stream, filter.name, maybeLength, params); + // after the first stream the length variable is invalid + maybeLength = null; + } + } + return stream; + }, + makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) { + if (stream.dict.get('Length') === 0 && !maybeLength) { + warn('Empty "' + name + '" stream.'); + return new NullStream(stream); + } + try { + if (params && this.xref) { + params = this.xref.fetchIfRef(params); + } + var xrefStreamStats = this.xref.stats.streamTypes; + if (name === 'FlateDecode' || name === 'Fl') { + xrefStreamStats[StreamType.FLATE] = true; + if (params) { + return new PredictorStream(new FlateStream(stream, maybeLength), + maybeLength, params); + } + return new FlateStream(stream, maybeLength); + } + if (name === 'LZWDecode' || name === 'LZW') { + xrefStreamStats[StreamType.LZW] = true; + var earlyChange = 1; + if (params) { + if (params.has('EarlyChange')) { + earlyChange = params.get('EarlyChange'); + } + return new PredictorStream( + new LZWStream(stream, maybeLength, earlyChange), + maybeLength, params); + } + return new LZWStream(stream, maybeLength, earlyChange); + } + if (name === 'DCTDecode' || name === 'DCT') { + xrefStreamStats[StreamType.DCT] = true; + return new JpegStream(stream, maybeLength, stream.dict, this.xref); + } + if (name === 'JPXDecode' || name === 'JPX') { + xrefStreamStats[StreamType.JPX] = true; + return new JpxStream(stream, maybeLength, stream.dict); + } + if (name === 'ASCII85Decode' || name === 'A85') { + xrefStreamStats[StreamType.A85] = true; + return new Ascii85Stream(stream, maybeLength); + } + if (name === 'ASCIIHexDecode' || name === 'AHx') { + xrefStreamStats[StreamType.AHX] = true; + return new AsciiHexStream(stream, maybeLength); + } + if (name === 'CCITTFaxDecode' || name === 'CCF') { + xrefStreamStats[StreamType.CCF] = true; + return new CCITTFaxStream(stream, maybeLength, params); + } + if (name === 'RunLengthDecode' || name === 'RL') { + xrefStreamStats[StreamType.RL] = true; + return new RunLengthStream(stream, maybeLength); + } + if (name === 'JBIG2Decode') { + xrefStreamStats[StreamType.JBIG] = true; + return new Jbig2Stream(stream, maybeLength, stream.dict); + } + warn('filter "' + name + '" not supported yet'); + return stream; + } catch (ex) { + if (ex instanceof MissingDataException) { + throw ex; + } + warn('Invalid stream: \"' + ex + '\"'); + return new NullStream(stream); + } + } + }; + + return Parser; +})(); + +var Lexer = (function LexerClosure() { + function Lexer(stream, knownCommands) { + this.stream = stream; + this.nextChar(); + + // While lexing, we build up many strings one char at a time. Using += for + // this can result in lots of garbage strings. It's better to build an + // array of single-char strings and then join() them together at the end. + // And reusing a single array (i.e. |this.strBuf|) over and over for this + // purpose uses less memory than using a new array for each string. + this.strBuf = []; + + // The PDFs might have "glued" commands with other commands, operands or + // literals, e.g. "q1". The knownCommands is a dictionary of the valid + // commands and their prefixes. The prefixes are built the following way: + // if there a command that is a prefix of the other valid command or + // literal (e.g. 'f' and 'false') the following prefixes must be included, + // 'fa', 'fal', 'fals'. The prefixes are not needed, if the command has no + // other commands or literals as a prefix. The knowCommands is optional. + this.knownCommands = knownCommands; + } + + Lexer.isSpace = function Lexer_isSpace(ch) { + // Space is one of the following characters: SPACE, TAB, CR or LF. + return (ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A); + }; + + // A '1' in this array means the character is white space. A '1' or + // '2' means the character ends a name or command. + var specialChars = [ + 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, // 0x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x + 1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, // 2x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, // 3x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, // 5x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, // 7x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // ax + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // bx + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // cx + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // dx + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // ex + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // fx + ]; + + function toHexDigit(ch) { + if (ch >= 0x30 && ch <= 0x39) { // '0'-'9' + return ch & 0x0F; + } + if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) { + // 'A'-'F', 'a'-'f' + return (ch & 0x0F) + 9; + } + return -1; + } + + Lexer.prototype = { + nextChar: function Lexer_nextChar() { + return (this.currentChar = this.stream.getByte()); + }, + peekChar: function Lexer_peekChar() { + return this.stream.peekByte(); + }, + getNumber: function Lexer_getNumber() { + var ch = this.currentChar; + var eNotation = false; + var divideBy = 0; // different from 0 if it's a floating point value + var sign = 1; + + if (ch === 0x2D) { // '-' + sign = -1; + ch = this.nextChar(); + + if (ch === 0x2D) { // '-' + // Ignore double negative (this is consistent with Adobe Reader). + ch = this.nextChar(); + } + } else if (ch === 0x2B) { // '+' + ch = this.nextChar(); + } + if (ch === 0x2E) { // '.' + divideBy = 10; + ch = this.nextChar(); + } + if (ch < 0x30 || ch > 0x39) { // '0' - '9' + error('Invalid number: ' + String.fromCharCode(ch)); + return 0; + } + + var baseValue = ch - 0x30; // '0' + var powerValue = 0; + var powerValueSign = 1; + + while ((ch = this.nextChar()) >= 0) { + if (0x30 <= ch && ch <= 0x39) { // '0' - '9' + var currentDigit = ch - 0x30; // '0' + if (eNotation) { // We are after an 'e' or 'E' + powerValue = powerValue * 10 + currentDigit; + } else { + if (divideBy !== 0) { // We are after a point + divideBy *= 10; + } + baseValue = baseValue * 10 + currentDigit; + } + } else if (ch === 0x2E) { // '.' + if (divideBy === 0) { + divideBy = 1; + } else { + // A number can have only one '.' + break; + } + } else if (ch === 0x2D) { // '-' + // ignore minus signs in the middle of numbers to match + // Adobe's behavior + warn('Badly formated number'); + } else if (ch === 0x45 || ch === 0x65) { // 'E', 'e' + // 'E' can be either a scientific notation or the beginning of a new + // operator + ch = this.peekChar(); + if (ch === 0x2B || ch === 0x2D) { // '+', '-' + powerValueSign = (ch === 0x2D) ? -1 : 1; + this.nextChar(); // Consume the sign character + } else if (ch < 0x30 || ch > 0x39) { // '0' - '9' + // The 'E' must be the beginning of a new operator + break; + } + eNotation = true; + } else { + // the last character doesn't belong to us + break; + } + } + + if (divideBy !== 0) { + baseValue /= divideBy; + } + if (eNotation) { + baseValue *= Math.pow(10, powerValueSign * powerValue); + } + return sign * baseValue; + }, + getString: function Lexer_getString() { + var numParen = 1; + var done = false; + var strBuf = this.strBuf; + strBuf.length = 0; + + var ch = this.nextChar(); + while (true) { + var charBuffered = false; + switch (ch | 0) { + case -1: + warn('Unterminated string'); + done = true; + break; + case 0x28: // '(' + ++numParen; + strBuf.push('('); + break; + case 0x29: // ')' + if (--numParen === 0) { + this.nextChar(); // consume strings ')' + done = true; + } else { + strBuf.push(')'); + } + break; + case 0x5C: // '\\' + ch = this.nextChar(); + switch (ch) { + case -1: + warn('Unterminated string'); + done = true; + break; + case 0x6E: // 'n' + strBuf.push('\n'); + break; + case 0x72: // 'r' + strBuf.push('\r'); + break; + case 0x74: // 't' + strBuf.push('\t'); + break; + case 0x62: // 'b' + strBuf.push('\b'); + break; + case 0x66: // 'f' + strBuf.push('\f'); + break; + case 0x5C: // '\' + case 0x28: // '(' + case 0x29: // ')' + strBuf.push(String.fromCharCode(ch)); + break; + case 0x30: case 0x31: case 0x32: case 0x33: // '0'-'3' + case 0x34: case 0x35: case 0x36: case 0x37: // '4'-'7' + var x = ch & 0x0F; + ch = this.nextChar(); + charBuffered = true; + if (ch >= 0x30 && ch <= 0x37) { // '0'-'7' + x = (x << 3) + (ch & 0x0F); + ch = this.nextChar(); + if (ch >= 0x30 && ch <= 0x37) { // '0'-'7' + charBuffered = false; + x = (x << 3) + (ch & 0x0F); + } + } + strBuf.push(String.fromCharCode(x)); + break; + case 0x0D: // CR + if (this.peekChar() === 0x0A) { // LF + this.nextChar(); + } + break; + case 0x0A: // LF + break; + default: + strBuf.push(String.fromCharCode(ch)); + break; + } + break; + default: + strBuf.push(String.fromCharCode(ch)); + break; + } + if (done) { + break; + } + if (!charBuffered) { + ch = this.nextChar(); + } + } + return strBuf.join(''); + }, + getName: function Lexer_getName() { + var ch, previousCh; + var strBuf = this.strBuf; + strBuf.length = 0; + while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) { + if (ch === 0x23) { // '#' + ch = this.nextChar(); + if (specialChars[ch]) { + warn('Lexer_getName: ' + + 'NUMBER SIGN (#) should be followed by a hexadecimal number.'); + strBuf.push('#'); + break; + } + var x = toHexDigit(ch); + if (x !== -1) { + previousCh = ch; + ch = this.nextChar(); + var x2 = toHexDigit(ch); + if (x2 === -1) { + warn('Lexer_getName: Illegal digit (' + + String.fromCharCode(ch) +') in hexadecimal number.'); + strBuf.push('#', String.fromCharCode(previousCh)); + if (specialChars[ch]) { + break; + } + strBuf.push(String.fromCharCode(ch)); + continue; + } + strBuf.push(String.fromCharCode((x << 4) | x2)); + } else { + strBuf.push('#', String.fromCharCode(ch)); + } + } else { + strBuf.push(String.fromCharCode(ch)); + } + } + if (strBuf.length > 127) { + warn('name token is longer than allowed by the spec: ' + strBuf.length); + } + return Name.get(strBuf.join('')); + }, + getHexString: function Lexer_getHexString() { + var strBuf = this.strBuf; + strBuf.length = 0; + var ch = this.currentChar; + var isFirstHex = true; + var firstDigit; + var secondDigit; + while (true) { + if (ch < 0) { + warn('Unterminated hex string'); + break; + } else if (ch === 0x3E) { // '>' + this.nextChar(); + break; + } else if (specialChars[ch] === 1) { + ch = this.nextChar(); + continue; + } else { + if (isFirstHex) { + firstDigit = toHexDigit(ch); + if (firstDigit === -1) { + warn('Ignoring invalid character "' + ch + '" in hex string'); + ch = this.nextChar(); + continue; + } + } else { + secondDigit = toHexDigit(ch); + if (secondDigit === -1) { + warn('Ignoring invalid character "' + ch + '" in hex string'); + ch = this.nextChar(); + continue; + } + strBuf.push(String.fromCharCode((firstDigit << 4) | secondDigit)); + } + isFirstHex = !isFirstHex; + ch = this.nextChar(); + } + } + return strBuf.join(''); + }, + getObj: function Lexer_getObj() { + // skip whitespace and comments + var comment = false; + var ch = this.currentChar; + while (true) { + if (ch < 0) { + return EOF; + } + if (comment) { + if (ch === 0x0A || ch === 0x0D) { // LF, CR + comment = false; + } + } else if (ch === 0x25) { // '%' + comment = true; + } else if (specialChars[ch] !== 1) { + break; + } + ch = this.nextChar(); + } + + // start reading token + switch (ch | 0) { + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: // '0'-'4' + case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: // '5'-'9' + case 0x2B: case 0x2D: case 0x2E: // '+', '-', '.' + return this.getNumber(); + case 0x28: // '(' + return this.getString(); + case 0x2F: // '/' + return this.getName(); + // array punctuation + case 0x5B: // '[' + this.nextChar(); + return Cmd.get('['); + case 0x5D: // ']' + this.nextChar(); + return Cmd.get(']'); + // hex string or dict punctuation + case 0x3C: // '<' + ch = this.nextChar(); + if (ch === 0x3C) { + // dict punctuation + this.nextChar(); + return Cmd.get('<<'); + } + return this.getHexString(); + // dict punctuation + case 0x3E: // '>' + ch = this.nextChar(); + if (ch === 0x3E) { + this.nextChar(); + return Cmd.get('>>'); + } + return Cmd.get('>'); + case 0x7B: // '{' + this.nextChar(); + return Cmd.get('{'); + case 0x7D: // '}' + this.nextChar(); + return Cmd.get('}'); + case 0x29: // ')' + error('Illegal character: ' + ch); + break; + } + + // command + var str = String.fromCharCode(ch); + var knownCommands = this.knownCommands; + var knownCommandFound = knownCommands && knownCommands[str] !== undefined; + while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) { + // stop if known command is found and next character does not make + // the str a command + var possibleCommand = str + String.fromCharCode(ch); + if (knownCommandFound && knownCommands[possibleCommand] === undefined) { + break; + } + if (str.length === 128) { + error('Command token too long: ' + str.length); + } + str = possibleCommand; + knownCommandFound = knownCommands && knownCommands[str] !== undefined; + } + if (str === 'true') { + return true; + } + if (str === 'false') { + return false; + } + if (str === 'null') { + return null; + } + return Cmd.get(str); + }, + skipToNextLine: function Lexer_skipToNextLine() { + var ch = this.currentChar; + while (ch >= 0) { + if (ch === 0x0D) { // CR + ch = this.nextChar(); + if (ch === 0x0A) { // LF + this.nextChar(); + } + break; + } else if (ch === 0x0A) { // LF + this.nextChar(); + break; + } + ch = this.nextChar(); + } + } + }; + + return Lexer; +})(); + +var Linearization = { + create: function LinearizationCreate(stream) { + function getInt(name, allowZeroValue) { + var obj = linDict.get(name); + if (isInt(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) { + return obj; + } + throw new Error('The "' + name + '" parameter in the linearization ' + + 'dictionary is invalid.'); + } + function getHints() { + var hints = linDict.get('H'), hintsLength, item; + if (isArray(hints) && + ((hintsLength = hints.length) === 2 || hintsLength === 4)) { + for (var index = 0; index < hintsLength; index++) { + if (!(isInt(item = hints[index]) && item > 0)) { + throw new Error('Hint (' + index + + ') in the linearization dictionary is invalid.'); + } + } + return hints; + } + throw new Error('Hint array in the linearization dictionary is invalid.'); + } + var parser = new Parser(new Lexer(stream), false, null); + var obj1 = parser.getObj(); + var obj2 = parser.getObj(); + var obj3 = parser.getObj(); + var linDict = parser.getObj(); + var obj, length; + if (!(isInt(obj1) && isInt(obj2) && isCmd(obj3, 'obj') && isDict(linDict) && + isNum(obj = linDict.get('Linearized')) && obj > 0)) { + return null; // No valid linearization dictionary found. + } else if ((length = getInt('L')) !== stream.length) { + throw new Error('The "L" parameter in the linearization dictionary ' + + 'does not equal the stream length.'); + } + return { + length: length, + hints: getHints(), + objectNumberFirst: getInt('O'), + endFirst: getInt('E'), + numPages: getInt('N'), + mainXRefEntriesOffset: getInt('T'), + pageFirst: (linDict.has('P') ? getInt('P', true) : 0) + }; + } +}; + +exports.EOF = EOF; +exports.Lexer = Lexer; +exports.Linearization = Linearization; +exports.Parser = Parser; +exports.isEOF = isEOF; + +// TODO refactor to remove dependency on stream.js +coreStream._setCoreParser(exports); +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreCMap = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser) { + +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var error = sharedUtil.error; +var isInt = sharedUtil.isInt; +var isString = sharedUtil.isString; +var warn = sharedUtil.warn; +var isName = corePrimitives.isName; +var isCmd = corePrimitives.isCmd; +var isStream = corePrimitives.isStream; +var StringStream = coreStream.StringStream; +var Lexer = coreParser.Lexer; +var isEOF = coreParser.isEOF; + +var BUILT_IN_CMAPS = [ +// << Start unicode maps. +'Adobe-GB1-UCS2', +'Adobe-CNS1-UCS2', +'Adobe-Japan1-UCS2', +'Adobe-Korea1-UCS2', +// >> End unicode maps. +'78-EUC-H', +'78-EUC-V', +'78-H', +'78-RKSJ-H', +'78-RKSJ-V', +'78-V', +'78ms-RKSJ-H', +'78ms-RKSJ-V', +'83pv-RKSJ-H', +'90ms-RKSJ-H', +'90ms-RKSJ-V', +'90msp-RKSJ-H', +'90msp-RKSJ-V', +'90pv-RKSJ-H', +'90pv-RKSJ-V', +'Add-H', +'Add-RKSJ-H', +'Add-RKSJ-V', +'Add-V', +'Adobe-CNS1-0', +'Adobe-CNS1-1', +'Adobe-CNS1-2', +'Adobe-CNS1-3', +'Adobe-CNS1-4', +'Adobe-CNS1-5', +'Adobe-CNS1-6', +'Adobe-GB1-0', +'Adobe-GB1-1', +'Adobe-GB1-2', +'Adobe-GB1-3', +'Adobe-GB1-4', +'Adobe-GB1-5', +'Adobe-Japan1-0', +'Adobe-Japan1-1', +'Adobe-Japan1-2', +'Adobe-Japan1-3', +'Adobe-Japan1-4', +'Adobe-Japan1-5', +'Adobe-Japan1-6', +'Adobe-Korea1-0', +'Adobe-Korea1-1', +'Adobe-Korea1-2', +'B5-H', +'B5-V', +'B5pc-H', +'B5pc-V', +'CNS-EUC-H', +'CNS-EUC-V', +'CNS1-H', +'CNS1-V', +'CNS2-H', +'CNS2-V', +'ETHK-B5-H', +'ETHK-B5-V', +'ETen-B5-H', +'ETen-B5-V', +'ETenms-B5-H', +'ETenms-B5-V', +'EUC-H', +'EUC-V', +'Ext-H', +'Ext-RKSJ-H', +'Ext-RKSJ-V', +'Ext-V', +'GB-EUC-H', +'GB-EUC-V', +'GB-H', +'GB-V', +'GBK-EUC-H', +'GBK-EUC-V', +'GBK2K-H', +'GBK2K-V', +'GBKp-EUC-H', +'GBKp-EUC-V', +'GBT-EUC-H', +'GBT-EUC-V', +'GBT-H', +'GBT-V', +'GBTpc-EUC-H', +'GBTpc-EUC-V', +'GBpc-EUC-H', +'GBpc-EUC-V', +'H', +'HKdla-B5-H', +'HKdla-B5-V', +'HKdlb-B5-H', +'HKdlb-B5-V', +'HKgccs-B5-H', +'HKgccs-B5-V', +'HKm314-B5-H', +'HKm314-B5-V', +'HKm471-B5-H', +'HKm471-B5-V', +'HKscs-B5-H', +'HKscs-B5-V', +'Hankaku', +'Hiragana', +'KSC-EUC-H', +'KSC-EUC-V', +'KSC-H', +'KSC-Johab-H', +'KSC-Johab-V', +'KSC-V', +'KSCms-UHC-H', +'KSCms-UHC-HW-H', +'KSCms-UHC-HW-V', +'KSCms-UHC-V', +'KSCpc-EUC-H', +'KSCpc-EUC-V', +'Katakana', +'NWP-H', +'NWP-V', +'RKSJ-H', +'RKSJ-V', +'Roman', +'UniCNS-UCS2-H', +'UniCNS-UCS2-V', +'UniCNS-UTF16-H', +'UniCNS-UTF16-V', +'UniCNS-UTF32-H', +'UniCNS-UTF32-V', +'UniCNS-UTF8-H', +'UniCNS-UTF8-V', +'UniGB-UCS2-H', +'UniGB-UCS2-V', +'UniGB-UTF16-H', +'UniGB-UTF16-V', +'UniGB-UTF32-H', +'UniGB-UTF32-V', +'UniGB-UTF8-H', +'UniGB-UTF8-V', +'UniJIS-UCS2-H', +'UniJIS-UCS2-HW-H', +'UniJIS-UCS2-HW-V', +'UniJIS-UCS2-V', +'UniJIS-UTF16-H', +'UniJIS-UTF16-V', +'UniJIS-UTF32-H', +'UniJIS-UTF32-V', +'UniJIS-UTF8-H', +'UniJIS-UTF8-V', +'UniJIS2004-UTF16-H', +'UniJIS2004-UTF16-V', +'UniJIS2004-UTF32-H', +'UniJIS2004-UTF32-V', +'UniJIS2004-UTF8-H', +'UniJIS2004-UTF8-V', +'UniJISPro-UCS2-HW-V', +'UniJISPro-UCS2-V', +'UniJISPro-UTF8-V', +'UniJISX0213-UTF32-H', +'UniJISX0213-UTF32-V', +'UniJISX02132004-UTF32-H', +'UniJISX02132004-UTF32-V', +'UniKS-UCS2-H', +'UniKS-UCS2-V', +'UniKS-UTF16-H', +'UniKS-UTF16-V', +'UniKS-UTF32-H', +'UniKS-UTF32-V', +'UniKS-UTF8-H', +'UniKS-UTF8-V', +'V', +'WP-Symbol']; + +// CMap, not to be confused with TrueType's cmap. +var CMap = (function CMapClosure() { + function CMap(builtInCMap) { + // Codespace ranges are stored as follows: + // [[1BytePairs], [2BytePairs], [3BytePairs], [4BytePairs]] + // where nBytePairs are ranges e.g. [low1, high1, low2, high2, ...] + this.codespaceRanges = [[], [], [], []]; + this.numCodespaceRanges = 0; + // Map entries have one of two forms. + // - cid chars are 16-bit unsigned integers, stored as integers. + // - bf chars are variable-length byte sequences, stored as strings, with + // one byte per character. + this._map = []; + this.name = ''; + this.vertical = false; + this.useCMap = null; + this.builtInCMap = builtInCMap; + } + CMap.prototype = { + addCodespaceRange: function(n, low, high) { + this.codespaceRanges[n - 1].push(low, high); + this.numCodespaceRanges++; + }, + + mapCidRange: function(low, high, dstLow) { + while (low <= high) { + this._map[low++] = dstLow++; + } + }, + + mapBfRange: function(low, high, dstLow) { + var lastByte = dstLow.length - 1; + while (low <= high) { + this._map[low++] = dstLow; + // Only the last byte has to be incremented. + dstLow = dstLow.substr(0, lastByte) + + String.fromCharCode(dstLow.charCodeAt(lastByte) + 1); + } + }, + + mapBfRangeToArray: function(low, high, array) { + var i = 0, ii = array.length; + while (low <= high && i < ii) { + this._map[low] = array[i++]; + ++low; + } + }, + + // This is used for both bf and cid chars. + mapOne: function(src, dst) { + this._map[src] = dst; + }, + + lookup: function(code) { + return this._map[code]; + }, + + contains: function(code) { + return this._map[code] !== undefined; + }, + + forEach: function(callback) { + // Most maps have fewer than 65536 entries, and for those we use normal + // array iteration. But really sparse tables are possible -- e.g. with + // indices in the *billions*. For such tables we use for..in, which isn't + // ideal because it stringifies the indices for all present elements, but + // it does avoid iterating over every undefined entry. + var map = this._map; + var length = map.length; + var i; + if (length <= 0x10000) { + for (i = 0; i < length; i++) { + if (map[i] !== undefined) { + callback(i, map[i]); + } + } + } else { + for (i in this._map) { + callback(i, map[i]); + } + } + }, + + charCodeOf: function(value) { + return this._map.indexOf(value); + }, + + getMap: function() { + return this._map; + }, + + readCharCode: function(str, offset, out) { + var c = 0; + var codespaceRanges = this.codespaceRanges; + var codespaceRangesLen = this.codespaceRanges.length; + // 9.7.6.2 CMap Mapping + // The code length is at most 4. + for (var n = 0; n < codespaceRangesLen; n++) { + c = ((c << 8) | str.charCodeAt(offset + n)) >>> 0; + // Check each codespace range to see if it falls within. + var codespaceRange = codespaceRanges[n]; + for (var k = 0, kk = codespaceRange.length; k < kk;) { + var low = codespaceRange[k++]; + var high = codespaceRange[k++]; + if (c >= low && c <= high) { + out.charcode = c; + out.length = n + 1; + return; + } + } + } + out.charcode = 0; + out.length = 1; + }, + + get length() { + return this._map.length; + }, + + get isIdentityCMap() { + if (!(this.name === 'Identity-H' || this.name === 'Identity-V')) { + return false; + } + if (this._map.length !== 0x10000) { + return false; + } + for (var i = 0; i < 0x10000; i++) { + if (this._map[i] !== i) { + return false; + } + } + return true; + } + }; + return CMap; +})(); + +// A special case of CMap, where the _map array implicitly has a length of +// 65536 and each element is equal to its index. +var IdentityCMap = (function IdentityCMapClosure() { + function IdentityCMap(vertical, n) { + CMap.call(this); + this.vertical = vertical; + this.addCodespaceRange(n, 0, 0xffff); + } + Util.inherit(IdentityCMap, CMap, {}); + + IdentityCMap.prototype = { + addCodespaceRange: CMap.prototype.addCodespaceRange, + + mapCidRange: function(low, high, dstLow) { + error('should not call mapCidRange'); + }, + + mapBfRange: function(low, high, dstLow) { + error('should not call mapBfRange'); + }, + + mapBfRangeToArray: function(low, high, array) { + error('should not call mapBfRangeToArray'); + }, + + mapOne: function(src, dst) { + error('should not call mapCidOne'); + }, + + lookup: function(code) { + return (isInt(code) && code <= 0xffff) ? code : undefined; + }, + + contains: function(code) { + return isInt(code) && code <= 0xffff; + }, + + forEach: function(callback) { + for (var i = 0; i <= 0xffff; i++) { + callback(i, i); + } + }, + + charCodeOf: function(value) { + return (isInt(value) && value <= 0xffff) ? value : -1; + }, + + getMap: function() { + // Sometimes identity maps must be instantiated, but it's rare. + var map = new Array(0x10000); + for (var i = 0; i <= 0xffff; i++) { + map[i] = i; + } + return map; + }, + + readCharCode: CMap.prototype.readCharCode, + + get length() { + return 0x10000; + }, + + get isIdentityCMap() { + error('should not access .isIdentityCMap'); + } + }; + + return IdentityCMap; +})(); + +var BinaryCMapReader = (function BinaryCMapReaderClosure() { + function fetchBinaryData(url) { + var nonBinaryRequest = PDFJS.disableWorker; + var request = new XMLHttpRequest(); + request.open('GET', url, false); + if (!nonBinaryRequest) { + try { + request.responseType = 'arraybuffer'; + nonBinaryRequest = request.responseType !== 'arraybuffer'; + } catch (e) { + nonBinaryRequest = true; + } + } + if (nonBinaryRequest && request.overrideMimeType) { + request.overrideMimeType('text/plain; charset=x-user-defined'); + } + request.send(null); + if (nonBinaryRequest ? !request.responseText : !request.response) { + error('Unable to get binary cMap at: ' + url); + } + if (nonBinaryRequest) { + var data = Array.prototype.map.call(request.responseText, function (ch) { + return ch.charCodeAt(0) & 255; + }); + return new Uint8Array(data); + } + return new Uint8Array(request.response); + } + + function hexToInt(a, size) { + var n = 0; + for (var i = 0; i <= size; i++) { + n = (n << 8) | a[i]; + } + return n >>> 0; + } + + function hexToStr(a, size) { + // This code is hot. Special-case some common values to avoid creating an + // object with subarray(). + if (size === 1) { + return String.fromCharCode(a[0], a[1]); + } + if (size === 3) { + return String.fromCharCode(a[0], a[1], a[2], a[3]); + } + return String.fromCharCode.apply(null, a.subarray(0, size + 1)); + } + + function addHex(a, b, size) { + var c = 0; + for (var i = size; i >= 0; i--) { + c += a[i] + b[i]; + a[i] = c & 255; + c >>= 8; + } + } + + function incHex(a, size) { + var c = 1; + for (var i = size; i >= 0 && c > 0; i--) { + c += a[i]; + a[i] = c & 255; + c >>= 8; + } + } + + var MAX_NUM_SIZE = 16; + var MAX_ENCODED_NUM_SIZE = 19; // ceil(MAX_NUM_SIZE * 7 / 8) + + function BinaryCMapStream(data) { + this.buffer = data; + this.pos = 0; + this.end = data.length; + this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE); + } + + BinaryCMapStream.prototype = { + readByte: function () { + if (this.pos >= this.end) { + return -1; + } + return this.buffer[this.pos++]; + }, + readNumber: function () { + var n = 0; + var last; + do { + var b = this.readByte(); + if (b < 0) { + error('unexpected EOF in bcmap'); + } + last = !(b & 0x80); + n = (n << 7) | (b & 0x7F); + } while (!last); + return n; + }, + readSigned: function () { + var n = this.readNumber(); + return (n & 1) ? ~(n >>> 1) : n >>> 1; + }, + readHex: function (num, size) { + num.set(this.buffer.subarray(this.pos, + this.pos + size + 1)); + this.pos += size + 1; + }, + readHexNumber: function (num, size) { + var last; + var stack = this.tmpBuf, sp = 0; + do { + var b = this.readByte(); + if (b < 0) { + error('unexpected EOF in bcmap'); + } + last = !(b & 0x80); + stack[sp++] = b & 0x7F; + } while (!last); + var i = size, buffer = 0, bufferSize = 0; + while (i >= 0) { + while (bufferSize < 8 && stack.length > 0) { + buffer = (stack[--sp] << bufferSize) | buffer; + bufferSize += 7; + } + num[i] = buffer & 255; + i--; + buffer >>= 8; + bufferSize -= 8; + } + }, + readHexSigned: function (num, size) { + this.readHexNumber(num, size); + var sign = num[size] & 1 ? 255 : 0; + var c = 0; + for (var i = 0; i <= size; i++) { + c = ((c & 1) << 8) | num[i]; + num[i] = (c >> 1) ^ sign; + } + }, + readString: function () { + var len = this.readNumber(); + var s = ''; + for (var i = 0; i < len; i++) { + s += String.fromCharCode(this.readNumber()); + } + return s; + } + }; + + function processBinaryCMap(url, cMap, extend) { + var data = fetchBinaryData(url); + var stream = new BinaryCMapStream(data); + + var header = stream.readByte(); + cMap.vertical = !!(header & 1); + + var useCMap = null; + var start = new Uint8Array(MAX_NUM_SIZE); + var end = new Uint8Array(MAX_NUM_SIZE); + var char = new Uint8Array(MAX_NUM_SIZE); + var charCode = new Uint8Array(MAX_NUM_SIZE); + var tmp = new Uint8Array(MAX_NUM_SIZE); + var code; + + var b; + while ((b = stream.readByte()) >= 0) { + var type = b >> 5; + if (type === 7) { // metadata, e.g. comment or usecmap + switch (b & 0x1F) { + case 0: + stream.readString(); // skipping comment + break; + case 1: + useCMap = stream.readString(); + break; + } + continue; + } + var sequence = !!(b & 0x10); + var dataSize = b & 15; + + assert(dataSize + 1 <= MAX_NUM_SIZE); + + var ucs2DataSize = 1; + var subitemsCount = stream.readNumber(); + var i; + switch (type) { + case 0: // codespacerange + stream.readHex(start, dataSize); + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), + hexToInt(end, dataSize)); + for (i = 1; i < subitemsCount; i++) { + incHex(end, dataSize); + stream.readHexNumber(start, dataSize); + addHex(start, end, dataSize); + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), + hexToInt(end, dataSize)); + } + break; + case 1: // notdefrange + stream.readHex(start, dataSize); + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + code = stream.readNumber(); + // undefined range, skipping + for (i = 1; i < subitemsCount; i++) { + incHex(end, dataSize); + stream.readHexNumber(start, dataSize); + addHex(start, end, dataSize); + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + code = stream.readNumber(); + // nop + } + break; + case 2: // cidchar + stream.readHex(char, dataSize); + code = stream.readNumber(); + cMap.mapOne(hexToInt(char, dataSize), code); + for (i = 1; i < subitemsCount; i++) { + incHex(char, dataSize); + if (!sequence) { + stream.readHexNumber(tmp, dataSize); + addHex(char, tmp, dataSize); + } + code = stream.readSigned() + (code + 1); + cMap.mapOne(hexToInt(char, dataSize), code); + } + break; + case 3: // cidrange + stream.readHex(start, dataSize); + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + code = stream.readNumber(); + cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), + code); + for (i = 1; i < subitemsCount; i++) { + incHex(end, dataSize); + if (!sequence) { + stream.readHexNumber(start, dataSize); + addHex(start, end, dataSize); + } else { + start.set(end); + } + stream.readHexNumber(end, dataSize); + addHex(end, start, dataSize); + code = stream.readNumber(); + cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), + code); + } + break; + case 4: // bfchar + stream.readHex(char, ucs2DataSize); + stream.readHex(charCode, dataSize); + cMap.mapOne(hexToInt(char, ucs2DataSize), + hexToStr(charCode, dataSize)); + for (i = 1; i < subitemsCount; i++) { + incHex(char, ucs2DataSize); + if (!sequence) { + stream.readHexNumber(tmp, ucs2DataSize); + addHex(char, tmp, ucs2DataSize); + } + incHex(charCode, dataSize); + stream.readHexSigned(tmp, dataSize); + addHex(charCode, tmp, dataSize); + cMap.mapOne(hexToInt(char, ucs2DataSize), + hexToStr(charCode, dataSize)); + } + break; + case 5: // bfrange + stream.readHex(start, ucs2DataSize); + stream.readHexNumber(end, ucs2DataSize); + addHex(end, start, ucs2DataSize); + stream.readHex(charCode, dataSize); + cMap.mapBfRange(hexToInt(start, ucs2DataSize), + hexToInt(end, ucs2DataSize), + hexToStr(charCode, dataSize)); + for (i = 1; i < subitemsCount; i++) { + incHex(end, ucs2DataSize); + if (!sequence) { + stream.readHexNumber(start, ucs2DataSize); + addHex(start, end, ucs2DataSize); + } else { + start.set(end); + } + stream.readHexNumber(end, ucs2DataSize); + addHex(end, start, ucs2DataSize); + stream.readHex(charCode, dataSize); + cMap.mapBfRange(hexToInt(start, ucs2DataSize), + hexToInt(end, ucs2DataSize), + hexToStr(charCode, dataSize)); + } + break; + default: + error('Unknown type: ' + type); + break; + } + } + + if (useCMap) { + extend(useCMap); + } + return cMap; + } + + function BinaryCMapReader() {} + + BinaryCMapReader.prototype = { + read: processBinaryCMap + }; + + return BinaryCMapReader; +})(); + +var CMapFactory = (function CMapFactoryClosure() { + function strToInt(str) { + var a = 0; + for (var i = 0; i < str.length; i++) { + a = (a << 8) | str.charCodeAt(i); + } + return a >>> 0; + } + + function expectString(obj) { + if (!isString(obj)) { + error('Malformed CMap: expected string.'); + } + } + + function expectInt(obj) { + if (!isInt(obj)) { + error('Malformed CMap: expected int.'); + } + } + + function parseBfChar(cMap, lexer) { + while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } + if (isCmd(obj, 'endbfchar')) { + return; + } + expectString(obj); + var src = strToInt(obj); + obj = lexer.getObj(); + // TODO are /dstName used? + expectString(obj); + var dst = obj; + cMap.mapOne(src, dst); + } + } + + function parseBfRange(cMap, lexer) { + while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } + if (isCmd(obj, 'endbfrange')) { + return; + } + expectString(obj); + var low = strToInt(obj); + obj = lexer.getObj(); + expectString(obj); + var high = strToInt(obj); + obj = lexer.getObj(); + if (isInt(obj) || isString(obj)) { + var dstLow = isInt(obj) ? String.fromCharCode(obj) : obj; + cMap.mapBfRange(low, high, dstLow); + } else if (isCmd(obj, '[')) { + obj = lexer.getObj(); + var array = []; + while (!isCmd(obj, ']') && !isEOF(obj)) { + array.push(obj); + obj = lexer.getObj(); + } + cMap.mapBfRangeToArray(low, high, array); + } else { + break; + } + } + error('Invalid bf range.'); + } + + function parseCidChar(cMap, lexer) { + while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } + if (isCmd(obj, 'endcidchar')) { + return; + } + expectString(obj); + var src = strToInt(obj); + obj = lexer.getObj(); + expectInt(obj); + var dst = obj; + cMap.mapOne(src, dst); + } + } + + function parseCidRange(cMap, lexer) { + while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } + if (isCmd(obj, 'endcidrange')) { + return; + } + expectString(obj); + var low = strToInt(obj); + obj = lexer.getObj(); + expectString(obj); + var high = strToInt(obj); + obj = lexer.getObj(); + expectInt(obj); + var dstLow = obj; + cMap.mapCidRange(low, high, dstLow); + } + } + + function parseCodespaceRange(cMap, lexer) { + while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } + if (isCmd(obj, 'endcodespacerange')) { + return; + } + if (!isString(obj)) { + break; + } + var low = strToInt(obj); + obj = lexer.getObj(); + if (!isString(obj)) { + break; + } + var high = strToInt(obj); + cMap.addCodespaceRange(obj.length, low, high); + } + error('Invalid codespace range.'); + } + + function parseWMode(cMap, lexer) { + var obj = lexer.getObj(); + if (isInt(obj)) { + cMap.vertical = !!obj; + } + } + + function parseCMapName(cMap, lexer) { + var obj = lexer.getObj(); + if (isName(obj) && isString(obj.name)) { + cMap.name = obj.name; + } + } + + function parseCMap(cMap, lexer, builtInCMapParams, useCMap) { + var previous; + var embededUseCMap; + objLoop: while (true) { + var obj = lexer.getObj(); + if (isEOF(obj)) { + break; + } else if (isName(obj)) { + if (obj.name === 'WMode') { + parseWMode(cMap, lexer); + } else if (obj.name === 'CMapName') { + parseCMapName(cMap, lexer); + } + previous = obj; + } else if (isCmd(obj)) { + switch (obj.cmd) { + case 'endcmap': + break objLoop; + case 'usecmap': + if (isName(previous)) { + embededUseCMap = previous.name; + } + break; + case 'begincodespacerange': + parseCodespaceRange(cMap, lexer); + break; + case 'beginbfchar': + parseBfChar(cMap, lexer); + break; + case 'begincidchar': + parseCidChar(cMap, lexer); + break; + case 'beginbfrange': + parseBfRange(cMap, lexer); + break; + case 'begincidrange': + parseCidRange(cMap, lexer); + break; + } + } + } + + if (!useCMap && embededUseCMap) { + // Load the usecmap definition from the file only if there wasn't one + // specified. + useCMap = embededUseCMap; + } + if (useCMap) { + extendCMap(cMap, builtInCMapParams, useCMap); + } + } + + function extendCMap(cMap, builtInCMapParams, useCMap) { + cMap.useCMap = createBuiltInCMap(useCMap, builtInCMapParams); + // If there aren't any code space ranges defined clone all the parent ones + // into this cMap. + if (cMap.numCodespaceRanges === 0) { + var useCodespaceRanges = cMap.useCMap.codespaceRanges; + for (var i = 0; i < useCodespaceRanges.length; i++) { + cMap.codespaceRanges[i] = useCodespaceRanges[i].slice(); + } + cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges; + } + // Merge the map into the current one, making sure not to override + // any previously defined entries. + cMap.useCMap.forEach(function(key, value) { + if (!cMap.contains(key)) { + cMap.mapOne(key, cMap.useCMap.lookup(key)); + } + }); + } + + function parseBinaryCMap(name, builtInCMapParams) { + var url = builtInCMapParams.url + name + '.bcmap'; + var cMap = new CMap(true); + new BinaryCMapReader().read(url, cMap, function (useCMap) { + extendCMap(cMap, builtInCMapParams, useCMap); + }); + return cMap; + } + + function createBuiltInCMap(name, builtInCMapParams) { + if (name === 'Identity-H') { + return new IdentityCMap(false, 2); + } else if (name === 'Identity-V') { + return new IdentityCMap(true, 2); + } + if (BUILT_IN_CMAPS.indexOf(name) === -1) { + error('Unknown cMap name: ' + name); + } + assert(builtInCMapParams, 'built-in cMap parameters are not provided'); + + if (builtInCMapParams.packed) { + return parseBinaryCMap(name, builtInCMapParams); + } + + var request = new XMLHttpRequest(); + var url = builtInCMapParams.url + name; + request.open('GET', url, false); + request.send(null); + if (!request.responseText) { + error('Unable to get cMap at: ' + url); + } + var cMap = new CMap(true); + var lexer = new Lexer(new StringStream(request.responseText)); + parseCMap(cMap, lexer, builtInCMapParams, null); + return cMap; + } + + return { + create: function (encoding, builtInCMapParams, useCMap) { + if (isName(encoding)) { + return createBuiltInCMap(encoding.name, builtInCMapParams); + } else if (isStream(encoding)) { + var cMap = new CMap(); + var lexer = new Lexer(encoding); + try { + parseCMap(cMap, lexer, builtInCMapParams, useCMap); + } catch (e) { + warn('Invalid CMap data. ' + e); + } + if (cMap.isIdentityCMap) { + return createBuiltInCMap(cMap.name, builtInCMapParams); + } + return cMap; + } + error('Encoding required.'); + } + }; +})(); + +exports.CMap = CMap; +exports.CMapFactory = CMapFactory; +exports.IdentityCMap = IdentityCMap; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreObj = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreCrypto, root.pdfjsCoreParser, + root.pdfjsCoreChunkedStream); + } +}(this, function (exports, sharedUtil, corePrimitives, coreCrypto, coreParser, + coreChunkedStream) { + +var InvalidPDFException = sharedUtil.InvalidPDFException; +var MissingDataException = sharedUtil.MissingDataException; +var XRefParseException = sharedUtil.XRefParseException; +var assert = sharedUtil.assert; +var bytesToString = sharedUtil.bytesToString; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isInt = sharedUtil.isInt; +var isString = sharedUtil.isString; +var shadow = sharedUtil.shadow; +var stringToPDFString = sharedUtil.stringToPDFString; +var stringToUTF8String = sharedUtil.stringToUTF8String; +var warn = sharedUtil.warn; +var isValidUrl = sharedUtil.isValidUrl; +var Util = sharedUtil.Util; +var Ref = corePrimitives.Ref; +var RefSet = corePrimitives.RefSet; +var RefSetCache = corePrimitives.RefSetCache; +var isName = corePrimitives.isName; +var isCmd = corePrimitives.isCmd; +var isDict = corePrimitives.isDict; +var isRef = corePrimitives.isRef; +var isStream = corePrimitives.isStream; +var CipherTransformFactory = coreCrypto.CipherTransformFactory; +var Lexer = coreParser.Lexer; +var Parser = coreParser.Parser; +var ChunkedStream = coreChunkedStream.ChunkedStream; + +var Catalog = (function CatalogClosure() { + function Catalog(pdfManager, xref, pageFactory) { + this.pdfManager = pdfManager; + this.xref = xref; + this.catDict = xref.getCatalogObj(); + this.fontCache = new RefSetCache(); + assert(isDict(this.catDict), + 'catalog object is not a dictionary'); + + // TODO refactor to move getPage() to the PDFDocument. + this.pageFactory = pageFactory; + this.pagePromises = []; + } + + Catalog.prototype = { + get metadata() { + var streamRef = this.catDict.getRaw('Metadata'); + if (!isRef(streamRef)) { + return shadow(this, 'metadata', null); + } + + var encryptMetadata = (!this.xref.encrypt ? false : + this.xref.encrypt.encryptMetadata); + + var stream = this.xref.fetch(streamRef, !encryptMetadata); + var metadata; + if (stream && isDict(stream.dict)) { + var type = stream.dict.get('Type'); + var subtype = stream.dict.get('Subtype'); + + if (isName(type) && isName(subtype) && + type.name === 'Metadata' && subtype.name === 'XML') { + // XXX: This should examine the charset the XML document defines, + // however since there are currently no real means to decode + // arbitrary charsets, let's just hope that the author of the PDF + // was reasonable enough to stick with the XML default charset, + // which is UTF-8. + try { + metadata = stringToUTF8String(bytesToString(stream.getBytes())); + } catch (e) { + info('Skipping invalid metadata.'); + } + } + } + + return shadow(this, 'metadata', metadata); + }, + get toplevelPagesDict() { + var pagesObj = this.catDict.get('Pages'); + assert(isDict(pagesObj), 'invalid top-level pages dictionary'); + // shadow the prototype getter + return shadow(this, 'toplevelPagesDict', pagesObj); + }, + get documentOutline() { + var obj = null; + try { + obj = this.readDocumentOutline(); + } catch (ex) { + if (ex instanceof MissingDataException) { + throw ex; + } + warn('Unable to read document outline'); + } + return shadow(this, 'documentOutline', obj); + }, + readDocumentOutline: function Catalog_readDocumentOutline() { + var xref = this.xref; + var obj = this.catDict.get('Outlines'); + var root = { items: [] }; + if (isDict(obj)) { + obj = obj.getRaw('First'); + var processed = new RefSet(); + if (isRef(obj)) { + var queue = [{obj: obj, parent: root}]; + // to avoid recursion keeping track of the items + // in the processed dictionary + processed.put(obj); + while (queue.length > 0) { + var i = queue.shift(); + var outlineDict = xref.fetchIfRef(i.obj); + if (outlineDict === null) { + continue; + } + if (!outlineDict.has('Title')) { + error('Invalid outline item'); + } + var actionDict = outlineDict.get('A'), dest = null, url = null; + if (actionDict) { + var destEntry = actionDict.get('D'); + if (destEntry) { + dest = destEntry; + } else { + var uriEntry = actionDict.get('URI'); + if (isString(uriEntry) && isValidUrl(uriEntry, false)) { + url = uriEntry; + } + } + } else if (outlineDict.has('Dest')) { + dest = outlineDict.getRaw('Dest'); + if (isName(dest)) { + dest = dest.name; + } + } + var title = outlineDict.get('Title'); + var outlineItem = { + dest: dest, + url: url, + title: stringToPDFString(title), + color: outlineDict.get('C') || [0, 0, 0], + count: outlineDict.get('Count'), + bold: !!(outlineDict.get('F') & 2), + italic: !!(outlineDict.get('F') & 1), + items: [] + }; + i.parent.items.push(outlineItem); + obj = outlineDict.getRaw('First'); + if (isRef(obj) && !processed.has(obj)) { + queue.push({obj: obj, parent: outlineItem}); + processed.put(obj); + } + obj = outlineDict.getRaw('Next'); + if (isRef(obj) && !processed.has(obj)) { + queue.push({obj: obj, parent: i.parent}); + processed.put(obj); + } + } + } + } + return (root.items.length > 0 ? root.items : null); + }, + get numPages() { + var obj = this.toplevelPagesDict.get('Count'); + assert( + isInt(obj), + 'page count in top level pages object is not an integer' + ); + // shadow the prototype getter + return shadow(this, 'num', obj); + }, + get destinations() { + function fetchDestination(dest) { + return isDict(dest) ? dest.get('D') : dest; + } + + var xref = this.xref; + var dests = {}, nameTreeRef, nameDictionaryRef; + var obj = this.catDict.get('Names'); + if (obj && obj.has('Dests')) { + nameTreeRef = obj.getRaw('Dests'); + } else if (this.catDict.has('Dests')) { + nameDictionaryRef = this.catDict.get('Dests'); + } + + if (nameDictionaryRef) { + // reading simple destination dictionary + obj = nameDictionaryRef; + obj.forEach(function catalogForEach(key, value) { + if (!value) { + return; + } + dests[key] = fetchDestination(value); + }); + } + if (nameTreeRef) { + var nameTree = new NameTree(nameTreeRef, xref); + var names = nameTree.getAll(); + for (var name in names) { + if (!names.hasOwnProperty(name)) { + continue; + } + dests[name] = fetchDestination(names[name]); + } + } + return shadow(this, 'destinations', dests); + }, + getDestination: function Catalog_getDestination(destinationId) { + function fetchDestination(dest) { + return isDict(dest) ? dest.get('D') : dest; + } + + var xref = this.xref; + var dest = null, nameTreeRef, nameDictionaryRef; + var obj = this.catDict.get('Names'); + if (obj && obj.has('Dests')) { + nameTreeRef = obj.getRaw('Dests'); + } else if (this.catDict.has('Dests')) { + nameDictionaryRef = this.catDict.get('Dests'); + } + + if (nameDictionaryRef) { // Simple destination dictionary. + var value = nameDictionaryRef.get(destinationId); + if (value) { + dest = fetchDestination(value); + } + } + if (nameTreeRef) { + var nameTree = new NameTree(nameTreeRef, xref); + dest = fetchDestination(nameTree.get(destinationId)); + } + return dest; + }, + + get pageLabels() { + var obj = null; + try { + obj = this.readPageLabels(); + } catch (ex) { + if (ex instanceof MissingDataException) { + throw ex; + } + warn('Unable to read page labels.'); + } + return shadow(this, 'pageLabels', obj); + }, + readPageLabels: function Catalog_readPageLabels() { + var obj = this.catDict.getRaw('PageLabels'); + if (!obj) { + return null; + } + var pageLabels = new Array(this.numPages); + var style = null; + var prefix = ''; + var start = 1; + + var numberTree = new NumberTree(obj, this.xref); + var nums = numberTree.getAll(); + var currentLabel = '', currentIndex = 1; + + for (var i = 0, ii = this.numPages; i < ii; i++) { + if (nums.hasOwnProperty(i)) { + var labelDict = nums[i]; + assert(isDict(labelDict), 'The PageLabel is not a dictionary.'); + + var type = labelDict.get('Type'); + assert(!type || (isName(type) && type.name === 'PageLabel'), + 'Invalid type in PageLabel dictionary.'); + + var s = labelDict.get('S'); + assert(!s || isName(s), 'Invalid style in PageLabel dictionary.'); + style = (s ? s.name : null); + + prefix = labelDict.get('P') || ''; + assert(isString(prefix), 'Invalid prefix in PageLabel dictionary.'); + + start = labelDict.get('St') || 1; + assert(isInt(start), 'Invalid start in PageLabel dictionary.'); + currentIndex = start; + } + + switch (style) { + case 'D': + currentLabel = currentIndex; + break; + case 'R': + case 'r': + currentLabel = Util.toRoman(currentIndex, style === 'r'); + break; + case 'A': + case 'a': + var LIMIT = 26; // Use only the characters A--Z, or a--z. + var A_UPPER_CASE = 0x41, A_LOWER_CASE = 0x61; + + var baseCharCode = (style === 'a' ? A_LOWER_CASE : A_UPPER_CASE); + var letterIndex = currentIndex - 1; + var character = String.fromCharCode(baseCharCode + + (letterIndex % LIMIT)); + var charBuf = []; + for (var j = 0, jj = (letterIndex / LIMIT) | 0; j <= jj; j++) { + charBuf.push(character); + } + currentLabel = charBuf.join(''); + break; + default: + assert(!style, + 'Invalid style "' + style + '" in PageLabel dictionary.'); + } + pageLabels[i] = prefix + currentLabel; + + currentLabel = ''; + currentIndex++; + } + return pageLabels; + }, + + get attachments() { + var xref = this.xref; + var attachments = null, nameTreeRef; + var obj = this.catDict.get('Names'); + if (obj) { + nameTreeRef = obj.getRaw('EmbeddedFiles'); + } + + if (nameTreeRef) { + var nameTree = new NameTree(nameTreeRef, xref); + var names = nameTree.getAll(); + for (var name in names) { + if (!names.hasOwnProperty(name)) { + continue; + } + var fs = new FileSpec(names[name], xref); + if (!attachments) { + attachments = {}; + } + attachments[stringToPDFString(name)] = fs.serializable; + } + } + return shadow(this, 'attachments', attachments); + }, + get javaScript() { + var xref = this.xref; + var obj = this.catDict.get('Names'); + + var javaScript = []; + function appendIfJavaScriptDict(jsDict) { + var type = jsDict.get('S'); + if (!isName(type) || type.name !== 'JavaScript') { + return; + } + var js = jsDict.get('JS'); + if (isStream(js)) { + js = bytesToString(js.getBytes()); + } else if (!isString(js)) { + return; + } + javaScript.push(stringToPDFString(js)); + } + if (obj && obj.has('JavaScript')) { + var nameTree = new NameTree(obj.getRaw('JavaScript'), xref); + var names = nameTree.getAll(); + for (var name in names) { + if (!names.hasOwnProperty(name)) { + continue; + } + // We don't really use the JavaScript right now. This code is + // defensive so we don't cause errors on document load. + var jsDict = names[name]; + if (isDict(jsDict)) { + appendIfJavaScriptDict(jsDict); + } + } + } + + // Append OpenAction actions to javaScript array + var openactionDict = this.catDict.get('OpenAction'); + if (isDict(openactionDict, 'Action')) { + var actionType = openactionDict.get('S'); + if (isName(actionType) && actionType.name === 'Named') { + // The named Print action is not a part of the PDF 1.7 specification, + // but is supported by many PDF readers/writers (including Adobe's). + var action = openactionDict.get('N'); + if (isName(action) && action.name === 'Print') { + javaScript.push('print({});'); + } + } else { + appendIfJavaScriptDict(openactionDict); + } + } + + return shadow(this, 'javaScript', javaScript); + }, + + cleanup: function Catalog_cleanup() { + var promises = []; + this.fontCache.forEach(function (promise) { + promises.push(promise); + }); + return Promise.all(promises).then(function (translatedFonts) { + for (var i = 0, ii = translatedFonts.length; i < ii; i++) { + var font = translatedFonts[i].dict; + delete font.translated; + } + this.fontCache.clear(); + }.bind(this)); + }, + + getPage: function Catalog_getPage(pageIndex) { + if (!(pageIndex in this.pagePromises)) { + this.pagePromises[pageIndex] = this.getPageDict(pageIndex).then( + function (a) { + var dict = a[0]; + var ref = a[1]; + return this.pageFactory.createPage(pageIndex, dict, ref, + this.fontCache); + }.bind(this) + ); + } + return this.pagePromises[pageIndex]; + }, + + getPageDict: function Catalog_getPageDict(pageIndex) { + var capability = createPromiseCapability(); + var nodesToVisit = [this.catDict.getRaw('Pages')]; + var currentPageIndex = 0; + var xref = this.xref; + var checkAllKids = false; + + function next() { + while (nodesToVisit.length) { + var currentNode = nodesToVisit.pop(); + + if (isRef(currentNode)) { + xref.fetchAsync(currentNode).then(function (obj) { + if (isDict(obj, 'Page') || (isDict(obj) && !obj.has('Kids'))) { + if (pageIndex === currentPageIndex) { + capability.resolve([obj, currentNode]); + } else { + currentPageIndex++; + next(); + } + return; + } + nodesToVisit.push(obj); + next(); + }, capability.reject); + return; + } + + // Must be a child page dictionary. + assert( + isDict(currentNode), + 'page dictionary kid reference points to wrong type of object' + ); + var count = currentNode.get('Count'); + // If the current node doesn't have any children, avoid getting stuck + // in an empty node further down in the tree (see issue5644.pdf). + if (count === 0) { + checkAllKids = true; + } + // Skip nodes where the page can't be. + if (currentPageIndex + count <= pageIndex) { + currentPageIndex += count; + continue; + } + + var kids = currentNode.get('Kids'); + assert(isArray(kids), 'page dictionary kids object is not an array'); + if (!checkAllKids && count === kids.length) { + // Nodes that don't have the page have been skipped and this is the + // bottom of the tree which means the page requested must be a + // descendant of this pages node. Ideally we would just resolve the + // promise with the page ref here, but there is the case where more + // pages nodes could link to single a page (see issue 3666 pdf). To + // handle this push it back on the queue so if it is a pages node it + // will be descended into. + nodesToVisit = [kids[pageIndex - currentPageIndex]]; + currentPageIndex = pageIndex; + continue; + } else { + for (var last = kids.length - 1; last >= 0; last--) { + nodesToVisit.push(kids[last]); + } + } + } + capability.reject('Page index ' + pageIndex + ' not found.'); + } + next(); + return capability.promise; + }, + + getPageIndex: function Catalog_getPageIndex(ref) { + // The page tree nodes have the count of all the leaves below them. To get + // how many pages are before we just have to walk up the tree and keep + // adding the count of siblings to the left of the node. + var xref = this.xref; + function pagesBeforeRef(kidRef) { + var total = 0; + var parentRef; + return xref.fetchAsync(kidRef).then(function (node) { + if (!node) { + return null; + } + parentRef = node.getRaw('Parent'); + return node.getAsync('Parent'); + }).then(function (parent) { + if (!parent) { + return null; + } + return parent.getAsync('Kids'); + }).then(function (kids) { + if (!kids) { + return null; + } + var kidPromises = []; + var found = false; + for (var i = 0; i < kids.length; i++) { + var kid = kids[i]; + assert(isRef(kid), 'kids must be a ref'); + if (kid.num === kidRef.num) { + found = true; + break; + } + kidPromises.push(xref.fetchAsync(kid).then(function (kid) { + if (kid.has('Count')) { + var count = kid.get('Count'); + total += count; + } else { // page leaf node + total++; + } + })); + } + if (!found) { + error('kid ref not found in parents kids'); + } + return Promise.all(kidPromises).then(function () { + return [total, parentRef]; + }); + }); + } + + var total = 0; + function next(ref) { + return pagesBeforeRef(ref).then(function (args) { + if (!args) { + return total; + } + var count = args[0]; + var parentRef = args[1]; + total += count; + return next(parentRef); + }); + } + + return next(ref); + } + }; + + return Catalog; +})(); + +var XRef = (function XRefClosure() { + function XRef(stream, password) { + this.stream = stream; + this.entries = []; + this.xrefstms = {}; + // prepare the XRef cache + this.cache = []; + this.password = password; + this.stats = { + streamTypes: [], + fontTypes: [] + }; + } + + XRef.prototype = { + setStartXRef: function XRef_setStartXRef(startXRef) { + // Store the starting positions of xref tables as we process them + // so we can recover from missing data errors + this.startXRefQueue = [startXRef]; + }, + + parse: function XRef_parse(recoveryMode) { + var trailerDict; + if (!recoveryMode) { + trailerDict = this.readXRef(); + } else { + warn('Indexing all PDF objects'); + trailerDict = this.indexObjects(); + } + trailerDict.assignXref(this); + this.trailer = trailerDict; + var encrypt = trailerDict.get('Encrypt'); + if (encrypt) { + var ids = trailerDict.get('ID'); + var fileId = (ids && ids.length) ? ids[0] : ''; + this.encrypt = new CipherTransformFactory(encrypt, fileId, + this.password); + } + + // get the root dictionary (catalog) object + if (!(this.root = trailerDict.get('Root'))) { + error('Invalid root reference'); + } + }, + + processXRefTable: function XRef_processXRefTable(parser) { + if (!('tableState' in this)) { + // Stores state of the table as we process it so we can resume + // from middle of table in case of missing data error + this.tableState = { + entryNum: 0, + streamPos: parser.lexer.stream.pos, + parserBuf1: parser.buf1, + parserBuf2: parser.buf2 + }; + } + + var obj = this.readXRefTable(parser); + + // Sanity check + if (!isCmd(obj, 'trailer')) { + error('Invalid XRef table: could not find trailer dictionary'); + } + // Read trailer dictionary, e.g. + // trailer + // << /Size 22 + // /Root 20R + // /Info 10R + // /ID [ <81b14aafa313db63dbd6f981e49f94f4> ] + // >> + // The parser goes through the entire stream << ... >> and provides + // a getter interface for the key-value table + var dict = parser.getObj(); + + // The pdflib PDF generator can generate a nested trailer dictionary + if (!isDict(dict) && dict.dict) { + dict = dict.dict; + } + if (!isDict(dict)) { + error('Invalid XRef table: could not parse trailer dictionary'); + } + delete this.tableState; + + return dict; + }, + + readXRefTable: function XRef_readXRefTable(parser) { + // Example of cross-reference table: + // xref + // 0 1 <-- subsection header (first obj #, obj count) + // 0000000000 65535 f <-- actual object (offset, generation #, f/n) + // 23 2 <-- subsection header ... and so on ... + // 0000025518 00002 n + // 0000025635 00000 n + // trailer + // ... + + var stream = parser.lexer.stream; + var tableState = this.tableState; + stream.pos = tableState.streamPos; + parser.buf1 = tableState.parserBuf1; + parser.buf2 = tableState.parserBuf2; + + // Outer loop is over subsection headers + var obj; + + while (true) { + if (!('firstEntryNum' in tableState) || !('entryCount' in tableState)) { + if (isCmd(obj = parser.getObj(), 'trailer')) { + break; + } + tableState.firstEntryNum = obj; + tableState.entryCount = parser.getObj(); + } + + var first = tableState.firstEntryNum; + var count = tableState.entryCount; + if (!isInt(first) || !isInt(count)) { + error('Invalid XRef table: wrong types in subsection header'); + } + // Inner loop is over objects themselves + for (var i = tableState.entryNum; i < count; i++) { + tableState.streamPos = stream.pos; + tableState.entryNum = i; + tableState.parserBuf1 = parser.buf1; + tableState.parserBuf2 = parser.buf2; + + var entry = {}; + entry.offset = parser.getObj(); + entry.gen = parser.getObj(); + var type = parser.getObj(); + + if (isCmd(type, 'f')) { + entry.free = true; + } else if (isCmd(type, 'n')) { + entry.uncompressed = true; + } + + // Validate entry obj + if (!isInt(entry.offset) || !isInt(entry.gen) || + !(entry.free || entry.uncompressed)) { + error('Invalid entry in XRef subsection: ' + first + ', ' + count); + } + + if (!this.entries[i + first]) { + this.entries[i + first] = entry; + } + } + + tableState.entryNum = 0; + tableState.streamPos = stream.pos; + tableState.parserBuf1 = parser.buf1; + tableState.parserBuf2 = parser.buf2; + delete tableState.firstEntryNum; + delete tableState.entryCount; + } + + // Per issue 3248: hp scanners generate bad XRef + if (first === 1 && this.entries[1] && this.entries[1].free) { + // shifting the entries + this.entries.shift(); + } + + // Sanity check: as per spec, first object must be free + if (this.entries[0] && !this.entries[0].free) { + error('Invalid XRef table: unexpected first object'); + } + return obj; + }, + + processXRefStream: function XRef_processXRefStream(stream) { + if (!('streamState' in this)) { + // Stores state of the stream as we process it so we can resume + // from middle of stream in case of missing data error + var streamParameters = stream.dict; + var byteWidths = streamParameters.get('W'); + var range = streamParameters.get('Index'); + if (!range) { + range = [0, streamParameters.get('Size')]; + } + + this.streamState = { + entryRanges: range, + byteWidths: byteWidths, + entryNum: 0, + streamPos: stream.pos + }; + } + this.readXRefStream(stream); + delete this.streamState; + + return stream.dict; + }, + + readXRefStream: function XRef_readXRefStream(stream) { + var i, j; + var streamState = this.streamState; + stream.pos = streamState.streamPos; + + var byteWidths = streamState.byteWidths; + var typeFieldWidth = byteWidths[0]; + var offsetFieldWidth = byteWidths[1]; + var generationFieldWidth = byteWidths[2]; + + var entryRanges = streamState.entryRanges; + while (entryRanges.length > 0) { + var first = entryRanges[0]; + var n = entryRanges[1]; + + if (!isInt(first) || !isInt(n)) { + error('Invalid XRef range fields: ' + first + ', ' + n); + } + if (!isInt(typeFieldWidth) || !isInt(offsetFieldWidth) || + !isInt(generationFieldWidth)) { + error('Invalid XRef entry fields length: ' + first + ', ' + n); + } + for (i = streamState.entryNum; i < n; ++i) { + streamState.entryNum = i; + streamState.streamPos = stream.pos; + + var type = 0, offset = 0, generation = 0; + for (j = 0; j < typeFieldWidth; ++j) { + type = (type << 8) | stream.getByte(); + } + // if type field is absent, its default value is 1 + if (typeFieldWidth === 0) { + type = 1; + } + for (j = 0; j < offsetFieldWidth; ++j) { + offset = (offset << 8) | stream.getByte(); + } + for (j = 0; j < generationFieldWidth; ++j) { + generation = (generation << 8) | stream.getByte(); + } + var entry = {}; + entry.offset = offset; + entry.gen = generation; + switch (type) { + case 0: + entry.free = true; + break; + case 1: + entry.uncompressed = true; + break; + case 2: + break; + default: + error('Invalid XRef entry type: ' + type); + } + if (!this.entries[first + i]) { + this.entries[first + i] = entry; + } + } + + streamState.entryNum = 0; + streamState.streamPos = stream.pos; + entryRanges.splice(0, 2); + } + }, + + indexObjects: function XRef_indexObjects() { + // Simple scan through the PDF content to find objects, + // trailers and XRef streams. + var TAB = 0x9, LF = 0xA, CR = 0xD, SPACE = 0x20; + var PERCENT = 0x25, LT = 0x3C; + + function readToken(data, offset) { + var token = '', ch = data[offset]; + while (ch !== LF && ch !== CR && ch !== LT) { + if (++offset >= data.length) { + break; + } + token += String.fromCharCode(ch); + ch = data[offset]; + } + return token; + } + function skipUntil(data, offset, what) { + var length = what.length, dataLength = data.length; + var skipped = 0; + // finding byte sequence + while (offset < dataLength) { + var i = 0; + while (i < length && data[offset + i] === what[i]) { + ++i; + } + if (i >= length) { + break; // sequence found + } + offset++; + skipped++; + } + return skipped; + } + var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/; + var trailerBytes = new Uint8Array([116, 114, 97, 105, 108, 101, 114]); + var startxrefBytes = new Uint8Array([115, 116, 97, 114, 116, 120, 114, + 101, 102]); + var endobjBytes = new Uint8Array([101, 110, 100, 111, 98, 106]); + var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]); + + // Clear out any existing entries, since they may be bogus. + this.entries.length = 0; + + var stream = this.stream; + stream.pos = 0; + var buffer = stream.getBytes(); + var position = stream.start, length = buffer.length; + var trailers = [], xrefStms = []; + while (position < length) { + var ch = buffer[position]; + if (ch === TAB || ch === LF || ch === CR || ch === SPACE) { + ++position; + continue; + } + if (ch === PERCENT) { // %-comment + do { + ++position; + if (position >= length) { + break; + } + ch = buffer[position]; + } while (ch !== LF && ch !== CR); + continue; + } + var token = readToken(buffer, position); + var m; + if (token.indexOf('xref') === 0 && + (token.length === 4 || /\s/.test(token[4]))) { + position += skipUntil(buffer, position, trailerBytes); + trailers.push(position); + position += skipUntil(buffer, position, startxrefBytes); + } else if ((m = objRegExp.exec(token))) { + if (typeof this.entries[m[1]] === 'undefined') { + this.entries[m[1]] = { + offset: position - stream.start, + gen: m[2] | 0, + uncompressed: true + }; + } + var contentLength = skipUntil(buffer, position, endobjBytes) + 7; + var content = buffer.subarray(position, position + contentLength); + + // checking XRef stream suspect + // (it shall have '/XRef' and next char is not a letter) + var xrefTagOffset = skipUntil(content, 0, xrefBytes); + if (xrefTagOffset < contentLength && + content[xrefTagOffset + 5] < 64) { + xrefStms.push(position - stream.start); + this.xrefstms[position - stream.start] = 1; // Avoid recursion + } + + position += contentLength; + } else if (token.indexOf('trailer') === 0 && + (token.length === 7 || /\s/.test(token[7]))) { + trailers.push(position); + position += skipUntil(buffer, position, startxrefBytes); + } else { + position += token.length + 1; + } + } + // reading XRef streams + var i, ii; + for (i = 0, ii = xrefStms.length; i < ii; ++i) { + this.startXRefQueue.push(xrefStms[i]); + this.readXRef(/* recoveryMode */ true); + } + // finding main trailer + var dict; + for (i = 0, ii = trailers.length; i < ii; ++i) { + stream.pos = trailers[i]; + var parser = new Parser(new Lexer(stream), true, this); + var obj = parser.getObj(); + if (!isCmd(obj, 'trailer')) { + continue; + } + // read the trailer dictionary + if (!isDict(dict = parser.getObj())) { + continue; + } + // taking the first one with 'ID' + if (dict.has('ID')) { + return dict; + } + } + // no tailer with 'ID', taking last one (if exists) + if (dict) { + return dict; + } + // nothing helps + // calling error() would reject worker with an UnknownErrorException. + throw new InvalidPDFException('Invalid PDF structure'); + }, + + readXRef: function XRef_readXRef(recoveryMode) { + var stream = this.stream; + + try { + while (this.startXRefQueue.length) { + var startXRef = this.startXRefQueue[0]; + + stream.pos = startXRef + stream.start; + + var parser = new Parser(new Lexer(stream), true, this); + var obj = parser.getObj(); + var dict; + + // Get dictionary + if (isCmd(obj, 'xref')) { + // Parse end-of-file XRef + dict = this.processXRefTable(parser); + if (!this.topDict) { + this.topDict = dict; + } + + // Recursively get other XRefs 'XRefStm', if any + obj = dict.get('XRefStm'); + if (isInt(obj)) { + var pos = obj; + // ignore previously loaded xref streams + // (possible infinite recursion) + if (!(pos in this.xrefstms)) { + this.xrefstms[pos] = 1; + this.startXRefQueue.push(pos); + } + } + } else if (isInt(obj)) { + // Parse in-stream XRef + if (!isInt(parser.getObj()) || + !isCmd(parser.getObj(), 'obj') || + !isStream(obj = parser.getObj())) { + error('Invalid XRef stream'); + } + dict = this.processXRefStream(obj); + if (!this.topDict) { + this.topDict = dict; + } + if (!dict) { + error('Failed to read XRef stream'); + } + } else { + error('Invalid XRef stream header'); + } + + // Recursively get previous dictionary, if any + obj = dict.get('Prev'); + if (isInt(obj)) { + this.startXRefQueue.push(obj); + } else if (isRef(obj)) { + // The spec says Prev must not be a reference, i.e. "/Prev NNN" + // This is a fallback for non-compliant PDFs, i.e. "/Prev NNN 0 R" + this.startXRefQueue.push(obj.num); + } + + this.startXRefQueue.shift(); + } + + return this.topDict; + } catch (e) { + if (e instanceof MissingDataException) { + throw e; + } + info('(while reading XRef): ' + e); + } + + if (recoveryMode) { + return; + } + throw new XRefParseException(); + }, + + getEntry: function XRef_getEntry(i) { + var xrefEntry = this.entries[i]; + if (xrefEntry && !xrefEntry.free && xrefEntry.offset) { + return xrefEntry; + } + return null; + }, + + fetchIfRef: function XRef_fetchIfRef(obj) { + if (!isRef(obj)) { + return obj; + } + return this.fetch(obj); + }, + + fetch: function XRef_fetch(ref, suppressEncryption) { + assert(isRef(ref), 'ref object is not a reference'); + var num = ref.num; + if (num in this.cache) { + var cacheEntry = this.cache[num]; + return cacheEntry; + } + + var xrefEntry = this.getEntry(num); + + // the referenced entry can be free + if (xrefEntry === null) { + return (this.cache[num] = null); + } + + if (xrefEntry.uncompressed) { + xrefEntry = this.fetchUncompressed(ref, xrefEntry, suppressEncryption); + } else { + xrefEntry = this.fetchCompressed(xrefEntry, suppressEncryption); + } + if (isDict(xrefEntry)){ + xrefEntry.objId = ref.toString(); + } else if (isStream(xrefEntry)) { + xrefEntry.dict.objId = ref.toString(); + } + return xrefEntry; + }, + + fetchUncompressed: function XRef_fetchUncompressed(ref, xrefEntry, + suppressEncryption) { + var gen = ref.gen; + var num = ref.num; + if (xrefEntry.gen !== gen) { + error('inconsistent generation in XRef'); + } + var stream = this.stream.makeSubStream(xrefEntry.offset + + this.stream.start); + var parser = new Parser(new Lexer(stream), true, this); + var obj1 = parser.getObj(); + var obj2 = parser.getObj(); + var obj3 = parser.getObj(); + if (!isInt(obj1) || parseInt(obj1, 10) !== num || + !isInt(obj2) || parseInt(obj2, 10) !== gen || + !isCmd(obj3)) { + error('bad XRef entry'); + } + if (!isCmd(obj3, 'obj')) { + // some bad PDFs use "obj1234" and really mean 1234 + if (obj3.cmd.indexOf('obj') === 0) { + num = parseInt(obj3.cmd.substring(3), 10); + if (!isNaN(num)) { + return num; + } + } + error('bad XRef entry'); + } + if (this.encrypt && !suppressEncryption) { + xrefEntry = parser.getObj(this.encrypt.createCipherTransform(num, gen)); + } else { + xrefEntry = parser.getObj(); + } + if (!isStream(xrefEntry)) { + this.cache[num] = xrefEntry; + } + return xrefEntry; + }, + + fetchCompressed: function XRef_fetchCompressed(xrefEntry, + suppressEncryption) { + var tableOffset = xrefEntry.offset; + var stream = this.fetch(new Ref(tableOffset, 0)); + if (!isStream(stream)) { + error('bad ObjStm stream'); + } + var first = stream.dict.get('First'); + var n = stream.dict.get('N'); + if (!isInt(first) || !isInt(n)) { + error('invalid first and n parameters for ObjStm stream'); + } + var parser = new Parser(new Lexer(stream), false, this); + parser.allowStreams = true; + var i, entries = [], num, nums = []; + // read the object numbers to populate cache + for (i = 0; i < n; ++i) { + num = parser.getObj(); + if (!isInt(num)) { + error('invalid object number in the ObjStm stream: ' + num); + } + nums.push(num); + var offset = parser.getObj(); + if (!isInt(offset)) { + error('invalid object offset in the ObjStm stream: ' + offset); + } + } + // read stream objects for cache + for (i = 0; i < n; ++i) { + entries.push(parser.getObj()); + num = nums[i]; + var entry = this.entries[num]; + if (entry && entry.offset === tableOffset && entry.gen === i) { + this.cache[num] = entries[i]; + } + } + xrefEntry = entries[xrefEntry.gen]; + if (xrefEntry === undefined) { + error('bad XRef entry for compressed object'); + } + return xrefEntry; + }, + + fetchIfRefAsync: function XRef_fetchIfRefAsync(obj) { + if (!isRef(obj)) { + return Promise.resolve(obj); + } + return this.fetchAsync(obj); + }, + + fetchAsync: function XRef_fetchAsync(ref, suppressEncryption) { + var streamManager = this.stream.manager; + var xref = this; + return new Promise(function tryFetch(resolve, reject) { + try { + resolve(xref.fetch(ref, suppressEncryption)); + } catch (e) { + if (e instanceof MissingDataException) { + streamManager.requestRange(e.begin, e.end).then(function () { + tryFetch(resolve, reject); + }, reject); + return; + } + reject(e); + } + }); + }, + + getCatalogObj: function XRef_getCatalogObj() { + return this.root; + } + }; + + return XRef; +})(); + +/** + * A NameTree/NumberTree is like a Dict but has some advantageous properties, + * see the specification (7.9.6 and 7.9.7) for additional details. + * TODO: implement all the Dict functions and make this more efficient. + */ +var NameOrNumberTree = (function NameOrNumberTreeClosure() { + function NameOrNumberTree(root, xref) { + throw new Error('Cannot initialize NameOrNumberTree.'); + } + + NameOrNumberTree.prototype = { + getAll: function NameOrNumberTree_getAll() { + var dict = {}; + if (!this.root) { + return dict; + } + var xref = this.xref; + // Reading Name/Number tree. + var processed = new RefSet(); + processed.put(this.root); + var queue = [this.root]; + while (queue.length > 0) { + var i, n; + var obj = xref.fetchIfRef(queue.shift()); + if (!isDict(obj)) { + continue; + } + if (obj.has('Kids')) { + var kids = obj.get('Kids'); + for (i = 0, n = kids.length; i < n; i++) { + var kid = kids[i]; + assert(!processed.has(kid), + 'Duplicate entry in "' + this._type + '" tree.'); + queue.push(kid); + processed.put(kid); + } + continue; + } + var entries = obj.get(this._type); + if (isArray(entries)) { + for (i = 0, n = entries.length; i < n; i += 2) { + dict[xref.fetchIfRef(entries[i])] = xref.fetchIfRef(entries[i + 1]); + } + } + } + return dict; + }, + + get: function NameOrNumberTree_get(key) { + if (!this.root) { + return null; + } + + var xref = this.xref; + var kidsOrEntries = xref.fetchIfRef(this.root); + var loopCount = 0; + var MAX_LEVELS = 10; + var l, r, m; + + // Perform a binary search to quickly find the entry that + // contains the key we are looking for. + while (kidsOrEntries.has('Kids')) { + if (++loopCount > MAX_LEVELS) { + warn('Search depth limit reached for "' + this._type + '" tree.'); + return null; + } + + var kids = kidsOrEntries.get('Kids'); + if (!isArray(kids)) { + return null; + } + + l = 0; + r = kids.length - 1; + while (l <= r) { + m = (l + r) >> 1; + var kid = xref.fetchIfRef(kids[m]); + var limits = kid.get('Limits'); + + if (key < xref.fetchIfRef(limits[0])) { + r = m - 1; + } else if (key > xref.fetchIfRef(limits[1])) { + l = m + 1; + } else { + kidsOrEntries = xref.fetchIfRef(kids[m]); + break; + } + } + if (l > r) { + return null; + } + } + + // If we get here, then we have found the right entry. Now go through the + // entries in the dictionary until we find the key we're looking for. + var entries = kidsOrEntries.get(this._type); + if (isArray(entries)) { + // Perform a binary search to reduce the lookup time. + l = 0; + r = entries.length - 2; + while (l <= r) { + // Check only even indices (0, 2, 4, ...) because the + // odd indices contain the actual data. + m = (l + r) & ~1; + var currentKey = xref.fetchIfRef(entries[m]); + if (key < currentKey) { + r = m - 2; + } else if (key > currentKey) { + l = m + 2; + } else { + return xref.fetchIfRef(entries[m + 1]); + } + } + } + return null; + } + }; + return NameOrNumberTree; +})(); + +var NameTree = (function NameTreeClosure() { + function NameTree(root, xref) { + this.root = root; + this.xref = xref; + this._type = 'Names'; + } + + Util.inherit(NameTree, NameOrNumberTree, {}); + + return NameTree; +})(); + +var NumberTree = (function NumberTreeClosure() { + function NumberTree(root, xref) { + this.root = root; + this.xref = xref; + this._type = 'Nums'; + } + + Util.inherit(NumberTree, NameOrNumberTree, {}); + + return NumberTree; +})(); + +/** + * "A PDF file can refer to the contents of another file by using a File + * Specification (PDF 1.1)", see the spec (7.11) for more details. + * NOTE: Only embedded files are supported (as part of the attachments support) + * TODO: support the 'URL' file system (with caching if !/V), portable + * collections attributes and related files (/RF) + */ +var FileSpec = (function FileSpecClosure() { + function FileSpec(root, xref) { + if (!root || !isDict(root)) { + return; + } + this.xref = xref; + this.root = root; + if (root.has('FS')) { + this.fs = root.get('FS'); + } + this.description = root.has('Desc') ? + stringToPDFString(root.get('Desc')) : + ''; + if (root.has('RF')) { + warn('Related file specifications are not supported'); + } + this.contentAvailable = true; + if (!root.has('EF')) { + this.contentAvailable = false; + warn('Non-embedded file specifications are not supported'); + } + } + + function pickPlatformItem(dict) { + // Look for the filename in this order: + // UF, F, Unix, Mac, DOS + if (dict.has('UF')) { + return dict.get('UF'); + } else if (dict.has('F')) { + return dict.get('F'); + } else if (dict.has('Unix')) { + return dict.get('Unix'); + } else if (dict.has('Mac')) { + return dict.get('Mac'); + } else if (dict.has('DOS')) { + return dict.get('DOS'); + } else { + return null; + } + } + + FileSpec.prototype = { + get filename() { + if (!this._filename && this.root) { + var filename = pickPlatformItem(this.root) || 'unnamed'; + this._filename = stringToPDFString(filename). + replace(/\\\\/g, '\\'). + replace(/\\\//g, '/'). + replace(/\\/g, '/'); + } + return this._filename; + }, + get content() { + if (!this.contentAvailable) { + return null; + } + if (!this.contentRef && this.root) { + this.contentRef = pickPlatformItem(this.root.get('EF')); + } + var content = null; + if (this.contentRef) { + var xref = this.xref; + var fileObj = xref.fetchIfRef(this.contentRef); + if (fileObj && isStream(fileObj)) { + content = fileObj.getBytes(); + } else { + warn('Embedded file specification points to non-existing/invalid ' + + 'content'); + } + } else { + warn('Embedded file specification does not have a content'); + } + return content; + }, + get serializable() { + return { + filename: this.filename, + content: this.content + }; + } + }; + return FileSpec; +})(); + +/** + * A helper for loading missing data in object graphs. It traverses the graph + * depth first and queues up any objects that have missing data. Once it has + * has traversed as many objects that are available it attempts to bundle the + * missing data requests and then resume from the nodes that weren't ready. + * + * NOTE: It provides protection from circular references by keeping track of + * of loaded references. However, you must be careful not to load any graphs + * that have references to the catalog or other pages since that will cause the + * entire PDF document object graph to be traversed. + */ +var ObjectLoader = (function() { + function mayHaveChildren(value) { + return isRef(value) || isDict(value) || isArray(value) || isStream(value); + } + + function addChildren(node, nodesToVisit) { + var value; + if (isDict(node) || isStream(node)) { + var map; + if (isDict(node)) { + map = node.map; + } else { + map = node.dict.map; + } + for (var key in map) { + value = map[key]; + if (mayHaveChildren(value)) { + nodesToVisit.push(value); + } + } + } else if (isArray(node)) { + for (var i = 0, ii = node.length; i < ii; i++) { + value = node[i]; + if (mayHaveChildren(value)) { + nodesToVisit.push(value); + } + } + } + } + + function ObjectLoader(obj, keys, xref) { + this.obj = obj; + this.keys = keys; + this.xref = xref; + this.refSet = null; + this.capability = null; + } + + ObjectLoader.prototype = { + load: function ObjectLoader_load() { + var keys = this.keys; + this.capability = createPromiseCapability(); + // Don't walk the graph if all the data is already loaded. + if (!(this.xref.stream instanceof ChunkedStream) || + this.xref.stream.getMissingChunks().length === 0) { + this.capability.resolve(); + return this.capability.promise; + } + + this.refSet = new RefSet(); + // Setup the initial nodes to visit. + var nodesToVisit = []; + for (var i = 0; i < keys.length; i++) { + nodesToVisit.push(this.obj[keys[i]]); + } + + this._walk(nodesToVisit); + return this.capability.promise; + }, + + _walk: function ObjectLoader_walk(nodesToVisit) { + var nodesToRevisit = []; + var pendingRequests = []; + // DFS walk of the object graph. + while (nodesToVisit.length) { + var currentNode = nodesToVisit.pop(); + + // Only references or chunked streams can cause missing data exceptions. + if (isRef(currentNode)) { + // Skip nodes that have already been visited. + if (this.refSet.has(currentNode)) { + continue; + } + try { + var ref = currentNode; + this.refSet.put(ref); + currentNode = this.xref.fetch(currentNode); + } catch (e) { + if (!(e instanceof MissingDataException)) { + throw e; + } + nodesToRevisit.push(currentNode); + pendingRequests.push({ begin: e.begin, end: e.end }); + } + } + if (currentNode && currentNode.getBaseStreams) { + var baseStreams = currentNode.getBaseStreams(); + var foundMissingData = false; + for (var i = 0; i < baseStreams.length; i++) { + var stream = baseStreams[i]; + if (stream.getMissingChunks && stream.getMissingChunks().length) { + foundMissingData = true; + pendingRequests.push({ + begin: stream.start, + end: stream.end + }); + } + } + if (foundMissingData) { + nodesToRevisit.push(currentNode); + } + } + + addChildren(currentNode, nodesToVisit); + } + + if (pendingRequests.length) { + this.xref.stream.manager.requestRanges(pendingRequests).then( + function pendingRequestCallback() { + nodesToVisit = nodesToRevisit; + for (var i = 0; i < nodesToRevisit.length; i++) { + var node = nodesToRevisit[i]; + // Remove any reference nodes from the currrent refset so they + // aren't skipped when we revist them. + if (isRef(node)) { + this.refSet.remove(node); + } + } + this._walk(nodesToVisit); + }.bind(this), this.capability.reject); + return; + } + // Everything is loaded. + this.refSet = null; + this.capability.resolve(); + } + }; + + return ObjectLoader; +})(); + +exports.Catalog = Catalog; +exports.ObjectLoader = ObjectLoader; +exports.XRef = XRef; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCorePsParser = {}), root.pdfjsSharedUtil, + root.pdfjsCoreParser); + } +}(this, function (exports, sharedUtil, coreParser) { + +var error = sharedUtil.error; +var EOF = coreParser.EOF; +var Lexer = coreParser.Lexer; + +var PostScriptParser = (function PostScriptParserClosure() { + function PostScriptParser(lexer) { + this.lexer = lexer; + this.operators = []; + this.token = null; + this.prev = null; + } + PostScriptParser.prototype = { + nextToken: function PostScriptParser_nextToken() { + this.prev = this.token; + this.token = this.lexer.getToken(); + }, + accept: function PostScriptParser_accept(type) { + if (this.token.type === type) { + this.nextToken(); + return true; + } + return false; + }, + expect: function PostScriptParser_expect(type) { + if (this.accept(type)) { + return true; + } + error('Unexpected symbol: found ' + this.token.type + ' expected ' + + type + '.'); + }, + parse: function PostScriptParser_parse() { + this.nextToken(); + this.expect(PostScriptTokenTypes.LBRACE); + this.parseBlock(); + this.expect(PostScriptTokenTypes.RBRACE); + return this.operators; + }, + parseBlock: function PostScriptParser_parseBlock() { + while (true) { + if (this.accept(PostScriptTokenTypes.NUMBER)) { + this.operators.push(this.prev.value); + } else if (this.accept(PostScriptTokenTypes.OPERATOR)) { + this.operators.push(this.prev.value); + } else if (this.accept(PostScriptTokenTypes.LBRACE)) { + this.parseCondition(); + } else { + return; + } + } + }, + parseCondition: function PostScriptParser_parseCondition() { + // Add two place holders that will be updated later + var conditionLocation = this.operators.length; + this.operators.push(null, null); + + this.parseBlock(); + this.expect(PostScriptTokenTypes.RBRACE); + if (this.accept(PostScriptTokenTypes.IF)) { + // The true block is right after the 'if' so it just falls through on + // true else it jumps and skips the true block. + this.operators[conditionLocation] = this.operators.length; + this.operators[conditionLocation + 1] = 'jz'; + } else if (this.accept(PostScriptTokenTypes.LBRACE)) { + var jumpLocation = this.operators.length; + this.operators.push(null, null); + var endOfTrue = this.operators.length; + this.parseBlock(); + this.expect(PostScriptTokenTypes.RBRACE); + this.expect(PostScriptTokenTypes.IFELSE); + // The jump is added at the end of the true block to skip the false + // block. + this.operators[jumpLocation] = this.operators.length; + this.operators[jumpLocation + 1] = 'j'; + + this.operators[conditionLocation] = endOfTrue; + this.operators[conditionLocation + 1] = 'jz'; + } else { + error('PS Function: error parsing conditional.'); + } + } + }; + return PostScriptParser; +})(); + +var PostScriptTokenTypes = { + LBRACE: 0, + RBRACE: 1, + NUMBER: 2, + OPERATOR: 3, + IF: 4, + IFELSE: 5 +}; + +var PostScriptToken = (function PostScriptTokenClosure() { + function PostScriptToken(type, value) { + this.type = type; + this.value = value; + } + + var opCache = {}; + + PostScriptToken.getOperator = function PostScriptToken_getOperator(op) { + var opValue = opCache[op]; + if (opValue) { + return opValue; + } + return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op); + }; + + PostScriptToken.LBRACE = new PostScriptToken(PostScriptTokenTypes.LBRACE, + '{'); + PostScriptToken.RBRACE = new PostScriptToken(PostScriptTokenTypes.RBRACE, + '}'); + PostScriptToken.IF = new PostScriptToken(PostScriptTokenTypes.IF, 'IF'); + PostScriptToken.IFELSE = new PostScriptToken(PostScriptTokenTypes.IFELSE, + 'IFELSE'); + return PostScriptToken; +})(); + +var PostScriptLexer = (function PostScriptLexerClosure() { + function PostScriptLexer(stream) { + this.stream = stream; + this.nextChar(); + + this.strBuf = []; + } + PostScriptLexer.prototype = { + nextChar: function PostScriptLexer_nextChar() { + return (this.currentChar = this.stream.getByte()); + }, + getToken: function PostScriptLexer_getToken() { + var comment = false; + var ch = this.currentChar; + + // skip comments + while (true) { + if (ch < 0) { + return EOF; + } + + if (comment) { + if (ch === 0x0A || ch === 0x0D) { + comment = false; + } + } else if (ch === 0x25) { // '%' + comment = true; + } else if (!Lexer.isSpace(ch)) { + break; + } + ch = this.nextChar(); + } + switch (ch | 0) { + case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: // '0'-'4' + case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: // '5'-'9' + case 0x2B: case 0x2D: case 0x2E: // '+', '-', '.' + return new PostScriptToken(PostScriptTokenTypes.NUMBER, + this.getNumber()); + case 0x7B: // '{' + this.nextChar(); + return PostScriptToken.LBRACE; + case 0x7D: // '}' + this.nextChar(); + return PostScriptToken.RBRACE; + } + // operator + var strBuf = this.strBuf; + strBuf.length = 0; + strBuf[0] = String.fromCharCode(ch); + + while ((ch = this.nextChar()) >= 0 && // and 'A'-'Z', 'a'-'z' + ((ch >= 0x41 && ch <= 0x5A) || (ch >= 0x61 && ch <= 0x7A))) { + strBuf.push(String.fromCharCode(ch)); + } + var str = strBuf.join(''); + switch (str.toLowerCase()) { + case 'if': + return PostScriptToken.IF; + case 'ifelse': + return PostScriptToken.IFELSE; + default: + return PostScriptToken.getOperator(str); + } + }, + getNumber: function PostScriptLexer_getNumber() { + var ch = this.currentChar; + var strBuf = this.strBuf; + strBuf.length = 0; + strBuf[0] = String.fromCharCode(ch); + + while ((ch = this.nextChar()) >= 0) { + if ((ch >= 0x30 && ch <= 0x39) || // '0'-'9' + ch === 0x2D || ch === 0x2E) { // '-', '.' + strBuf.push(String.fromCharCode(ch)); + } else { + break; + } + } + var value = parseFloat(strBuf.join('')); + if (isNaN(value)) { + error('Invalid floating point number: ' + value); + } + return value; + } + }; + return PostScriptLexer; +})(); + +exports.PostScriptLexer = PostScriptLexer; +exports.PostScriptParser = PostScriptParser; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreFonts = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser, + root.pdfjsCoreCMap, root.pdfjsCoreGlyphList, root.pdfjsCoreCharsets, + root.pdfjsCoreFontRenderer); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser, + coreCMap, coreGlyphList, coreCharsets, coreFontRenderer) { + +var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX; +var FontType = sharedUtil.FontType; +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var bytesToString = sharedUtil.bytesToString; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isInt = sharedUtil.isInt; +var isNum = sharedUtil.isNum; +var readUint32 = sharedUtil.readUint32; +var shadow = sharedUtil.shadow; +var stringToBytes = sharedUtil.stringToBytes; +var string32 = sharedUtil.string32; +var warn = sharedUtil.warn; +var Name = corePrimitives.Name; +var Stream = coreStream.Stream; +var Lexer = coreParser.Lexer; +var CMapFactory = coreCMap.CMapFactory; +var IdentityCMap = coreCMap.IdentityCMap; +var GlyphsUnicode = coreGlyphList.GlyphsUnicode; +var DingbatsGlyphsUnicode = coreGlyphList.DingbatsGlyphsUnicode; +var ISOAdobeCharset = coreCharsets.ISOAdobeCharset; +var ExpertCharset = coreCharsets.ExpertCharset; +var ExpertSubsetCharset = coreCharsets.ExpertSubsetCharset; +var FontRendererFactory = coreFontRenderer.FontRendererFactory; + +// Unicode Private Use Area +var PRIVATE_USE_OFFSET_START = 0xE000; +var PRIVATE_USE_OFFSET_END = 0xF8FF; +var SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = false; + +// PDF Glyph Space Units are one Thousandth of a TextSpace Unit +// except for Type 3 fonts +var PDF_GLYPH_SPACE_UNITS = 1000; + +// Hinting is currently disabled due to unknown problems on windows +// in tracemonkey and various other pdfs with type1 fonts. +var HINTING_ENABLED = false; + +// Accented charactars are not displayed properly on windows, using this flag +// to control analysis of seac charstrings. +var SEAC_ANALYSIS_ENABLED = false; + +// Maximum subroutine call depth of type 2 chartrings. Matches OTS. +var MAX_SUBR_NESTING = 10; + +var FontFlags = { + FixedPitch: 1, + Serif: 2, + Symbolic: 4, + Script: 8, + Nonsymbolic: 32, + Italic: 64, + AllCap: 65536, + SmallCap: 131072, + ForceBold: 262144 +}; + +var Encodings = { + ExpertEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclamsmall', 'Hungarumlautsmall', '', 'dollaroldstyle', + 'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior', + 'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'comma', + 'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle', + 'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', + 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'colon', + 'semicolon', 'commasuperior', 'threequartersemdash', 'periodsuperior', + 'questionsmall', '', 'asuperior', 'bsuperior', 'centsuperior', 'dsuperior', + 'esuperior', '', '', 'isuperior', '', '', 'lsuperior', 'msuperior', + 'nsuperior', 'osuperior', '', '', 'rsuperior', 'ssuperior', 'tsuperior', + '', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', '', + 'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall', + 'Asmall', 'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', + 'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', + 'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', + 'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', + 'onefitted', 'rupiah', 'Tildesmall', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall', + '', '', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall', + 'Caronsmall', '', 'Dotaccentsmall', '', '', 'Macronsmall', '', '', + 'figuredash', 'hypheninferior', '', '', 'Ogoneksmall', 'Ringsmall', + 'Cedillasmall', '', '', '', 'onequarter', 'onehalf', 'threequarters', + 'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths', + 'seveneighths', 'onethird', 'twothirds', '', '', 'zerosuperior', + 'onesuperior', 'twosuperior', 'threesuperior', 'foursuperior', + 'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior', + 'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior', + 'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior', + 'seveninferior', 'eightinferior', 'nineinferior', 'centinferior', + 'dollarinferior', 'periodinferior', 'commainferior', 'Agravesmall', + 'Aacutesmall', 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall', + 'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall', + 'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall', + 'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall', + 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall', + 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall', + 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall', + 'Ydieresissmall'], + MacExpertEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclamsmall', 'Hungarumlautsmall', 'centoldstyle', + 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', 'Acutesmall', + 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader', + 'onedotenleader', 'comma', 'hyphen', 'period', 'fraction', 'zerooldstyle', + 'oneoldstyle', 'twooldstyle', 'threeoldstyle', 'fouroldstyle', + 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', + 'nineoldstyle', 'colon', 'semicolon', '', 'threequartersemdash', '', + 'questionsmall', '', '', '', '', 'Ethsmall', '', '', 'onequarter', + 'onehalf', 'threequarters', 'oneeighth', 'threeeighths', 'fiveeighths', + 'seveneighths', 'onethird', 'twothirds', '', '', '', '', '', '', 'ff', + 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', '', 'parenrightinferior', + 'Circumflexsmall', 'hypheninferior', 'Gravesmall', 'Asmall', 'Bsmall', + 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall', + 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall', + 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', + 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', + 'Tildesmall', '', '', 'asuperior', 'centsuperior', '', '', '', '', + 'Aacutesmall', 'Agravesmall', 'Acircumflexsmall', 'Adieresissmall', + 'Atildesmall', 'Aringsmall', 'Ccedillasmall', 'Eacutesmall', 'Egravesmall', + 'Ecircumflexsmall', 'Edieresissmall', 'Iacutesmall', 'Igravesmall', + 'Icircumflexsmall', 'Idieresissmall', 'Ntildesmall', 'Oacutesmall', + 'Ogravesmall', 'Ocircumflexsmall', 'Odieresissmall', 'Otildesmall', + 'Uacutesmall', 'Ugravesmall', 'Ucircumflexsmall', 'Udieresissmall', '', + 'eightsuperior', 'fourinferior', 'threeinferior', 'sixinferior', + 'eightinferior', 'seveninferior', 'Scaronsmall', '', 'centinferior', + 'twoinferior', '', 'Dieresissmall', '', 'Caronsmall', 'osuperior', + 'fiveinferior', '', 'commainferior', 'periodinferior', 'Yacutesmall', '', + 'dollarinferior', '', 'Thornsmall', '', 'nineinferior', 'zeroinferior', + 'Zcaronsmall', 'AEsmall', 'Oslashsmall', 'questiondownsmall', + 'oneinferior', 'Lslashsmall', '', '', '', '', '', '', 'Cedillasmall', '', + '', '', '', '', 'OEsmall', 'figuredash', 'hyphensuperior', '', '', '', '', + 'exclamdownsmall', '', 'Ydieresissmall', '', 'onesuperior', 'twosuperior', + 'threesuperior', 'foursuperior', 'fivesuperior', 'sixsuperior', + 'sevensuperior', 'ninesuperior', 'zerosuperior', '', 'esuperior', + 'rsuperior', 'tsuperior', '', '', 'isuperior', 'ssuperior', 'dsuperior', + '', '', '', '', '', 'lsuperior', 'Ogoneksmall', 'Brevesmall', + 'Macronsmall', 'bsuperior', 'nsuperior', 'msuperior', 'commasuperior', + 'periodsuperior', 'Dotaccentsmall', 'Ringsmall'], + MacRomanEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', + 'ampersand', 'quotesingle', 'parenleft', 'parenright', 'asterisk', 'plus', + 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', + 'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', + 'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', + 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', + 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', + 'asciicircum', 'underscore', 'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', '', + 'Adieresis', 'Aring', 'Ccedilla', 'Eacute', 'Ntilde', 'Odieresis', + 'Udieresis', 'aacute', 'agrave', 'acircumflex', 'adieresis', 'atilde', + 'aring', 'ccedilla', 'eacute', 'egrave', 'ecircumflex', 'edieresis', + 'iacute', 'igrave', 'icircumflex', 'idieresis', 'ntilde', 'oacute', + 'ograve', 'ocircumflex', 'odieresis', 'otilde', 'uacute', 'ugrave', + 'ucircumflex', 'udieresis', 'dagger', 'degree', 'cent', 'sterling', + 'section', 'bullet', 'paragraph', 'germandbls', 'registered', 'copyright', + 'trademark', 'acute', 'dieresis', 'notequal', 'AE', 'Oslash', 'infinity', + 'plusminus', 'lessequal', 'greaterequal', 'yen', 'mu', 'partialdiff', + 'summation', 'product', 'pi', 'integral', 'ordfeminine', 'ordmasculine', + 'Omega', 'ae', 'oslash', 'questiondown', 'exclamdown', 'logicalnot', + 'radical', 'florin', 'approxequal', 'Delta', 'guillemotleft', + 'guillemotright', 'ellipsis', 'space', 'Agrave', 'Atilde', 'Otilde', 'OE', + 'oe', 'endash', 'emdash', 'quotedblleft', 'quotedblright', 'quoteleft', + 'quoteright', 'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction', + 'currency', 'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl', + 'periodcentered', 'quotesinglbase', 'quotedblbase', 'perthousand', + 'Acircumflex', 'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute', + 'Icircumflex', 'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple', + 'Ograve', 'Uacute', 'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex', + 'tilde', 'macron', 'breve', 'dotaccent', 'ring', 'cedilla', 'hungarumlaut', + 'ogonek', 'caron'], + StandardEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', + 'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus', + 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', + 'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', + 'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', + 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', + 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', + 'asciicircum', 'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', + 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', 'exclamdown', + 'cent', 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency', + 'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft', + 'guilsinglright', 'fi', 'fl', '', 'endash', 'dagger', 'daggerdbl', + 'periodcentered', '', 'paragraph', 'bullet', 'quotesinglbase', + 'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis', + 'perthousand', '', 'questiondown', '', 'grave', 'acute', 'circumflex', + 'tilde', 'macron', 'breve', 'dotaccent', 'dieresis', '', 'ring', 'cedilla', + '', 'hungarumlaut', 'ogonek', 'caron', 'emdash', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', 'AE', '', 'ordfeminine', '', '', + '', '', 'Lslash', 'Oslash', 'OE', 'ordmasculine', '', '', '', '', '', 'ae', + '', '', '', 'dotlessi', '', '', 'lslash', 'oslash', 'oe', 'germandbls'], + WinAnsiEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', + 'ampersand', 'quotesingle', 'parenleft', 'parenright', 'asterisk', 'plus', + 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', + 'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', + 'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', + 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', + 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', + 'asciicircum', 'underscore', 'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', + 'bullet', 'Euro', 'bullet', 'quotesinglbase', 'florin', 'quotedblbase', + 'ellipsis', 'dagger', 'daggerdbl', 'circumflex', 'perthousand', 'Scaron', + 'guilsinglleft', 'OE', 'bullet', 'Zcaron', 'bullet', 'bullet', 'quoteleft', + 'quoteright', 'quotedblleft', 'quotedblright', 'bullet', 'endash', + 'emdash', 'tilde', 'trademark', 'scaron', 'guilsinglright', 'oe', 'bullet', + 'zcaron', 'Ydieresis', 'space', 'exclamdown', 'cent', 'sterling', + 'currency', 'yen', 'brokenbar', 'section', 'dieresis', 'copyright', + 'ordfeminine', 'guillemotleft', 'logicalnot', 'hyphen', 'registered', + 'macron', 'degree', 'plusminus', 'twosuperior', 'threesuperior', 'acute', + 'mu', 'paragraph', 'periodcentered', 'cedilla', 'onesuperior', + 'ordmasculine', 'guillemotright', 'onequarter', 'onehalf', 'threequarters', + 'questiondown', 'Agrave', 'Aacute', 'Acircumflex', 'Atilde', 'Adieresis', + 'Aring', 'AE', 'Ccedilla', 'Egrave', 'Eacute', 'Ecircumflex', 'Edieresis', + 'Igrave', 'Iacute', 'Icircumflex', 'Idieresis', 'Eth', 'Ntilde', 'Ograve', + 'Oacute', 'Ocircumflex', 'Otilde', 'Odieresis', 'multiply', 'Oslash', + 'Ugrave', 'Uacute', 'Ucircumflex', 'Udieresis', 'Yacute', 'Thorn', + 'germandbls', 'agrave', 'aacute', 'acircumflex', 'atilde', 'adieresis', + 'aring', 'ae', 'ccedilla', 'egrave', 'eacute', 'ecircumflex', 'edieresis', + 'igrave', 'iacute', 'icircumflex', 'idieresis', 'eth', 'ntilde', 'ograve', + 'oacute', 'ocircumflex', 'otilde', 'odieresis', 'divide', 'oslash', + 'ugrave', 'uacute', 'ucircumflex', 'udieresis', 'yacute', 'thorn', + 'ydieresis'], + SymbolSetEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'exclam', 'universal', 'numbersign', 'existential', 'percent', + 'ampersand', 'suchthat', 'parenleft', 'parenright', 'asteriskmath', 'plus', + 'comma', 'minus', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four', + 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', + 'equal', 'greater', 'question', 'congruent', 'Alpha', 'Beta', 'Chi', + 'Delta', 'Epsilon', 'Phi', 'Gamma', 'Eta', 'Iota', 'theta1', 'Kappa', + 'Lambda', 'Mu', 'Nu', 'Omicron', 'Pi', 'Theta', 'Rho', 'Sigma', 'Tau', + 'Upsilon', 'sigma1', 'Omega', 'Xi', 'Psi', 'Zeta', 'bracketleft', + 'therefore', 'bracketright', 'perpendicular', 'underscore', 'radicalex', + 'alpha', 'beta', 'chi', 'delta', 'epsilon', 'phi', 'gamma', 'eta', 'iota', + 'phi1', 'kappa', 'lambda', 'mu', 'nu', 'omicron', 'pi', 'theta', 'rho', + 'sigma', 'tau', 'upsilon', 'omega1', 'omega', 'xi', 'psi', 'zeta', + 'braceleft', 'bar', 'braceright', 'similar', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', 'Euro', 'Upsilon1', 'minute', 'lessequal', + 'fraction', 'infinity', 'florin', 'club', 'diamond', 'heart', 'spade', + 'arrowboth', 'arrowleft', 'arrowup', 'arrowright', 'arrowdown', 'degree', + 'plusminus', 'second', 'greaterequal', 'multiply', 'proportional', + 'partialdiff', 'bullet', 'divide', 'notequal', 'equivalence', + 'approxequal', 'ellipsis', 'arrowvertex', 'arrowhorizex', 'carriagereturn', + 'aleph', 'Ifraktur', 'Rfraktur', 'weierstrass', 'circlemultiply', + 'circleplus', 'emptyset', 'intersection', 'union', 'propersuperset', + 'reflexsuperset', 'notsubset', 'propersubset', 'reflexsubset', 'element', + 'notelement', 'angle', 'gradient', 'registerserif', 'copyrightserif', + 'trademarkserif', 'product', 'radical', 'dotmath', 'logicalnot', + 'logicaland', 'logicalor', 'arrowdblboth', 'arrowdblleft', 'arrowdblup', + 'arrowdblright', 'arrowdbldown', 'lozenge', 'angleleft', 'registersans', + 'copyrightsans', 'trademarksans', 'summation', 'parenlefttp', + 'parenleftex', 'parenleftbt', 'bracketlefttp', 'bracketleftex', + 'bracketleftbt', 'bracelefttp', 'braceleftmid', 'braceleftbt', 'braceex', + '', 'angleright', 'integral', 'integraltp', 'integralex', 'integralbt', + 'parenrighttp', 'parenrightex', 'parenrightbt', 'bracketrighttp', + 'bracketrightex', 'bracketrightbt', 'bracerighttp', 'bracerightmid', + 'bracerightbt'], + ZapfDingbatsEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', + 'space', 'a1', 'a2', 'a202', 'a3', 'a4', 'a5', 'a119', 'a118', 'a117', + 'a11', 'a12', 'a13', 'a14', 'a15', 'a16', 'a105', 'a17', 'a18', 'a19', + 'a20', 'a21', 'a22', 'a23', 'a24', 'a25', 'a26', 'a27', 'a28', 'a6', 'a7', + 'a8', 'a9', 'a10', 'a29', 'a30', 'a31', 'a32', 'a33', 'a34', 'a35', 'a36', + 'a37', 'a38', 'a39', 'a40', 'a41', 'a42', 'a43', 'a44', 'a45', 'a46', + 'a47', 'a48', 'a49', 'a50', 'a51', 'a52', 'a53', 'a54', 'a55', 'a56', + 'a57', 'a58', 'a59', 'a60', 'a61', 'a62', 'a63', 'a64', 'a65', 'a66', + 'a67', 'a68', 'a69', 'a70', 'a71', 'a72', 'a73', 'a74', 'a203', 'a75', + 'a204', 'a76', 'a77', 'a78', 'a79', 'a81', 'a82', 'a83', 'a84', 'a97', + 'a98', 'a99', 'a100', '', 'a89', 'a90', 'a93', 'a94', 'a91', 'a92', 'a205', + 'a85', 'a206', 'a86', 'a87', 'a88', 'a95', 'a96', '', '', '', '', '', '', + '', '', '', '', '', '', '', '', '', '', '', '', '', 'a101', 'a102', 'a103', + 'a104', 'a106', 'a107', 'a108', 'a112', 'a111', 'a110', 'a109', 'a120', + 'a121', 'a122', 'a123', 'a124', 'a125', 'a126', 'a127', 'a128', 'a129', + 'a130', 'a131', 'a132', 'a133', 'a134', 'a135', 'a136', 'a137', 'a138', + 'a139', 'a140', 'a141', 'a142', 'a143', 'a144', 'a145', 'a146', 'a147', + 'a148', 'a149', 'a150', 'a151', 'a152', 'a153', 'a154', 'a155', 'a156', + 'a157', 'a158', 'a159', 'a160', 'a161', 'a163', 'a164', 'a196', 'a165', + 'a192', 'a166', 'a167', 'a168', 'a169', 'a170', 'a171', 'a172', 'a173', + 'a162', 'a174', 'a175', 'a176', 'a177', 'a178', 'a179', 'a193', 'a180', + 'a199', 'a181', 'a200', 'a182', '', 'a201', 'a183', 'a184', 'a197', 'a185', + 'a194', 'a198', 'a186', 'a195', 'a187', 'a188', 'a189', 'a190', 'a191'] +}; + +/** + * Hold a map of decoded fonts and of the standard fourteen Type1 + * fonts and their acronyms. + */ +var stdFontMap = { + 'ArialNarrow': 'Helvetica', + 'ArialNarrow-Bold': 'Helvetica-Bold', + 'ArialNarrow-BoldItalic': 'Helvetica-BoldOblique', + 'ArialNarrow-Italic': 'Helvetica-Oblique', + 'ArialBlack': 'Helvetica', + 'ArialBlack-Bold': 'Helvetica-Bold', + 'ArialBlack-BoldItalic': 'Helvetica-BoldOblique', + 'ArialBlack-Italic': 'Helvetica-Oblique', + 'Arial': 'Helvetica', + 'Arial-Bold': 'Helvetica-Bold', + 'Arial-BoldItalic': 'Helvetica-BoldOblique', + 'Arial-Italic': 'Helvetica-Oblique', + 'Arial-BoldItalicMT': 'Helvetica-BoldOblique', + 'Arial-BoldMT': 'Helvetica-Bold', + 'Arial-ItalicMT': 'Helvetica-Oblique', + 'ArialMT': 'Helvetica', + 'Courier-Bold': 'Courier-Bold', + 'Courier-BoldItalic': 'Courier-BoldOblique', + 'Courier-Italic': 'Courier-Oblique', + 'CourierNew': 'Courier', + 'CourierNew-Bold': 'Courier-Bold', + 'CourierNew-BoldItalic': 'Courier-BoldOblique', + 'CourierNew-Italic': 'Courier-Oblique', + 'CourierNewPS-BoldItalicMT': 'Courier-BoldOblique', + 'CourierNewPS-BoldMT': 'Courier-Bold', + 'CourierNewPS-ItalicMT': 'Courier-Oblique', + 'CourierNewPSMT': 'Courier', + 'Helvetica': 'Helvetica', + 'Helvetica-Bold': 'Helvetica-Bold', + 'Helvetica-BoldItalic': 'Helvetica-BoldOblique', + 'Helvetica-BoldOblique': 'Helvetica-BoldOblique', + 'Helvetica-Italic': 'Helvetica-Oblique', + 'Helvetica-Oblique':'Helvetica-Oblique', + 'Symbol-Bold': 'Symbol', + 'Symbol-BoldItalic': 'Symbol', + 'Symbol-Italic': 'Symbol', + 'TimesNewRoman': 'Times-Roman', + 'TimesNewRoman-Bold': 'Times-Bold', + 'TimesNewRoman-BoldItalic': 'Times-BoldItalic', + 'TimesNewRoman-Italic': 'Times-Italic', + 'TimesNewRomanPS': 'Times-Roman', + 'TimesNewRomanPS-Bold': 'Times-Bold', + 'TimesNewRomanPS-BoldItalic': 'Times-BoldItalic', + 'TimesNewRomanPS-BoldItalicMT': 'Times-BoldItalic', + 'TimesNewRomanPS-BoldMT': 'Times-Bold', + 'TimesNewRomanPS-Italic': 'Times-Italic', + 'TimesNewRomanPS-ItalicMT': 'Times-Italic', + 'TimesNewRomanPSMT': 'Times-Roman', + 'TimesNewRomanPSMT-Bold': 'Times-Bold', + 'TimesNewRomanPSMT-BoldItalic': 'Times-BoldItalic', + 'TimesNewRomanPSMT-Italic': 'Times-Italic' +}; + +/** + * Holds the map of the non-standard fonts that might be included as a standard + * fonts without glyph data. + */ +var nonStdFontMap = { + 'CenturyGothic': 'Helvetica', + 'CenturyGothic-Bold': 'Helvetica-Bold', + 'CenturyGothic-BoldItalic': 'Helvetica-BoldOblique', + 'CenturyGothic-Italic': 'Helvetica-Oblique', + 'ComicSansMS': 'Comic Sans MS', + 'ComicSansMS-Bold': 'Comic Sans MS-Bold', + 'ComicSansMS-BoldItalic': 'Comic Sans MS-BoldItalic', + 'ComicSansMS-Italic': 'Comic Sans MS-Italic', + 'LucidaConsole': 'Courier', + 'LucidaConsole-Bold': 'Courier-Bold', + 'LucidaConsole-BoldItalic': 'Courier-BoldOblique', + 'LucidaConsole-Italic': 'Courier-Oblique', + 'MS-Gothic': 'MS Gothic', + 'MS-Gothic-Bold': 'MS Gothic-Bold', + 'MS-Gothic-BoldItalic': 'MS Gothic-BoldItalic', + 'MS-Gothic-Italic': 'MS Gothic-Italic', + 'MS-Mincho': 'MS Mincho', + 'MS-Mincho-Bold': 'MS Mincho-Bold', + 'MS-Mincho-BoldItalic': 'MS Mincho-BoldItalic', + 'MS-Mincho-Italic': 'MS Mincho-Italic', + 'MS-PGothic': 'MS PGothic', + 'MS-PGothic-Bold': 'MS PGothic-Bold', + 'MS-PGothic-BoldItalic': 'MS PGothic-BoldItalic', + 'MS-PGothic-Italic': 'MS PGothic-Italic', + 'MS-PMincho': 'MS PMincho', + 'MS-PMincho-Bold': 'MS PMincho-Bold', + 'MS-PMincho-BoldItalic': 'MS PMincho-BoldItalic', + 'MS-PMincho-Italic': 'MS PMincho-Italic', + 'Wingdings': 'ZapfDingbats' +}; + +var serifFonts = { + 'Adobe Jenson': true, 'Adobe Text': true, 'Albertus': true, + 'Aldus': true, 'Alexandria': true, 'Algerian': true, + 'American Typewriter': true, 'Antiqua': true, 'Apex': true, + 'Arno': true, 'Aster': true, 'Aurora': true, + 'Baskerville': true, 'Bell': true, 'Bembo': true, + 'Bembo Schoolbook': true, 'Benguiat': true, 'Berkeley Old Style': true, + 'Bernhard Modern': true, 'Berthold City': true, 'Bodoni': true, + 'Bauer Bodoni': true, 'Book Antiqua': true, 'Bookman': true, + 'Bordeaux Roman': true, 'Californian FB': true, 'Calisto': true, + 'Calvert': true, 'Capitals': true, 'Cambria': true, + 'Cartier': true, 'Caslon': true, 'Catull': true, + 'Centaur': true, 'Century Old Style': true, 'Century Schoolbook': true, + 'Chaparral': true, 'Charis SIL': true, 'Cheltenham': true, + 'Cholla Slab': true, 'Clarendon': true, 'Clearface': true, + 'Cochin': true, 'Colonna': true, 'Computer Modern': true, + 'Concrete Roman': true, 'Constantia': true, 'Cooper Black': true, + 'Corona': true, 'Ecotype': true, 'Egyptienne': true, + 'Elephant': true, 'Excelsior': true, 'Fairfield': true, + 'FF Scala': true, 'Folkard': true, 'Footlight': true, + 'FreeSerif': true, 'Friz Quadrata': true, 'Garamond': true, + 'Gentium': true, 'Georgia': true, 'Gloucester': true, + 'Goudy Old Style': true, 'Goudy Schoolbook': true, 'Goudy Pro Font': true, + 'Granjon': true, 'Guardian Egyptian': true, 'Heather': true, + 'Hercules': true, 'High Tower Text': true, 'Hiroshige': true, + 'Hoefler Text': true, 'Humana Serif': true, 'Imprint': true, + 'Ionic No. 5': true, 'Janson': true, 'Joanna': true, + 'Korinna': true, 'Lexicon': true, 'Liberation Serif': true, + 'Linux Libertine': true, 'Literaturnaya': true, 'Lucida': true, + 'Lucida Bright': true, 'Melior': true, 'Memphis': true, + 'Miller': true, 'Minion': true, 'Modern': true, + 'Mona Lisa': true, 'Mrs Eaves': true, 'MS Serif': true, + 'Museo Slab': true, 'New York': true, 'Nimbus Roman': true, + 'NPS Rawlinson Roadway': true, 'Palatino': true, 'Perpetua': true, + 'Plantin': true, 'Plantin Schoolbook': true, 'Playbill': true, + 'Poor Richard': true, 'Rawlinson Roadway': true, 'Renault': true, + 'Requiem': true, 'Rockwell': true, 'Roman': true, + 'Rotis Serif': true, 'Sabon': true, 'Scala': true, + 'Seagull': true, 'Sistina': true, 'Souvenir': true, + 'STIX': true, 'Stone Informal': true, 'Stone Serif': true, + 'Sylfaen': true, 'Times': true, 'Trajan': true, + 'Trinité': true, 'Trump Mediaeval': true, 'Utopia': true, + 'Vale Type': true, 'Bitstream Vera': true, 'Vera Serif': true, + 'Versailles': true, 'Wanted': true, 'Weiss': true, + 'Wide Latin': true, 'Windsor': true, 'XITS': true +}; + +var symbolsFonts = { + 'Dingbats': true, 'Symbol': true, 'ZapfDingbats': true +}; + +// Glyph map for well-known standard fonts. Sometimes Ghostscript uses CID fonts +// but does not embed the CID to GID mapping. The mapping is incomplete for all +// glyphs, but common for some set of the standard fonts. +var GlyphMapForStandardFonts = { + '2': 10, '3': 32, '4': 33, '5': 34, '6': 35, '7': 36, '8': 37, '9': 38, + '10': 39, '11': 40, '12': 41, '13': 42, '14': 43, '15': 44, '16': 45, + '17': 46, '18': 47, '19': 48, '20': 49, '21': 50, '22': 51, '23': 52, + '24': 53, '25': 54, '26': 55, '27': 56, '28': 57, '29': 58, '30': 894, + '31': 60, '32': 61, '33': 62, '34': 63, '35': 64, '36': 65, '37': 66, + '38': 67, '39': 68, '40': 69, '41': 70, '42': 71, '43': 72, '44': 73, + '45': 74, '46': 75, '47': 76, '48': 77, '49': 78, '50': 79, '51': 80, + '52': 81, '53': 82, '54': 83, '55': 84, '56': 85, '57': 86, '58': 87, + '59': 88, '60': 89, '61': 90, '62': 91, '63': 92, '64': 93, '65': 94, + '66': 95, '67': 96, '68': 97, '69': 98, '70': 99, '71': 100, '72': 101, + '73': 102, '74': 103, '75': 104, '76': 105, '77': 106, '78': 107, '79': 108, + '80': 109, '81': 110, '82': 111, '83': 112, '84': 113, '85': 114, '86': 115, + '87': 116, '88': 117, '89': 118, '90': 119, '91': 120, '92': 121, '93': 122, + '94': 123, '95': 124, '96': 125, '97': 126, '98': 196, '99': 197, '100': 199, + '101': 201, '102': 209, '103': 214, '104': 220, '105': 225, '106': 224, + '107': 226, '108': 228, '109': 227, '110': 229, '111': 231, '112': 233, + '113': 232, '114': 234, '115': 235, '116': 237, '117': 236, '118': 238, + '119': 239, '120': 241, '121': 243, '122': 242, '123': 244, '124': 246, + '125': 245, '126': 250, '127': 249, '128': 251, '129': 252, '130': 8224, + '131': 176, '132': 162, '133': 163, '134': 167, '135': 8226, '136': 182, + '137': 223, '138': 174, '139': 169, '140': 8482, '141': 180, '142': 168, + '143': 8800, '144': 198, '145': 216, '146': 8734, '147': 177, '148': 8804, + '149': 8805, '150': 165, '151': 181, '152': 8706, '153': 8721, '154': 8719, + '156': 8747, '157': 170, '158': 186, '159': 8486, '160': 230, '161': 248, + '162': 191, '163': 161, '164': 172, '165': 8730, '166': 402, '167': 8776, + '168': 8710, '169': 171, '170': 187, '171': 8230, '210': 218, '223': 711, + '224': 321, '225': 322, '227': 353, '229': 382, '234': 253, '252': 263, + '253': 268, '254': 269, '258': 258, '260': 260, '261': 261, '265': 280, + '266': 281, '268': 283, '269': 313, '275': 323, '276': 324, '278': 328, + '284': 345, '285': 346, '286': 347, '292': 367, '295': 377, '296': 378, + '298': 380, '305': 963, + '306': 964, '307': 966, '308': 8215, '309': 8252, '310': 8319, '311': 8359, + '312': 8592, '313': 8593, '337': 9552, '493': 1039, '494': 1040, '705': 1524, + '706': 8362, '710': 64288, '711': 64298, '759': 1617, '761': 1776, + '763': 1778, '775': 1652, '777': 1764, '778': 1780, '779': 1781, '780': 1782, + '782': 771, '783': 64726, '786': 8363, '788': 8532, '790': 768, '791': 769, + '792': 768, '795': 803, '797': 64336, '798': 64337, '799': 64342, + '800': 64343, '801': 64344, '802': 64345, '803': 64362, '804': 64363, + '805': 64364, '2424': 7821, '2425': 7822, '2426': 7823, '2427': 7824, + '2428': 7825, '2429': 7826, '2430': 7827, '2433': 7682, '2678': 8045, + '2679': 8046, '2830': 1552, '2838': 686, '2840': 751, '2842': 753, + '2843': 754, '2844': 755, '2846': 757, '2856': 767, '2857': 848, '2858': 849, + '2862': 853, '2863': 854, '2864': 855, '2865': 861, '2866': 862, '2906': 7460, + '2908': 7462, '2909': 7463, '2910': 7464, '2912': 7466, '2913': 7467, + '2914': 7468, '2916': 7470, '2917': 7471, '2918': 7472, '2920': 7474, + '2921': 7475, '2922': 7476, '2924': 7478, '2925': 7479, '2926': 7480, + '2928': 7482, '2929': 7483, '2930': 7484, '2932': 7486, '2933': 7487, + '2934': 7488, '2936': 7490, '2937': 7491, '2938': 7492, '2940': 7494, + '2941': 7495, '2942': 7496, '2944': 7498, '2946': 7500, '2948': 7502, + '2950': 7504, '2951': 7505, '2952': 7506, '2954': 7508, '2955': 7509, + '2956': 7510, '2958': 7512, '2959': 7513, '2960': 7514, '2962': 7516, + '2963': 7517, '2964': 7518, '2966': 7520, '2967': 7521, '2968': 7522, + '2970': 7524, '2971': 7525, '2972': 7526, '2974': 7528, '2975': 7529, + '2976': 7530, '2978': 1537, '2979': 1538, '2980': 1539, '2982': 1549, + '2983': 1551, '2984': 1552, '2986': 1554, '2987': 1555, '2988': 1556, + '2990': 1623, '2991': 1624, '2995': 1775, '2999': 1791, '3002': 64290, + '3003': 64291, '3004': 64292, '3006': 64294, '3007': 64295, '3008': 64296, + '3011': 1900, '3014': 8223, '3015': 8244, '3017': 7532, '3018': 7533, + '3019': 7534, '3075': 7590, '3076': 7591, '3079': 7594, '3080': 7595, + '3083': 7598, '3084': 7599, '3087': 7602, '3088': 7603, '3091': 7606, + '3092': 7607, '3095': 7610, '3096': 7611, '3099': 7614, '3100': 7615, + '3103': 7618, '3104': 7619, '3107': 8337, '3108': 8338, '3116': 1884, + '3119': 1885, '3120': 1885, '3123': 1886, '3124': 1886, '3127': 1887, + '3128': 1887, '3131': 1888, '3132': 1888, '3135': 1889, '3136': 1889, + '3139': 1890, '3140': 1890, '3143': 1891, '3144': 1891, '3147': 1892, + '3148': 1892, '3153': 580, '3154': 581, '3157': 584, '3158': 585, '3161': 588, + '3162': 589, '3165': 891, '3166': 892, '3169': 1274, '3170': 1275, + '3173': 1278, '3174': 1279, '3181': 7622, '3182': 7623, '3282': 11799, + '3316': 578, '3379': 42785, '3393': 1159, '3416': 8377 +}; + +// The glyph map for ArialBlack differs slightly from the glyph map used for +// other well-known standard fonts. Hence we use this (incomplete) CID to GID +// mapping to adjust the glyph map for non-embedded ArialBlack fonts. +var SupplementalGlyphMapForArialBlack = { + '227': 322, '264': 261, '291': 346, +}; + +// Some characters, e.g. copyrightserif, are mapped to the private use area and +// might not be displayed using standard fonts. Mapping/hacking well-known chars +// to the similar equivalents in the normal characters range. +var SpecialPUASymbols = { + '63721': 0x00A9, // copyrightsans (0xF8E9) => copyright + '63193': 0x00A9, // copyrightserif (0xF6D9) => copyright + '63720': 0x00AE, // registersans (0xF8E8) => registered + '63194': 0x00AE, // registerserif (0xF6DA) => registered + '63722': 0x2122, // trademarksans (0xF8EA) => trademark + '63195': 0x2122, // trademarkserif (0xF6DB) => trademark + '63729': 0x23A7, // bracelefttp (0xF8F1) + '63730': 0x23A8, // braceleftmid (0xF8F2) + '63731': 0x23A9, // braceleftbt (0xF8F3) + '63740': 0x23AB, // bracerighttp (0xF8FC) + '63741': 0x23AC, // bracerightmid (0xF8FD) + '63742': 0x23AD, // bracerightbt (0xF8FE) + '63726': 0x23A1, // bracketlefttp (0xF8EE) + '63727': 0x23A2, // bracketleftex (0xF8EF) + '63728': 0x23A3, // bracketleftbt (0xF8F0) + '63737': 0x23A4, // bracketrighttp (0xF8F9) + '63738': 0x23A5, // bracketrightex (0xF8FA) + '63739': 0x23A6, // bracketrightbt (0xF8FB) + '63723': 0x239B, // parenlefttp (0xF8EB) + '63724': 0x239C, // parenleftex (0xF8EC) + '63725': 0x239D, // parenleftbt (0xF8ED) + '63734': 0x239E, // parenrighttp (0xF8F6) + '63735': 0x239F, // parenrightex (0xF8F7) + '63736': 0x23A0, // parenrightbt (0xF8F8) +}; +function mapSpecialUnicodeValues(code) { + if (code >= 0xFFF0 && code <= 0xFFFF) { // Specials unicode block. + return 0; + } else if (code >= 0xF600 && code <= 0xF8FF) { + return (SpecialPUASymbols[code] || code); + } + return code; +} + +var UnicodeRanges = [ + { 'begin': 0x0000, 'end': 0x007F }, // Basic Latin + { 'begin': 0x0080, 'end': 0x00FF }, // Latin-1 Supplement + { 'begin': 0x0100, 'end': 0x017F }, // Latin Extended-A + { 'begin': 0x0180, 'end': 0x024F }, // Latin Extended-B + { 'begin': 0x0250, 'end': 0x02AF }, // IPA Extensions + { 'begin': 0x02B0, 'end': 0x02FF }, // Spacing Modifier Letters + { 'begin': 0x0300, 'end': 0x036F }, // Combining Diacritical Marks + { 'begin': 0x0370, 'end': 0x03FF }, // Greek and Coptic + { 'begin': 0x2C80, 'end': 0x2CFF }, // Coptic + { 'begin': 0x0400, 'end': 0x04FF }, // Cyrillic + { 'begin': 0x0530, 'end': 0x058F }, // Armenian + { 'begin': 0x0590, 'end': 0x05FF }, // Hebrew + { 'begin': 0xA500, 'end': 0xA63F }, // Vai + { 'begin': 0x0600, 'end': 0x06FF }, // Arabic + { 'begin': 0x07C0, 'end': 0x07FF }, // NKo + { 'begin': 0x0900, 'end': 0x097F }, // Devanagari + { 'begin': 0x0980, 'end': 0x09FF }, // Bengali + { 'begin': 0x0A00, 'end': 0x0A7F }, // Gurmukhi + { 'begin': 0x0A80, 'end': 0x0AFF }, // Gujarati + { 'begin': 0x0B00, 'end': 0x0B7F }, // Oriya + { 'begin': 0x0B80, 'end': 0x0BFF }, // Tamil + { 'begin': 0x0C00, 'end': 0x0C7F }, // Telugu + { 'begin': 0x0C80, 'end': 0x0CFF }, // Kannada + { 'begin': 0x0D00, 'end': 0x0D7F }, // Malayalam + { 'begin': 0x0E00, 'end': 0x0E7F }, // Thai + { 'begin': 0x0E80, 'end': 0x0EFF }, // Lao + { 'begin': 0x10A0, 'end': 0x10FF }, // Georgian + { 'begin': 0x1B00, 'end': 0x1B7F }, // Balinese + { 'begin': 0x1100, 'end': 0x11FF }, // Hangul Jamo + { 'begin': 0x1E00, 'end': 0x1EFF }, // Latin Extended Additional + { 'begin': 0x1F00, 'end': 0x1FFF }, // Greek Extended + { 'begin': 0x2000, 'end': 0x206F }, // General Punctuation + { 'begin': 0x2070, 'end': 0x209F }, // Superscripts And Subscripts + { 'begin': 0x20A0, 'end': 0x20CF }, // Currency Symbol + { 'begin': 0x20D0, 'end': 0x20FF }, // Combining Diacritical Marks For Symbols + { 'begin': 0x2100, 'end': 0x214F }, // Letterlike Symbols + { 'begin': 0x2150, 'end': 0x218F }, // Number Forms + { 'begin': 0x2190, 'end': 0x21FF }, // Arrows + { 'begin': 0x2200, 'end': 0x22FF }, // Mathematical Operators + { 'begin': 0x2300, 'end': 0x23FF }, // Miscellaneous Technical + { 'begin': 0x2400, 'end': 0x243F }, // Control Pictures + { 'begin': 0x2440, 'end': 0x245F }, // Optical Character Recognition + { 'begin': 0x2460, 'end': 0x24FF }, // Enclosed Alphanumerics + { 'begin': 0x2500, 'end': 0x257F }, // Box Drawing + { 'begin': 0x2580, 'end': 0x259F }, // Block Elements + { 'begin': 0x25A0, 'end': 0x25FF }, // Geometric Shapes + { 'begin': 0x2600, 'end': 0x26FF }, // Miscellaneous Symbols + { 'begin': 0x2700, 'end': 0x27BF }, // Dingbats + { 'begin': 0x3000, 'end': 0x303F }, // CJK Symbols And Punctuation + { 'begin': 0x3040, 'end': 0x309F }, // Hiragana + { 'begin': 0x30A0, 'end': 0x30FF }, // Katakana + { 'begin': 0x3100, 'end': 0x312F }, // Bopomofo + { 'begin': 0x3130, 'end': 0x318F }, // Hangul Compatibility Jamo + { 'begin': 0xA840, 'end': 0xA87F }, // Phags-pa + { 'begin': 0x3200, 'end': 0x32FF }, // Enclosed CJK Letters And Months + { 'begin': 0x3300, 'end': 0x33FF }, // CJK Compatibility + { 'begin': 0xAC00, 'end': 0xD7AF }, // Hangul Syllables + { 'begin': 0xD800, 'end': 0xDFFF }, // Non-Plane 0 * + { 'begin': 0x10900, 'end': 0x1091F }, // Phoenicia + { 'begin': 0x4E00, 'end': 0x9FFF }, // CJK Unified Ideographs + { 'begin': 0xE000, 'end': 0xF8FF }, // Private Use Area (plane 0) + { 'begin': 0x31C0, 'end': 0x31EF }, // CJK Strokes + { 'begin': 0xFB00, 'end': 0xFB4F }, // Alphabetic Presentation Forms + { 'begin': 0xFB50, 'end': 0xFDFF }, // Arabic Presentation Forms-A + { 'begin': 0xFE20, 'end': 0xFE2F }, // Combining Half Marks + { 'begin': 0xFE10, 'end': 0xFE1F }, // Vertical Forms + { 'begin': 0xFE50, 'end': 0xFE6F }, // Small Form Variants + { 'begin': 0xFE70, 'end': 0xFEFF }, // Arabic Presentation Forms-B + { 'begin': 0xFF00, 'end': 0xFFEF }, // Halfwidth And Fullwidth Forms + { 'begin': 0xFFF0, 'end': 0xFFFF }, // Specials + { 'begin': 0x0F00, 'end': 0x0FFF }, // Tibetan + { 'begin': 0x0700, 'end': 0x074F }, // Syriac + { 'begin': 0x0780, 'end': 0x07BF }, // Thaana + { 'begin': 0x0D80, 'end': 0x0DFF }, // Sinhala + { 'begin': 0x1000, 'end': 0x109F }, // Myanmar + { 'begin': 0x1200, 'end': 0x137F }, // Ethiopic + { 'begin': 0x13A0, 'end': 0x13FF }, // Cherokee + { 'begin': 0x1400, 'end': 0x167F }, // Unified Canadian Aboriginal Syllabics + { 'begin': 0x1680, 'end': 0x169F }, // Ogham + { 'begin': 0x16A0, 'end': 0x16FF }, // Runic + { 'begin': 0x1780, 'end': 0x17FF }, // Khmer + { 'begin': 0x1800, 'end': 0x18AF }, // Mongolian + { 'begin': 0x2800, 'end': 0x28FF }, // Braille Patterns + { 'begin': 0xA000, 'end': 0xA48F }, // Yi Syllables + { 'begin': 0x1700, 'end': 0x171F }, // Tagalog + { 'begin': 0x10300, 'end': 0x1032F }, // Old Italic + { 'begin': 0x10330, 'end': 0x1034F }, // Gothic + { 'begin': 0x10400, 'end': 0x1044F }, // Deseret + { 'begin': 0x1D000, 'end': 0x1D0FF }, // Byzantine Musical Symbols + { 'begin': 0x1D400, 'end': 0x1D7FF }, // Mathematical Alphanumeric Symbols + { 'begin': 0xFF000, 'end': 0xFFFFD }, // Private Use (plane 15) + { 'begin': 0xFE00, 'end': 0xFE0F }, // Variation Selectors + { 'begin': 0xE0000, 'end': 0xE007F }, // Tags + { 'begin': 0x1900, 'end': 0x194F }, // Limbu + { 'begin': 0x1950, 'end': 0x197F }, // Tai Le + { 'begin': 0x1980, 'end': 0x19DF }, // New Tai Lue + { 'begin': 0x1A00, 'end': 0x1A1F }, // Buginese + { 'begin': 0x2C00, 'end': 0x2C5F }, // Glagolitic + { 'begin': 0x2D30, 'end': 0x2D7F }, // Tifinagh + { 'begin': 0x4DC0, 'end': 0x4DFF }, // Yijing Hexagram Symbols + { 'begin': 0xA800, 'end': 0xA82F }, // Syloti Nagri + { 'begin': 0x10000, 'end': 0x1007F }, // Linear B Syllabary + { 'begin': 0x10140, 'end': 0x1018F }, // Ancient Greek Numbers + { 'begin': 0x10380, 'end': 0x1039F }, // Ugaritic + { 'begin': 0x103A0, 'end': 0x103DF }, // Old Persian + { 'begin': 0x10450, 'end': 0x1047F }, // Shavian + { 'begin': 0x10480, 'end': 0x104AF }, // Osmanya + { 'begin': 0x10800, 'end': 0x1083F }, // Cypriot Syllabary + { 'begin': 0x10A00, 'end': 0x10A5F }, // Kharoshthi + { 'begin': 0x1D300, 'end': 0x1D35F }, // Tai Xuan Jing Symbols + { 'begin': 0x12000, 'end': 0x123FF }, // Cuneiform + { 'begin': 0x1D360, 'end': 0x1D37F }, // Counting Rod Numerals + { 'begin': 0x1B80, 'end': 0x1BBF }, // Sundanese + { 'begin': 0x1C00, 'end': 0x1C4F }, // Lepcha + { 'begin': 0x1C50, 'end': 0x1C7F }, // Ol Chiki + { 'begin': 0xA880, 'end': 0xA8DF }, // Saurashtra + { 'begin': 0xA900, 'end': 0xA92F }, // Kayah Li + { 'begin': 0xA930, 'end': 0xA95F }, // Rejang + { 'begin': 0xAA00, 'end': 0xAA5F }, // Cham + { 'begin': 0x10190, 'end': 0x101CF }, // Ancient Symbols + { 'begin': 0x101D0, 'end': 0x101FF }, // Phaistos Disc + { 'begin': 0x102A0, 'end': 0x102DF }, // Carian + { 'begin': 0x1F030, 'end': 0x1F09F } // Domino Tiles +]; + +var MacStandardGlyphOrdering = [ + '.notdef', '.null', 'nonmarkingreturn', 'space', 'exclam', 'quotedbl', + 'numbersign', 'dollar', 'percent', 'ampersand', 'quotesingle', 'parenleft', + 'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash', + 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', + 'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question', 'at', + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft', + 'backslash', 'bracketright', 'asciicircum', 'underscore', 'grave', 'a', 'b', + 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', + 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', + 'asciitilde', 'Adieresis', 'Aring', 'Ccedilla', 'Eacute', 'Ntilde', + 'Odieresis', 'Udieresis', 'aacute', 'agrave', 'acircumflex', 'adieresis', + 'atilde', 'aring', 'ccedilla', 'eacute', 'egrave', 'ecircumflex', 'edieresis', + 'iacute', 'igrave', 'icircumflex', 'idieresis', 'ntilde', 'oacute', 'ograve', + 'ocircumflex', 'odieresis', 'otilde', 'uacute', 'ugrave', 'ucircumflex', + 'udieresis', 'dagger', 'degree', 'cent', 'sterling', 'section', 'bullet', + 'paragraph', 'germandbls', 'registered', 'copyright', 'trademark', 'acute', + 'dieresis', 'notequal', 'AE', 'Oslash', 'infinity', 'plusminus', 'lessequal', + 'greaterequal', 'yen', 'mu', 'partialdiff', 'summation', 'product', 'pi', + 'integral', 'ordfeminine', 'ordmasculine', 'Omega', 'ae', 'oslash', + 'questiondown', 'exclamdown', 'logicalnot', 'radical', 'florin', + 'approxequal', 'Delta', 'guillemotleft', 'guillemotright', 'ellipsis', + 'nonbreakingspace', 'Agrave', 'Atilde', 'Otilde', 'OE', 'oe', 'endash', + 'emdash', 'quotedblleft', 'quotedblright', 'quoteleft', 'quoteright', + 'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction', 'currency', + 'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl', 'periodcentered', + 'quotesinglbase', 'quotedblbase', 'perthousand', 'Acircumflex', + 'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute', 'Icircumflex', + 'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple', 'Ograve', 'Uacute', + 'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex', 'tilde', 'macron', + 'breve', 'dotaccent', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron', + 'Lslash', 'lslash', 'Scaron', 'scaron', 'Zcaron', 'zcaron', 'brokenbar', + 'Eth', 'eth', 'Yacute', 'yacute', 'Thorn', 'thorn', 'minus', 'multiply', + 'onesuperior', 'twosuperior', 'threesuperior', 'onehalf', 'onequarter', + 'threequarters', 'franc', 'Gbreve', 'gbreve', 'Idotaccent', 'Scedilla', + 'scedilla', 'Cacute', 'cacute', 'Ccaron', 'ccaron', 'dcroat']; + +function getUnicodeRangeFor(value) { + for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) { + var range = UnicodeRanges[i]; + if (value >= range.begin && value < range.end) { + return i; + } + } + return -1; +} + +function isRTLRangeFor(value) { + var range = UnicodeRanges[13]; + if (value >= range.begin && value < range.end) { + return true; + } + range = UnicodeRanges[11]; + if (value >= range.begin && value < range.end) { + return true; + } + return false; +} + +// The normalization table is obtained by filtering the Unicode characters +// database with entries. +var NormalizedUnicodes = { + '\u00A8': '\u0020\u0308', + '\u00AF': '\u0020\u0304', + '\u00B4': '\u0020\u0301', + '\u00B5': '\u03BC', + '\u00B8': '\u0020\u0327', + '\u0132': '\u0049\u004A', + '\u0133': '\u0069\u006A', + '\u013F': '\u004C\u00B7', + '\u0140': '\u006C\u00B7', + '\u0149': '\u02BC\u006E', + '\u017F': '\u0073', + '\u01C4': '\u0044\u017D', + '\u01C5': '\u0044\u017E', + '\u01C6': '\u0064\u017E', + '\u01C7': '\u004C\u004A', + '\u01C8': '\u004C\u006A', + '\u01C9': '\u006C\u006A', + '\u01CA': '\u004E\u004A', + '\u01CB': '\u004E\u006A', + '\u01CC': '\u006E\u006A', + '\u01F1': '\u0044\u005A', + '\u01F2': '\u0044\u007A', + '\u01F3': '\u0064\u007A', + '\u02D8': '\u0020\u0306', + '\u02D9': '\u0020\u0307', + '\u02DA': '\u0020\u030A', + '\u02DB': '\u0020\u0328', + '\u02DC': '\u0020\u0303', + '\u02DD': '\u0020\u030B', + '\u037A': '\u0020\u0345', + '\u0384': '\u0020\u0301', + '\u03D0': '\u03B2', + '\u03D1': '\u03B8', + '\u03D2': '\u03A5', + '\u03D5': '\u03C6', + '\u03D6': '\u03C0', + '\u03F0': '\u03BA', + '\u03F1': '\u03C1', + '\u03F2': '\u03C2', + '\u03F4': '\u0398', + '\u03F5': '\u03B5', + '\u03F9': '\u03A3', + '\u0587': '\u0565\u0582', + '\u0675': '\u0627\u0674', + '\u0676': '\u0648\u0674', + '\u0677': '\u06C7\u0674', + '\u0678': '\u064A\u0674', + '\u0E33': '\u0E4D\u0E32', + '\u0EB3': '\u0ECD\u0EB2', + '\u0EDC': '\u0EAB\u0E99', + '\u0EDD': '\u0EAB\u0EA1', + '\u0F77': '\u0FB2\u0F81', + '\u0F79': '\u0FB3\u0F81', + '\u1E9A': '\u0061\u02BE', + '\u1FBD': '\u0020\u0313', + '\u1FBF': '\u0020\u0313', + '\u1FC0': '\u0020\u0342', + '\u1FFE': '\u0020\u0314', + '\u2002': '\u0020', + '\u2003': '\u0020', + '\u2004': '\u0020', + '\u2005': '\u0020', + '\u2006': '\u0020', + '\u2008': '\u0020', + '\u2009': '\u0020', + '\u200A': '\u0020', + '\u2017': '\u0020\u0333', + '\u2024': '\u002E', + '\u2025': '\u002E\u002E', + '\u2026': '\u002E\u002E\u002E', + '\u2033': '\u2032\u2032', + '\u2034': '\u2032\u2032\u2032', + '\u2036': '\u2035\u2035', + '\u2037': '\u2035\u2035\u2035', + '\u203C': '\u0021\u0021', + '\u203E': '\u0020\u0305', + '\u2047': '\u003F\u003F', + '\u2048': '\u003F\u0021', + '\u2049': '\u0021\u003F', + '\u2057': '\u2032\u2032\u2032\u2032', + '\u205F': '\u0020', + '\u20A8': '\u0052\u0073', + '\u2100': '\u0061\u002F\u0063', + '\u2101': '\u0061\u002F\u0073', + '\u2103': '\u00B0\u0043', + '\u2105': '\u0063\u002F\u006F', + '\u2106': '\u0063\u002F\u0075', + '\u2107': '\u0190', + '\u2109': '\u00B0\u0046', + '\u2116': '\u004E\u006F', + '\u2121': '\u0054\u0045\u004C', + '\u2135': '\u05D0', + '\u2136': '\u05D1', + '\u2137': '\u05D2', + '\u2138': '\u05D3', + '\u213B': '\u0046\u0041\u0058', + '\u2160': '\u0049', + '\u2161': '\u0049\u0049', + '\u2162': '\u0049\u0049\u0049', + '\u2163': '\u0049\u0056', + '\u2164': '\u0056', + '\u2165': '\u0056\u0049', + '\u2166': '\u0056\u0049\u0049', + '\u2167': '\u0056\u0049\u0049\u0049', + '\u2168': '\u0049\u0058', + '\u2169': '\u0058', + '\u216A': '\u0058\u0049', + '\u216B': '\u0058\u0049\u0049', + '\u216C': '\u004C', + '\u216D': '\u0043', + '\u216E': '\u0044', + '\u216F': '\u004D', + '\u2170': '\u0069', + '\u2171': '\u0069\u0069', + '\u2172': '\u0069\u0069\u0069', + '\u2173': '\u0069\u0076', + '\u2174': '\u0076', + '\u2175': '\u0076\u0069', + '\u2176': '\u0076\u0069\u0069', + '\u2177': '\u0076\u0069\u0069\u0069', + '\u2178': '\u0069\u0078', + '\u2179': '\u0078', + '\u217A': '\u0078\u0069', + '\u217B': '\u0078\u0069\u0069', + '\u217C': '\u006C', + '\u217D': '\u0063', + '\u217E': '\u0064', + '\u217F': '\u006D', + '\u222C': '\u222B\u222B', + '\u222D': '\u222B\u222B\u222B', + '\u222F': '\u222E\u222E', + '\u2230': '\u222E\u222E\u222E', + '\u2474': '\u0028\u0031\u0029', + '\u2475': '\u0028\u0032\u0029', + '\u2476': '\u0028\u0033\u0029', + '\u2477': '\u0028\u0034\u0029', + '\u2478': '\u0028\u0035\u0029', + '\u2479': '\u0028\u0036\u0029', + '\u247A': '\u0028\u0037\u0029', + '\u247B': '\u0028\u0038\u0029', + '\u247C': '\u0028\u0039\u0029', + '\u247D': '\u0028\u0031\u0030\u0029', + '\u247E': '\u0028\u0031\u0031\u0029', + '\u247F': '\u0028\u0031\u0032\u0029', + '\u2480': '\u0028\u0031\u0033\u0029', + '\u2481': '\u0028\u0031\u0034\u0029', + '\u2482': '\u0028\u0031\u0035\u0029', + '\u2483': '\u0028\u0031\u0036\u0029', + '\u2484': '\u0028\u0031\u0037\u0029', + '\u2485': '\u0028\u0031\u0038\u0029', + '\u2486': '\u0028\u0031\u0039\u0029', + '\u2487': '\u0028\u0032\u0030\u0029', + '\u2488': '\u0031\u002E', + '\u2489': '\u0032\u002E', + '\u248A': '\u0033\u002E', + '\u248B': '\u0034\u002E', + '\u248C': '\u0035\u002E', + '\u248D': '\u0036\u002E', + '\u248E': '\u0037\u002E', + '\u248F': '\u0038\u002E', + '\u2490': '\u0039\u002E', + '\u2491': '\u0031\u0030\u002E', + '\u2492': '\u0031\u0031\u002E', + '\u2493': '\u0031\u0032\u002E', + '\u2494': '\u0031\u0033\u002E', + '\u2495': '\u0031\u0034\u002E', + '\u2496': '\u0031\u0035\u002E', + '\u2497': '\u0031\u0036\u002E', + '\u2498': '\u0031\u0037\u002E', + '\u2499': '\u0031\u0038\u002E', + '\u249A': '\u0031\u0039\u002E', + '\u249B': '\u0032\u0030\u002E', + '\u249C': '\u0028\u0061\u0029', + '\u249D': '\u0028\u0062\u0029', + '\u249E': '\u0028\u0063\u0029', + '\u249F': '\u0028\u0064\u0029', + '\u24A0': '\u0028\u0065\u0029', + '\u24A1': '\u0028\u0066\u0029', + '\u24A2': '\u0028\u0067\u0029', + '\u24A3': '\u0028\u0068\u0029', + '\u24A4': '\u0028\u0069\u0029', + '\u24A5': '\u0028\u006A\u0029', + '\u24A6': '\u0028\u006B\u0029', + '\u24A7': '\u0028\u006C\u0029', + '\u24A8': '\u0028\u006D\u0029', + '\u24A9': '\u0028\u006E\u0029', + '\u24AA': '\u0028\u006F\u0029', + '\u24AB': '\u0028\u0070\u0029', + '\u24AC': '\u0028\u0071\u0029', + '\u24AD': '\u0028\u0072\u0029', + '\u24AE': '\u0028\u0073\u0029', + '\u24AF': '\u0028\u0074\u0029', + '\u24B0': '\u0028\u0075\u0029', + '\u24B1': '\u0028\u0076\u0029', + '\u24B2': '\u0028\u0077\u0029', + '\u24B3': '\u0028\u0078\u0029', + '\u24B4': '\u0028\u0079\u0029', + '\u24B5': '\u0028\u007A\u0029', + '\u2A0C': '\u222B\u222B\u222B\u222B', + '\u2A74': '\u003A\u003A\u003D', + '\u2A75': '\u003D\u003D', + '\u2A76': '\u003D\u003D\u003D', + '\u2E9F': '\u6BCD', + '\u2EF3': '\u9F9F', + '\u2F00': '\u4E00', + '\u2F01': '\u4E28', + '\u2F02': '\u4E36', + '\u2F03': '\u4E3F', + '\u2F04': '\u4E59', + '\u2F05': '\u4E85', + '\u2F06': '\u4E8C', + '\u2F07': '\u4EA0', + '\u2F08': '\u4EBA', + '\u2F09': '\u513F', + '\u2F0A': '\u5165', + '\u2F0B': '\u516B', + '\u2F0C': '\u5182', + '\u2F0D': '\u5196', + '\u2F0E': '\u51AB', + '\u2F0F': '\u51E0', + '\u2F10': '\u51F5', + '\u2F11': '\u5200', + '\u2F12': '\u529B', + '\u2F13': '\u52F9', + '\u2F14': '\u5315', + '\u2F15': '\u531A', + '\u2F16': '\u5338', + '\u2F17': '\u5341', + '\u2F18': '\u535C', + '\u2F19': '\u5369', + '\u2F1A': '\u5382', + '\u2F1B': '\u53B6', + '\u2F1C': '\u53C8', + '\u2F1D': '\u53E3', + '\u2F1E': '\u56D7', + '\u2F1F': '\u571F', + '\u2F20': '\u58EB', + '\u2F21': '\u5902', + '\u2F22': '\u590A', + '\u2F23': '\u5915', + '\u2F24': '\u5927', + '\u2F25': '\u5973', + '\u2F26': '\u5B50', + '\u2F27': '\u5B80', + '\u2F28': '\u5BF8', + '\u2F29': '\u5C0F', + '\u2F2A': '\u5C22', + '\u2F2B': '\u5C38', + '\u2F2C': '\u5C6E', + '\u2F2D': '\u5C71', + '\u2F2E': '\u5DDB', + '\u2F2F': '\u5DE5', + '\u2F30': '\u5DF1', + '\u2F31': '\u5DFE', + '\u2F32': '\u5E72', + '\u2F33': '\u5E7A', + '\u2F34': '\u5E7F', + '\u2F35': '\u5EF4', + '\u2F36': '\u5EFE', + '\u2F37': '\u5F0B', + '\u2F38': '\u5F13', + '\u2F39': '\u5F50', + '\u2F3A': '\u5F61', + '\u2F3B': '\u5F73', + '\u2F3C': '\u5FC3', + '\u2F3D': '\u6208', + '\u2F3E': '\u6236', + '\u2F3F': '\u624B', + '\u2F40': '\u652F', + '\u2F41': '\u6534', + '\u2F42': '\u6587', + '\u2F43': '\u6597', + '\u2F44': '\u65A4', + '\u2F45': '\u65B9', + '\u2F46': '\u65E0', + '\u2F47': '\u65E5', + '\u2F48': '\u66F0', + '\u2F49': '\u6708', + '\u2F4A': '\u6728', + '\u2F4B': '\u6B20', + '\u2F4C': '\u6B62', + '\u2F4D': '\u6B79', + '\u2F4E': '\u6BB3', + '\u2F4F': '\u6BCB', + '\u2F50': '\u6BD4', + '\u2F51': '\u6BDB', + '\u2F52': '\u6C0F', + '\u2F53': '\u6C14', + '\u2F54': '\u6C34', + '\u2F55': '\u706B', + '\u2F56': '\u722A', + '\u2F57': '\u7236', + '\u2F58': '\u723B', + '\u2F59': '\u723F', + '\u2F5A': '\u7247', + '\u2F5B': '\u7259', + '\u2F5C': '\u725B', + '\u2F5D': '\u72AC', + '\u2F5E': '\u7384', + '\u2F5F': '\u7389', + '\u2F60': '\u74DC', + '\u2F61': '\u74E6', + '\u2F62': '\u7518', + '\u2F63': '\u751F', + '\u2F64': '\u7528', + '\u2F65': '\u7530', + '\u2F66': '\u758B', + '\u2F67': '\u7592', + '\u2F68': '\u7676', + '\u2F69': '\u767D', + '\u2F6A': '\u76AE', + '\u2F6B': '\u76BF', + '\u2F6C': '\u76EE', + '\u2F6D': '\u77DB', + '\u2F6E': '\u77E2', + '\u2F6F': '\u77F3', + '\u2F70': '\u793A', + '\u2F71': '\u79B8', + '\u2F72': '\u79BE', + '\u2F73': '\u7A74', + '\u2F74': '\u7ACB', + '\u2F75': '\u7AF9', + '\u2F76': '\u7C73', + '\u2F77': '\u7CF8', + '\u2F78': '\u7F36', + '\u2F79': '\u7F51', + '\u2F7A': '\u7F8A', + '\u2F7B': '\u7FBD', + '\u2F7C': '\u8001', + '\u2F7D': '\u800C', + '\u2F7E': '\u8012', + '\u2F7F': '\u8033', + '\u2F80': '\u807F', + '\u2F81': '\u8089', + '\u2F82': '\u81E3', + '\u2F83': '\u81EA', + '\u2F84': '\u81F3', + '\u2F85': '\u81FC', + '\u2F86': '\u820C', + '\u2F87': '\u821B', + '\u2F88': '\u821F', + '\u2F89': '\u826E', + '\u2F8A': '\u8272', + '\u2F8B': '\u8278', + '\u2F8C': '\u864D', + '\u2F8D': '\u866B', + '\u2F8E': '\u8840', + '\u2F8F': '\u884C', + '\u2F90': '\u8863', + '\u2F91': '\u897E', + '\u2F92': '\u898B', + '\u2F93': '\u89D2', + '\u2F94': '\u8A00', + '\u2F95': '\u8C37', + '\u2F96': '\u8C46', + '\u2F97': '\u8C55', + '\u2F98': '\u8C78', + '\u2F99': '\u8C9D', + '\u2F9A': '\u8D64', + '\u2F9B': '\u8D70', + '\u2F9C': '\u8DB3', + '\u2F9D': '\u8EAB', + '\u2F9E': '\u8ECA', + '\u2F9F': '\u8F9B', + '\u2FA0': '\u8FB0', + '\u2FA1': '\u8FB5', + '\u2FA2': '\u9091', + '\u2FA3': '\u9149', + '\u2FA4': '\u91C6', + '\u2FA5': '\u91CC', + '\u2FA6': '\u91D1', + '\u2FA7': '\u9577', + '\u2FA8': '\u9580', + '\u2FA9': '\u961C', + '\u2FAA': '\u96B6', + '\u2FAB': '\u96B9', + '\u2FAC': '\u96E8', + '\u2FAD': '\u9751', + '\u2FAE': '\u975E', + '\u2FAF': '\u9762', + '\u2FB0': '\u9769', + '\u2FB1': '\u97CB', + '\u2FB2': '\u97ED', + '\u2FB3': '\u97F3', + '\u2FB4': '\u9801', + '\u2FB5': '\u98A8', + '\u2FB6': '\u98DB', + '\u2FB7': '\u98DF', + '\u2FB8': '\u9996', + '\u2FB9': '\u9999', + '\u2FBA': '\u99AC', + '\u2FBB': '\u9AA8', + '\u2FBC': '\u9AD8', + '\u2FBD': '\u9ADF', + '\u2FBE': '\u9B25', + '\u2FBF': '\u9B2F', + '\u2FC0': '\u9B32', + '\u2FC1': '\u9B3C', + '\u2FC2': '\u9B5A', + '\u2FC3': '\u9CE5', + '\u2FC4': '\u9E75', + '\u2FC5': '\u9E7F', + '\u2FC6': '\u9EA5', + '\u2FC7': '\u9EBB', + '\u2FC8': '\u9EC3', + '\u2FC9': '\u9ECD', + '\u2FCA': '\u9ED1', + '\u2FCB': '\u9EF9', + '\u2FCC': '\u9EFD', + '\u2FCD': '\u9F0E', + '\u2FCE': '\u9F13', + '\u2FCF': '\u9F20', + '\u2FD0': '\u9F3B', + '\u2FD1': '\u9F4A', + '\u2FD2': '\u9F52', + '\u2FD3': '\u9F8D', + '\u2FD4': '\u9F9C', + '\u2FD5': '\u9FA0', + '\u3036': '\u3012', + '\u3038': '\u5341', + '\u3039': '\u5344', + '\u303A': '\u5345', + '\u309B': '\u0020\u3099', + '\u309C': '\u0020\u309A', + '\u3131': '\u1100', + '\u3132': '\u1101', + '\u3133': '\u11AA', + '\u3134': '\u1102', + '\u3135': '\u11AC', + '\u3136': '\u11AD', + '\u3137': '\u1103', + '\u3138': '\u1104', + '\u3139': '\u1105', + '\u313A': '\u11B0', + '\u313B': '\u11B1', + '\u313C': '\u11B2', + '\u313D': '\u11B3', + '\u313E': '\u11B4', + '\u313F': '\u11B5', + '\u3140': '\u111A', + '\u3141': '\u1106', + '\u3142': '\u1107', + '\u3143': '\u1108', + '\u3144': '\u1121', + '\u3145': '\u1109', + '\u3146': '\u110A', + '\u3147': '\u110B', + '\u3148': '\u110C', + '\u3149': '\u110D', + '\u314A': '\u110E', + '\u314B': '\u110F', + '\u314C': '\u1110', + '\u314D': '\u1111', + '\u314E': '\u1112', + '\u314F': '\u1161', + '\u3150': '\u1162', + '\u3151': '\u1163', + '\u3152': '\u1164', + '\u3153': '\u1165', + '\u3154': '\u1166', + '\u3155': '\u1167', + '\u3156': '\u1168', + '\u3157': '\u1169', + '\u3158': '\u116A', + '\u3159': '\u116B', + '\u315A': '\u116C', + '\u315B': '\u116D', + '\u315C': '\u116E', + '\u315D': '\u116F', + '\u315E': '\u1170', + '\u315F': '\u1171', + '\u3160': '\u1172', + '\u3161': '\u1173', + '\u3162': '\u1174', + '\u3163': '\u1175', + '\u3164': '\u1160', + '\u3165': '\u1114', + '\u3166': '\u1115', + '\u3167': '\u11C7', + '\u3168': '\u11C8', + '\u3169': '\u11CC', + '\u316A': '\u11CE', + '\u316B': '\u11D3', + '\u316C': '\u11D7', + '\u316D': '\u11D9', + '\u316E': '\u111C', + '\u316F': '\u11DD', + '\u3170': '\u11DF', + '\u3171': '\u111D', + '\u3172': '\u111E', + '\u3173': '\u1120', + '\u3174': '\u1122', + '\u3175': '\u1123', + '\u3176': '\u1127', + '\u3177': '\u1129', + '\u3178': '\u112B', + '\u3179': '\u112C', + '\u317A': '\u112D', + '\u317B': '\u112E', + '\u317C': '\u112F', + '\u317D': '\u1132', + '\u317E': '\u1136', + '\u317F': '\u1140', + '\u3180': '\u1147', + '\u3181': '\u114C', + '\u3182': '\u11F1', + '\u3183': '\u11F2', + '\u3184': '\u1157', + '\u3185': '\u1158', + '\u3186': '\u1159', + '\u3187': '\u1184', + '\u3188': '\u1185', + '\u3189': '\u1188', + '\u318A': '\u1191', + '\u318B': '\u1192', + '\u318C': '\u1194', + '\u318D': '\u119E', + '\u318E': '\u11A1', + '\u3200': '\u0028\u1100\u0029', + '\u3201': '\u0028\u1102\u0029', + '\u3202': '\u0028\u1103\u0029', + '\u3203': '\u0028\u1105\u0029', + '\u3204': '\u0028\u1106\u0029', + '\u3205': '\u0028\u1107\u0029', + '\u3206': '\u0028\u1109\u0029', + '\u3207': '\u0028\u110B\u0029', + '\u3208': '\u0028\u110C\u0029', + '\u3209': '\u0028\u110E\u0029', + '\u320A': '\u0028\u110F\u0029', + '\u320B': '\u0028\u1110\u0029', + '\u320C': '\u0028\u1111\u0029', + '\u320D': '\u0028\u1112\u0029', + '\u320E': '\u0028\u1100\u1161\u0029', + '\u320F': '\u0028\u1102\u1161\u0029', + '\u3210': '\u0028\u1103\u1161\u0029', + '\u3211': '\u0028\u1105\u1161\u0029', + '\u3212': '\u0028\u1106\u1161\u0029', + '\u3213': '\u0028\u1107\u1161\u0029', + '\u3214': '\u0028\u1109\u1161\u0029', + '\u3215': '\u0028\u110B\u1161\u0029', + '\u3216': '\u0028\u110C\u1161\u0029', + '\u3217': '\u0028\u110E\u1161\u0029', + '\u3218': '\u0028\u110F\u1161\u0029', + '\u3219': '\u0028\u1110\u1161\u0029', + '\u321A': '\u0028\u1111\u1161\u0029', + '\u321B': '\u0028\u1112\u1161\u0029', + '\u321C': '\u0028\u110C\u116E\u0029', + '\u321D': '\u0028\u110B\u1169\u110C\u1165\u11AB\u0029', + '\u321E': '\u0028\u110B\u1169\u1112\u116E\u0029', + '\u3220': '\u0028\u4E00\u0029', + '\u3221': '\u0028\u4E8C\u0029', + '\u3222': '\u0028\u4E09\u0029', + '\u3223': '\u0028\u56DB\u0029', + '\u3224': '\u0028\u4E94\u0029', + '\u3225': '\u0028\u516D\u0029', + '\u3226': '\u0028\u4E03\u0029', + '\u3227': '\u0028\u516B\u0029', + '\u3228': '\u0028\u4E5D\u0029', + '\u3229': '\u0028\u5341\u0029', + '\u322A': '\u0028\u6708\u0029', + '\u322B': '\u0028\u706B\u0029', + '\u322C': '\u0028\u6C34\u0029', + '\u322D': '\u0028\u6728\u0029', + '\u322E': '\u0028\u91D1\u0029', + '\u322F': '\u0028\u571F\u0029', + '\u3230': '\u0028\u65E5\u0029', + '\u3231': '\u0028\u682A\u0029', + '\u3232': '\u0028\u6709\u0029', + '\u3233': '\u0028\u793E\u0029', + '\u3234': '\u0028\u540D\u0029', + '\u3235': '\u0028\u7279\u0029', + '\u3236': '\u0028\u8CA1\u0029', + '\u3237': '\u0028\u795D\u0029', + '\u3238': '\u0028\u52B4\u0029', + '\u3239': '\u0028\u4EE3\u0029', + '\u323A': '\u0028\u547C\u0029', + '\u323B': '\u0028\u5B66\u0029', + '\u323C': '\u0028\u76E3\u0029', + '\u323D': '\u0028\u4F01\u0029', + '\u323E': '\u0028\u8CC7\u0029', + '\u323F': '\u0028\u5354\u0029', + '\u3240': '\u0028\u796D\u0029', + '\u3241': '\u0028\u4F11\u0029', + '\u3242': '\u0028\u81EA\u0029', + '\u3243': '\u0028\u81F3\u0029', + '\u32C0': '\u0031\u6708', + '\u32C1': '\u0032\u6708', + '\u32C2': '\u0033\u6708', + '\u32C3': '\u0034\u6708', + '\u32C4': '\u0035\u6708', + '\u32C5': '\u0036\u6708', + '\u32C6': '\u0037\u6708', + '\u32C7': '\u0038\u6708', + '\u32C8': '\u0039\u6708', + '\u32C9': '\u0031\u0030\u6708', + '\u32CA': '\u0031\u0031\u6708', + '\u32CB': '\u0031\u0032\u6708', + '\u3358': '\u0030\u70B9', + '\u3359': '\u0031\u70B9', + '\u335A': '\u0032\u70B9', + '\u335B': '\u0033\u70B9', + '\u335C': '\u0034\u70B9', + '\u335D': '\u0035\u70B9', + '\u335E': '\u0036\u70B9', + '\u335F': '\u0037\u70B9', + '\u3360': '\u0038\u70B9', + '\u3361': '\u0039\u70B9', + '\u3362': '\u0031\u0030\u70B9', + '\u3363': '\u0031\u0031\u70B9', + '\u3364': '\u0031\u0032\u70B9', + '\u3365': '\u0031\u0033\u70B9', + '\u3366': '\u0031\u0034\u70B9', + '\u3367': '\u0031\u0035\u70B9', + '\u3368': '\u0031\u0036\u70B9', + '\u3369': '\u0031\u0037\u70B9', + '\u336A': '\u0031\u0038\u70B9', + '\u336B': '\u0031\u0039\u70B9', + '\u336C': '\u0032\u0030\u70B9', + '\u336D': '\u0032\u0031\u70B9', + '\u336E': '\u0032\u0032\u70B9', + '\u336F': '\u0032\u0033\u70B9', + '\u3370': '\u0032\u0034\u70B9', + '\u33E0': '\u0031\u65E5', + '\u33E1': '\u0032\u65E5', + '\u33E2': '\u0033\u65E5', + '\u33E3': '\u0034\u65E5', + '\u33E4': '\u0035\u65E5', + '\u33E5': '\u0036\u65E5', + '\u33E6': '\u0037\u65E5', + '\u33E7': '\u0038\u65E5', + '\u33E8': '\u0039\u65E5', + '\u33E9': '\u0031\u0030\u65E5', + '\u33EA': '\u0031\u0031\u65E5', + '\u33EB': '\u0031\u0032\u65E5', + '\u33EC': '\u0031\u0033\u65E5', + '\u33ED': '\u0031\u0034\u65E5', + '\u33EE': '\u0031\u0035\u65E5', + '\u33EF': '\u0031\u0036\u65E5', + '\u33F0': '\u0031\u0037\u65E5', + '\u33F1': '\u0031\u0038\u65E5', + '\u33F2': '\u0031\u0039\u65E5', + '\u33F3': '\u0032\u0030\u65E5', + '\u33F4': '\u0032\u0031\u65E5', + '\u33F5': '\u0032\u0032\u65E5', + '\u33F6': '\u0032\u0033\u65E5', + '\u33F7': '\u0032\u0034\u65E5', + '\u33F8': '\u0032\u0035\u65E5', + '\u33F9': '\u0032\u0036\u65E5', + '\u33FA': '\u0032\u0037\u65E5', + '\u33FB': '\u0032\u0038\u65E5', + '\u33FC': '\u0032\u0039\u65E5', + '\u33FD': '\u0033\u0030\u65E5', + '\u33FE': '\u0033\u0031\u65E5', + '\uFB00': '\u0066\u0066', + '\uFB01': '\u0066\u0069', + '\uFB02': '\u0066\u006C', + '\uFB03': '\u0066\u0066\u0069', + '\uFB04': '\u0066\u0066\u006C', + '\uFB05': '\u017F\u0074', + '\uFB06': '\u0073\u0074', + '\uFB13': '\u0574\u0576', + '\uFB14': '\u0574\u0565', + '\uFB15': '\u0574\u056B', + '\uFB16': '\u057E\u0576', + '\uFB17': '\u0574\u056D', + '\uFB4F': '\u05D0\u05DC', + '\uFB50': '\u0671', + '\uFB51': '\u0671', + '\uFB52': '\u067B', + '\uFB53': '\u067B', + '\uFB54': '\u067B', + '\uFB55': '\u067B', + '\uFB56': '\u067E', + '\uFB57': '\u067E', + '\uFB58': '\u067E', + '\uFB59': '\u067E', + '\uFB5A': '\u0680', + '\uFB5B': '\u0680', + '\uFB5C': '\u0680', + '\uFB5D': '\u0680', + '\uFB5E': '\u067A', + '\uFB5F': '\u067A', + '\uFB60': '\u067A', + '\uFB61': '\u067A', + '\uFB62': '\u067F', + '\uFB63': '\u067F', + '\uFB64': '\u067F', + '\uFB65': '\u067F', + '\uFB66': '\u0679', + '\uFB67': '\u0679', + '\uFB68': '\u0679', + '\uFB69': '\u0679', + '\uFB6A': '\u06A4', + '\uFB6B': '\u06A4', + '\uFB6C': '\u06A4', + '\uFB6D': '\u06A4', + '\uFB6E': '\u06A6', + '\uFB6F': '\u06A6', + '\uFB70': '\u06A6', + '\uFB71': '\u06A6', + '\uFB72': '\u0684', + '\uFB73': '\u0684', + '\uFB74': '\u0684', + '\uFB75': '\u0684', + '\uFB76': '\u0683', + '\uFB77': '\u0683', + '\uFB78': '\u0683', + '\uFB79': '\u0683', + '\uFB7A': '\u0686', + '\uFB7B': '\u0686', + '\uFB7C': '\u0686', + '\uFB7D': '\u0686', + '\uFB7E': '\u0687', + '\uFB7F': '\u0687', + '\uFB80': '\u0687', + '\uFB81': '\u0687', + '\uFB82': '\u068D', + '\uFB83': '\u068D', + '\uFB84': '\u068C', + '\uFB85': '\u068C', + '\uFB86': '\u068E', + '\uFB87': '\u068E', + '\uFB88': '\u0688', + '\uFB89': '\u0688', + '\uFB8A': '\u0698', + '\uFB8B': '\u0698', + '\uFB8C': '\u0691', + '\uFB8D': '\u0691', + '\uFB8E': '\u06A9', + '\uFB8F': '\u06A9', + '\uFB90': '\u06A9', + '\uFB91': '\u06A9', + '\uFB92': '\u06AF', + '\uFB93': '\u06AF', + '\uFB94': '\u06AF', + '\uFB95': '\u06AF', + '\uFB96': '\u06B3', + '\uFB97': '\u06B3', + '\uFB98': '\u06B3', + '\uFB99': '\u06B3', + '\uFB9A': '\u06B1', + '\uFB9B': '\u06B1', + '\uFB9C': '\u06B1', + '\uFB9D': '\u06B1', + '\uFB9E': '\u06BA', + '\uFB9F': '\u06BA', + '\uFBA0': '\u06BB', + '\uFBA1': '\u06BB', + '\uFBA2': '\u06BB', + '\uFBA3': '\u06BB', + '\uFBA4': '\u06C0', + '\uFBA5': '\u06C0', + '\uFBA6': '\u06C1', + '\uFBA7': '\u06C1', + '\uFBA8': '\u06C1', + '\uFBA9': '\u06C1', + '\uFBAA': '\u06BE', + '\uFBAB': '\u06BE', + '\uFBAC': '\u06BE', + '\uFBAD': '\u06BE', + '\uFBAE': '\u06D2', + '\uFBAF': '\u06D2', + '\uFBB0': '\u06D3', + '\uFBB1': '\u06D3', + '\uFBD3': '\u06AD', + '\uFBD4': '\u06AD', + '\uFBD5': '\u06AD', + '\uFBD6': '\u06AD', + '\uFBD7': '\u06C7', + '\uFBD8': '\u06C7', + '\uFBD9': '\u06C6', + '\uFBDA': '\u06C6', + '\uFBDB': '\u06C8', + '\uFBDC': '\u06C8', + '\uFBDD': '\u0677', + '\uFBDE': '\u06CB', + '\uFBDF': '\u06CB', + '\uFBE0': '\u06C5', + '\uFBE1': '\u06C5', + '\uFBE2': '\u06C9', + '\uFBE3': '\u06C9', + '\uFBE4': '\u06D0', + '\uFBE5': '\u06D0', + '\uFBE6': '\u06D0', + '\uFBE7': '\u06D0', + '\uFBE8': '\u0649', + '\uFBE9': '\u0649', + '\uFBEA': '\u0626\u0627', + '\uFBEB': '\u0626\u0627', + '\uFBEC': '\u0626\u06D5', + '\uFBED': '\u0626\u06D5', + '\uFBEE': '\u0626\u0648', + '\uFBEF': '\u0626\u0648', + '\uFBF0': '\u0626\u06C7', + '\uFBF1': '\u0626\u06C7', + '\uFBF2': '\u0626\u06C6', + '\uFBF3': '\u0626\u06C6', + '\uFBF4': '\u0626\u06C8', + '\uFBF5': '\u0626\u06C8', + '\uFBF6': '\u0626\u06D0', + '\uFBF7': '\u0626\u06D0', + '\uFBF8': '\u0626\u06D0', + '\uFBF9': '\u0626\u0649', + '\uFBFA': '\u0626\u0649', + '\uFBFB': '\u0626\u0649', + '\uFBFC': '\u06CC', + '\uFBFD': '\u06CC', + '\uFBFE': '\u06CC', + '\uFBFF': '\u06CC', + '\uFC00': '\u0626\u062C', + '\uFC01': '\u0626\u062D', + '\uFC02': '\u0626\u0645', + '\uFC03': '\u0626\u0649', + '\uFC04': '\u0626\u064A', + '\uFC05': '\u0628\u062C', + '\uFC06': '\u0628\u062D', + '\uFC07': '\u0628\u062E', + '\uFC08': '\u0628\u0645', + '\uFC09': '\u0628\u0649', + '\uFC0A': '\u0628\u064A', + '\uFC0B': '\u062A\u062C', + '\uFC0C': '\u062A\u062D', + '\uFC0D': '\u062A\u062E', + '\uFC0E': '\u062A\u0645', + '\uFC0F': '\u062A\u0649', + '\uFC10': '\u062A\u064A', + '\uFC11': '\u062B\u062C', + '\uFC12': '\u062B\u0645', + '\uFC13': '\u062B\u0649', + '\uFC14': '\u062B\u064A', + '\uFC15': '\u062C\u062D', + '\uFC16': '\u062C\u0645', + '\uFC17': '\u062D\u062C', + '\uFC18': '\u062D\u0645', + '\uFC19': '\u062E\u062C', + '\uFC1A': '\u062E\u062D', + '\uFC1B': '\u062E\u0645', + '\uFC1C': '\u0633\u062C', + '\uFC1D': '\u0633\u062D', + '\uFC1E': '\u0633\u062E', + '\uFC1F': '\u0633\u0645', + '\uFC20': '\u0635\u062D', + '\uFC21': '\u0635\u0645', + '\uFC22': '\u0636\u062C', + '\uFC23': '\u0636\u062D', + '\uFC24': '\u0636\u062E', + '\uFC25': '\u0636\u0645', + '\uFC26': '\u0637\u062D', + '\uFC27': '\u0637\u0645', + '\uFC28': '\u0638\u0645', + '\uFC29': '\u0639\u062C', + '\uFC2A': '\u0639\u0645', + '\uFC2B': '\u063A\u062C', + '\uFC2C': '\u063A\u0645', + '\uFC2D': '\u0641\u062C', + '\uFC2E': '\u0641\u062D', + '\uFC2F': '\u0641\u062E', + '\uFC30': '\u0641\u0645', + '\uFC31': '\u0641\u0649', + '\uFC32': '\u0641\u064A', + '\uFC33': '\u0642\u062D', + '\uFC34': '\u0642\u0645', + '\uFC35': '\u0642\u0649', + '\uFC36': '\u0642\u064A', + '\uFC37': '\u0643\u0627', + '\uFC38': '\u0643\u062C', + '\uFC39': '\u0643\u062D', + '\uFC3A': '\u0643\u062E', + '\uFC3B': '\u0643\u0644', + '\uFC3C': '\u0643\u0645', + '\uFC3D': '\u0643\u0649', + '\uFC3E': '\u0643\u064A', + '\uFC3F': '\u0644\u062C', + '\uFC40': '\u0644\u062D', + '\uFC41': '\u0644\u062E', + '\uFC42': '\u0644\u0645', + '\uFC43': '\u0644\u0649', + '\uFC44': '\u0644\u064A', + '\uFC45': '\u0645\u062C', + '\uFC46': '\u0645\u062D', + '\uFC47': '\u0645\u062E', + '\uFC48': '\u0645\u0645', + '\uFC49': '\u0645\u0649', + '\uFC4A': '\u0645\u064A', + '\uFC4B': '\u0646\u062C', + '\uFC4C': '\u0646\u062D', + '\uFC4D': '\u0646\u062E', + '\uFC4E': '\u0646\u0645', + '\uFC4F': '\u0646\u0649', + '\uFC50': '\u0646\u064A', + '\uFC51': '\u0647\u062C', + '\uFC52': '\u0647\u0645', + '\uFC53': '\u0647\u0649', + '\uFC54': '\u0647\u064A', + '\uFC55': '\u064A\u062C', + '\uFC56': '\u064A\u062D', + '\uFC57': '\u064A\u062E', + '\uFC58': '\u064A\u0645', + '\uFC59': '\u064A\u0649', + '\uFC5A': '\u064A\u064A', + '\uFC5B': '\u0630\u0670', + '\uFC5C': '\u0631\u0670', + '\uFC5D': '\u0649\u0670', + '\uFC5E': '\u0020\u064C\u0651', + '\uFC5F': '\u0020\u064D\u0651', + '\uFC60': '\u0020\u064E\u0651', + '\uFC61': '\u0020\u064F\u0651', + '\uFC62': '\u0020\u0650\u0651', + '\uFC63': '\u0020\u0651\u0670', + '\uFC64': '\u0626\u0631', + '\uFC65': '\u0626\u0632', + '\uFC66': '\u0626\u0645', + '\uFC67': '\u0626\u0646', + '\uFC68': '\u0626\u0649', + '\uFC69': '\u0626\u064A', + '\uFC6A': '\u0628\u0631', + '\uFC6B': '\u0628\u0632', + '\uFC6C': '\u0628\u0645', + '\uFC6D': '\u0628\u0646', + '\uFC6E': '\u0628\u0649', + '\uFC6F': '\u0628\u064A', + '\uFC70': '\u062A\u0631', + '\uFC71': '\u062A\u0632', + '\uFC72': '\u062A\u0645', + '\uFC73': '\u062A\u0646', + '\uFC74': '\u062A\u0649', + '\uFC75': '\u062A\u064A', + '\uFC76': '\u062B\u0631', + '\uFC77': '\u062B\u0632', + '\uFC78': '\u062B\u0645', + '\uFC79': '\u062B\u0646', + '\uFC7A': '\u062B\u0649', + '\uFC7B': '\u062B\u064A', + '\uFC7C': '\u0641\u0649', + '\uFC7D': '\u0641\u064A', + '\uFC7E': '\u0642\u0649', + '\uFC7F': '\u0642\u064A', + '\uFC80': '\u0643\u0627', + '\uFC81': '\u0643\u0644', + '\uFC82': '\u0643\u0645', + '\uFC83': '\u0643\u0649', + '\uFC84': '\u0643\u064A', + '\uFC85': '\u0644\u0645', + '\uFC86': '\u0644\u0649', + '\uFC87': '\u0644\u064A', + '\uFC88': '\u0645\u0627', + '\uFC89': '\u0645\u0645', + '\uFC8A': '\u0646\u0631', + '\uFC8B': '\u0646\u0632', + '\uFC8C': '\u0646\u0645', + '\uFC8D': '\u0646\u0646', + '\uFC8E': '\u0646\u0649', + '\uFC8F': '\u0646\u064A', + '\uFC90': '\u0649\u0670', + '\uFC91': '\u064A\u0631', + '\uFC92': '\u064A\u0632', + '\uFC93': '\u064A\u0645', + '\uFC94': '\u064A\u0646', + '\uFC95': '\u064A\u0649', + '\uFC96': '\u064A\u064A', + '\uFC97': '\u0626\u062C', + '\uFC98': '\u0626\u062D', + '\uFC99': '\u0626\u062E', + '\uFC9A': '\u0626\u0645', + '\uFC9B': '\u0626\u0647', + '\uFC9C': '\u0628\u062C', + '\uFC9D': '\u0628\u062D', + '\uFC9E': '\u0628\u062E', + '\uFC9F': '\u0628\u0645', + '\uFCA0': '\u0628\u0647', + '\uFCA1': '\u062A\u062C', + '\uFCA2': '\u062A\u062D', + '\uFCA3': '\u062A\u062E', + '\uFCA4': '\u062A\u0645', + '\uFCA5': '\u062A\u0647', + '\uFCA6': '\u062B\u0645', + '\uFCA7': '\u062C\u062D', + '\uFCA8': '\u062C\u0645', + '\uFCA9': '\u062D\u062C', + '\uFCAA': '\u062D\u0645', + '\uFCAB': '\u062E\u062C', + '\uFCAC': '\u062E\u0645', + '\uFCAD': '\u0633\u062C', + '\uFCAE': '\u0633\u062D', + '\uFCAF': '\u0633\u062E', + '\uFCB0': '\u0633\u0645', + '\uFCB1': '\u0635\u062D', + '\uFCB2': '\u0635\u062E', + '\uFCB3': '\u0635\u0645', + '\uFCB4': '\u0636\u062C', + '\uFCB5': '\u0636\u062D', + '\uFCB6': '\u0636\u062E', + '\uFCB7': '\u0636\u0645', + '\uFCB8': '\u0637\u062D', + '\uFCB9': '\u0638\u0645', + '\uFCBA': '\u0639\u062C', + '\uFCBB': '\u0639\u0645', + '\uFCBC': '\u063A\u062C', + '\uFCBD': '\u063A\u0645', + '\uFCBE': '\u0641\u062C', + '\uFCBF': '\u0641\u062D', + '\uFCC0': '\u0641\u062E', + '\uFCC1': '\u0641\u0645', + '\uFCC2': '\u0642\u062D', + '\uFCC3': '\u0642\u0645', + '\uFCC4': '\u0643\u062C', + '\uFCC5': '\u0643\u062D', + '\uFCC6': '\u0643\u062E', + '\uFCC7': '\u0643\u0644', + '\uFCC8': '\u0643\u0645', + '\uFCC9': '\u0644\u062C', + '\uFCCA': '\u0644\u062D', + '\uFCCB': '\u0644\u062E', + '\uFCCC': '\u0644\u0645', + '\uFCCD': '\u0644\u0647', + '\uFCCE': '\u0645\u062C', + '\uFCCF': '\u0645\u062D', + '\uFCD0': '\u0645\u062E', + '\uFCD1': '\u0645\u0645', + '\uFCD2': '\u0646\u062C', + '\uFCD3': '\u0646\u062D', + '\uFCD4': '\u0646\u062E', + '\uFCD5': '\u0646\u0645', + '\uFCD6': '\u0646\u0647', + '\uFCD7': '\u0647\u062C', + '\uFCD8': '\u0647\u0645', + '\uFCD9': '\u0647\u0670', + '\uFCDA': '\u064A\u062C', + '\uFCDB': '\u064A\u062D', + '\uFCDC': '\u064A\u062E', + '\uFCDD': '\u064A\u0645', + '\uFCDE': '\u064A\u0647', + '\uFCDF': '\u0626\u0645', + '\uFCE0': '\u0626\u0647', + '\uFCE1': '\u0628\u0645', + '\uFCE2': '\u0628\u0647', + '\uFCE3': '\u062A\u0645', + '\uFCE4': '\u062A\u0647', + '\uFCE5': '\u062B\u0645', + '\uFCE6': '\u062B\u0647', + '\uFCE7': '\u0633\u0645', + '\uFCE8': '\u0633\u0647', + '\uFCE9': '\u0634\u0645', + '\uFCEA': '\u0634\u0647', + '\uFCEB': '\u0643\u0644', + '\uFCEC': '\u0643\u0645', + '\uFCED': '\u0644\u0645', + '\uFCEE': '\u0646\u0645', + '\uFCEF': '\u0646\u0647', + '\uFCF0': '\u064A\u0645', + '\uFCF1': '\u064A\u0647', + '\uFCF2': '\u0640\u064E\u0651', + '\uFCF3': '\u0640\u064F\u0651', + '\uFCF4': '\u0640\u0650\u0651', + '\uFCF5': '\u0637\u0649', + '\uFCF6': '\u0637\u064A', + '\uFCF7': '\u0639\u0649', + '\uFCF8': '\u0639\u064A', + '\uFCF9': '\u063A\u0649', + '\uFCFA': '\u063A\u064A', + '\uFCFB': '\u0633\u0649', + '\uFCFC': '\u0633\u064A', + '\uFCFD': '\u0634\u0649', + '\uFCFE': '\u0634\u064A', + '\uFCFF': '\u062D\u0649', + '\uFD00': '\u062D\u064A', + '\uFD01': '\u062C\u0649', + '\uFD02': '\u062C\u064A', + '\uFD03': '\u062E\u0649', + '\uFD04': '\u062E\u064A', + '\uFD05': '\u0635\u0649', + '\uFD06': '\u0635\u064A', + '\uFD07': '\u0636\u0649', + '\uFD08': '\u0636\u064A', + '\uFD09': '\u0634\u062C', + '\uFD0A': '\u0634\u062D', + '\uFD0B': '\u0634\u062E', + '\uFD0C': '\u0634\u0645', + '\uFD0D': '\u0634\u0631', + '\uFD0E': '\u0633\u0631', + '\uFD0F': '\u0635\u0631', + '\uFD10': '\u0636\u0631', + '\uFD11': '\u0637\u0649', + '\uFD12': '\u0637\u064A', + '\uFD13': '\u0639\u0649', + '\uFD14': '\u0639\u064A', + '\uFD15': '\u063A\u0649', + '\uFD16': '\u063A\u064A', + '\uFD17': '\u0633\u0649', + '\uFD18': '\u0633\u064A', + '\uFD19': '\u0634\u0649', + '\uFD1A': '\u0634\u064A', + '\uFD1B': '\u062D\u0649', + '\uFD1C': '\u062D\u064A', + '\uFD1D': '\u062C\u0649', + '\uFD1E': '\u062C\u064A', + '\uFD1F': '\u062E\u0649', + '\uFD20': '\u062E\u064A', + '\uFD21': '\u0635\u0649', + '\uFD22': '\u0635\u064A', + '\uFD23': '\u0636\u0649', + '\uFD24': '\u0636\u064A', + '\uFD25': '\u0634\u062C', + '\uFD26': '\u0634\u062D', + '\uFD27': '\u0634\u062E', + '\uFD28': '\u0634\u0645', + '\uFD29': '\u0634\u0631', + '\uFD2A': '\u0633\u0631', + '\uFD2B': '\u0635\u0631', + '\uFD2C': '\u0636\u0631', + '\uFD2D': '\u0634\u062C', + '\uFD2E': '\u0634\u062D', + '\uFD2F': '\u0634\u062E', + '\uFD30': '\u0634\u0645', + '\uFD31': '\u0633\u0647', + '\uFD32': '\u0634\u0647', + '\uFD33': '\u0637\u0645', + '\uFD34': '\u0633\u062C', + '\uFD35': '\u0633\u062D', + '\uFD36': '\u0633\u062E', + '\uFD37': '\u0634\u062C', + '\uFD38': '\u0634\u062D', + '\uFD39': '\u0634\u062E', + '\uFD3A': '\u0637\u0645', + '\uFD3B': '\u0638\u0645', + '\uFD3C': '\u0627\u064B', + '\uFD3D': '\u0627\u064B', + '\uFD50': '\u062A\u062C\u0645', + '\uFD51': '\u062A\u062D\u062C', + '\uFD52': '\u062A\u062D\u062C', + '\uFD53': '\u062A\u062D\u0645', + '\uFD54': '\u062A\u062E\u0645', + '\uFD55': '\u062A\u0645\u062C', + '\uFD56': '\u062A\u0645\u062D', + '\uFD57': '\u062A\u0645\u062E', + '\uFD58': '\u062C\u0645\u062D', + '\uFD59': '\u062C\u0645\u062D', + '\uFD5A': '\u062D\u0645\u064A', + '\uFD5B': '\u062D\u0645\u0649', + '\uFD5C': '\u0633\u062D\u062C', + '\uFD5D': '\u0633\u062C\u062D', + '\uFD5E': '\u0633\u062C\u0649', + '\uFD5F': '\u0633\u0645\u062D', + '\uFD60': '\u0633\u0645\u062D', + '\uFD61': '\u0633\u0645\u062C', + '\uFD62': '\u0633\u0645\u0645', + '\uFD63': '\u0633\u0645\u0645', + '\uFD64': '\u0635\u062D\u062D', + '\uFD65': '\u0635\u062D\u062D', + '\uFD66': '\u0635\u0645\u0645', + '\uFD67': '\u0634\u062D\u0645', + '\uFD68': '\u0634\u062D\u0645', + '\uFD69': '\u0634\u062C\u064A', + '\uFD6A': '\u0634\u0645\u062E', + '\uFD6B': '\u0634\u0645\u062E', + '\uFD6C': '\u0634\u0645\u0645', + '\uFD6D': '\u0634\u0645\u0645', + '\uFD6E': '\u0636\u062D\u0649', + '\uFD6F': '\u0636\u062E\u0645', + '\uFD70': '\u0636\u062E\u0645', + '\uFD71': '\u0637\u0645\u062D', + '\uFD72': '\u0637\u0645\u062D', + '\uFD73': '\u0637\u0645\u0645', + '\uFD74': '\u0637\u0645\u064A', + '\uFD75': '\u0639\u062C\u0645', + '\uFD76': '\u0639\u0645\u0645', + '\uFD77': '\u0639\u0645\u0645', + '\uFD78': '\u0639\u0645\u0649', + '\uFD79': '\u063A\u0645\u0645', + '\uFD7A': '\u063A\u0645\u064A', + '\uFD7B': '\u063A\u0645\u0649', + '\uFD7C': '\u0641\u062E\u0645', + '\uFD7D': '\u0641\u062E\u0645', + '\uFD7E': '\u0642\u0645\u062D', + '\uFD7F': '\u0642\u0645\u0645', + '\uFD80': '\u0644\u062D\u0645', + '\uFD81': '\u0644\u062D\u064A', + '\uFD82': '\u0644\u062D\u0649', + '\uFD83': '\u0644\u062C\u062C', + '\uFD84': '\u0644\u062C\u062C', + '\uFD85': '\u0644\u062E\u0645', + '\uFD86': '\u0644\u062E\u0645', + '\uFD87': '\u0644\u0645\u062D', + '\uFD88': '\u0644\u0645\u062D', + '\uFD89': '\u0645\u062D\u062C', + '\uFD8A': '\u0645\u062D\u0645', + '\uFD8B': '\u0645\u062D\u064A', + '\uFD8C': '\u0645\u062C\u062D', + '\uFD8D': '\u0645\u062C\u0645', + '\uFD8E': '\u0645\u062E\u062C', + '\uFD8F': '\u0645\u062E\u0645', + '\uFD92': '\u0645\u062C\u062E', + '\uFD93': '\u0647\u0645\u062C', + '\uFD94': '\u0647\u0645\u0645', + '\uFD95': '\u0646\u062D\u0645', + '\uFD96': '\u0646\u062D\u0649', + '\uFD97': '\u0646\u062C\u0645', + '\uFD98': '\u0646\u062C\u0645', + '\uFD99': '\u0646\u062C\u0649', + '\uFD9A': '\u0646\u0645\u064A', + '\uFD9B': '\u0646\u0645\u0649', + '\uFD9C': '\u064A\u0645\u0645', + '\uFD9D': '\u064A\u0645\u0645', + '\uFD9E': '\u0628\u062E\u064A', + '\uFD9F': '\u062A\u062C\u064A', + '\uFDA0': '\u062A\u062C\u0649', + '\uFDA1': '\u062A\u062E\u064A', + '\uFDA2': '\u062A\u062E\u0649', + '\uFDA3': '\u062A\u0645\u064A', + '\uFDA4': '\u062A\u0645\u0649', + '\uFDA5': '\u062C\u0645\u064A', + '\uFDA6': '\u062C\u062D\u0649', + '\uFDA7': '\u062C\u0645\u0649', + '\uFDA8': '\u0633\u062E\u0649', + '\uFDA9': '\u0635\u062D\u064A', + '\uFDAA': '\u0634\u062D\u064A', + '\uFDAB': '\u0636\u062D\u064A', + '\uFDAC': '\u0644\u062C\u064A', + '\uFDAD': '\u0644\u0645\u064A', + '\uFDAE': '\u064A\u062D\u064A', + '\uFDAF': '\u064A\u062C\u064A', + '\uFDB0': '\u064A\u0645\u064A', + '\uFDB1': '\u0645\u0645\u064A', + '\uFDB2': '\u0642\u0645\u064A', + '\uFDB3': '\u0646\u062D\u064A', + '\uFDB4': '\u0642\u0645\u062D', + '\uFDB5': '\u0644\u062D\u0645', + '\uFDB6': '\u0639\u0645\u064A', + '\uFDB7': '\u0643\u0645\u064A', + '\uFDB8': '\u0646\u062C\u062D', + '\uFDB9': '\u0645\u062E\u064A', + '\uFDBA': '\u0644\u062C\u0645', + '\uFDBB': '\u0643\u0645\u0645', + '\uFDBC': '\u0644\u062C\u0645', + '\uFDBD': '\u0646\u062C\u062D', + '\uFDBE': '\u062C\u062D\u064A', + '\uFDBF': '\u062D\u062C\u064A', + '\uFDC0': '\u0645\u062C\u064A', + '\uFDC1': '\u0641\u0645\u064A', + '\uFDC2': '\u0628\u062D\u064A', + '\uFDC3': '\u0643\u0645\u0645', + '\uFDC4': '\u0639\u062C\u0645', + '\uFDC5': '\u0635\u0645\u0645', + '\uFDC6': '\u0633\u062E\u064A', + '\uFDC7': '\u0646\u062C\u064A', + '\uFE49': '\u203E', + '\uFE4A': '\u203E', + '\uFE4B': '\u203E', + '\uFE4C': '\u203E', + '\uFE4D': '\u005F', + '\uFE4E': '\u005F', + '\uFE4F': '\u005F', + '\uFE80': '\u0621', + '\uFE81': '\u0622', + '\uFE82': '\u0622', + '\uFE83': '\u0623', + '\uFE84': '\u0623', + '\uFE85': '\u0624', + '\uFE86': '\u0624', + '\uFE87': '\u0625', + '\uFE88': '\u0625', + '\uFE89': '\u0626', + '\uFE8A': '\u0626', + '\uFE8B': '\u0626', + '\uFE8C': '\u0626', + '\uFE8D': '\u0627', + '\uFE8E': '\u0627', + '\uFE8F': '\u0628', + '\uFE90': '\u0628', + '\uFE91': '\u0628', + '\uFE92': '\u0628', + '\uFE93': '\u0629', + '\uFE94': '\u0629', + '\uFE95': '\u062A', + '\uFE96': '\u062A', + '\uFE97': '\u062A', + '\uFE98': '\u062A', + '\uFE99': '\u062B', + '\uFE9A': '\u062B', + '\uFE9B': '\u062B', + '\uFE9C': '\u062B', + '\uFE9D': '\u062C', + '\uFE9E': '\u062C', + '\uFE9F': '\u062C', + '\uFEA0': '\u062C', + '\uFEA1': '\u062D', + '\uFEA2': '\u062D', + '\uFEA3': '\u062D', + '\uFEA4': '\u062D', + '\uFEA5': '\u062E', + '\uFEA6': '\u062E', + '\uFEA7': '\u062E', + '\uFEA8': '\u062E', + '\uFEA9': '\u062F', + '\uFEAA': '\u062F', + '\uFEAB': '\u0630', + '\uFEAC': '\u0630', + '\uFEAD': '\u0631', + '\uFEAE': '\u0631', + '\uFEAF': '\u0632', + '\uFEB0': '\u0632', + '\uFEB1': '\u0633', + '\uFEB2': '\u0633', + '\uFEB3': '\u0633', + '\uFEB4': '\u0633', + '\uFEB5': '\u0634', + '\uFEB6': '\u0634', + '\uFEB7': '\u0634', + '\uFEB8': '\u0634', + '\uFEB9': '\u0635', + '\uFEBA': '\u0635', + '\uFEBB': '\u0635', + '\uFEBC': '\u0635', + '\uFEBD': '\u0636', + '\uFEBE': '\u0636', + '\uFEBF': '\u0636', + '\uFEC0': '\u0636', + '\uFEC1': '\u0637', + '\uFEC2': '\u0637', + '\uFEC3': '\u0637', + '\uFEC4': '\u0637', + '\uFEC5': '\u0638', + '\uFEC6': '\u0638', + '\uFEC7': '\u0638', + '\uFEC8': '\u0638', + '\uFEC9': '\u0639', + '\uFECA': '\u0639', + '\uFECB': '\u0639', + '\uFECC': '\u0639', + '\uFECD': '\u063A', + '\uFECE': '\u063A', + '\uFECF': '\u063A', + '\uFED0': '\u063A', + '\uFED1': '\u0641', + '\uFED2': '\u0641', + '\uFED3': '\u0641', + '\uFED4': '\u0641', + '\uFED5': '\u0642', + '\uFED6': '\u0642', + '\uFED7': '\u0642', + '\uFED8': '\u0642', + '\uFED9': '\u0643', + '\uFEDA': '\u0643', + '\uFEDB': '\u0643', + '\uFEDC': '\u0643', + '\uFEDD': '\u0644', + '\uFEDE': '\u0644', + '\uFEDF': '\u0644', + '\uFEE0': '\u0644', + '\uFEE1': '\u0645', + '\uFEE2': '\u0645', + '\uFEE3': '\u0645', + '\uFEE4': '\u0645', + '\uFEE5': '\u0646', + '\uFEE6': '\u0646', + '\uFEE7': '\u0646', + '\uFEE8': '\u0646', + '\uFEE9': '\u0647', + '\uFEEA': '\u0647', + '\uFEEB': '\u0647', + '\uFEEC': '\u0647', + '\uFEED': '\u0648', + '\uFEEE': '\u0648', + '\uFEEF': '\u0649', + '\uFEF0': '\u0649', + '\uFEF1': '\u064A', + '\uFEF2': '\u064A', + '\uFEF3': '\u064A', + '\uFEF4': '\u064A', + '\uFEF5': '\u0644\u0622', + '\uFEF6': '\u0644\u0622', + '\uFEF7': '\u0644\u0623', + '\uFEF8': '\u0644\u0623', + '\uFEF9': '\u0644\u0625', + '\uFEFA': '\u0644\u0625', + '\uFEFB': '\u0644\u0627', + '\uFEFC': '\u0644\u0627' +}; + +function reverseIfRtl(chars) { + var charsLength = chars.length; + //reverse an arabic ligature + if (charsLength <= 1 || !isRTLRangeFor(chars.charCodeAt(0))) { + return chars; + } + var s = ''; + for (var ii = charsLength - 1; ii >= 0; ii--) { + s += chars[ii]; + } + return s; +} + +function adjustWidths(properties) { + if (!properties.fontMatrix) { + return; + } + if (properties.fontMatrix[0] === FONT_IDENTITY_MATRIX[0]) { + return; + } + // adjusting width to fontMatrix scale + var scale = 0.001 / properties.fontMatrix[0]; + var glyphsWidths = properties.widths; + for (var glyph in glyphsWidths) { + glyphsWidths[glyph] *= scale; + } + properties.defaultWidth *= scale; +} + +function getFontType(type, subtype) { + switch (type) { + case 'Type1': + return subtype === 'Type1C' ? FontType.TYPE1C : FontType.TYPE1; + case 'CIDFontType0': + return subtype === 'CIDFontType0C' ? FontType.CIDFONTTYPE0C : + FontType.CIDFONTTYPE0; + case 'OpenType': + return FontType.OPENTYPE; + case 'TrueType': + return FontType.TRUETYPE; + case 'CIDFontType2': + return FontType.CIDFONTTYPE2; + case 'MMType1': + return FontType.MMTYPE1; + case 'Type0': + return FontType.TYPE0; + default: + return FontType.UNKNOWN; + } +} + +var Glyph = (function GlyphClosure() { + function Glyph(fontChar, unicode, accent, width, vmetric, operatorListId, + isSpace) { + this.fontChar = fontChar; + this.unicode = unicode; + this.accent = accent; + this.width = width; + this.vmetric = vmetric; + this.operatorListId = operatorListId; + this.isSpace = isSpace; + } + + Glyph.prototype.matchesForCache = function(fontChar, unicode, accent, width, + vmetric, operatorListId, isSpace) { + return this.fontChar === fontChar && + this.unicode === unicode && + this.accent === accent && + this.width === width && + this.vmetric === vmetric && + this.operatorListId === operatorListId && + this.isSpace === isSpace; + }; + + return Glyph; +})(); + +var ToUnicodeMap = (function ToUnicodeMapClosure() { + function ToUnicodeMap(cmap) { + // The elements of this._map can be integers or strings, depending on how + // |cmap| was created. + this._map = cmap; + } + + ToUnicodeMap.prototype = { + get length() { + return this._map.length; + }, + + forEach: function(callback) { + for (var charCode in this._map) { + callback(charCode, this._map[charCode].charCodeAt(0)); + } + }, + + has: function(i) { + return this._map[i] !== undefined; + }, + + get: function(i) { + return this._map[i]; + }, + + charCodeOf: function(v) { + return this._map.indexOf(v); + } + }; + + return ToUnicodeMap; +})(); + +var IdentityToUnicodeMap = (function IdentityToUnicodeMapClosure() { + function IdentityToUnicodeMap(firstChar, lastChar) { + this.firstChar = firstChar; + this.lastChar = lastChar; + } + + IdentityToUnicodeMap.prototype = { + get length() { + return (this.lastChar + 1) - this.firstChar; + }, + + forEach: function (callback) { + for (var i = this.firstChar, ii = this.lastChar; i <= ii; i++) { + callback(i, i); + } + }, + + has: function (i) { + return this.firstChar <= i && i <= this.lastChar; + }, + + get: function (i) { + if (this.firstChar <= i && i <= this.lastChar) { + return String.fromCharCode(i); + } + return undefined; + }, + + charCodeOf: function (v) { + return (isInt(v) && v >= this.firstChar && v <= this.lastChar) ? v : -1; + } + }; + + return IdentityToUnicodeMap; +})(); + +var OpenTypeFileBuilder = (function OpenTypeFileBuilderClosure() { + function writeInt16(dest, offset, num) { + dest[offset] = (num >> 8) & 0xFF; + dest[offset + 1] = num & 0xFF; + } + + function writeInt32(dest, offset, num) { + dest[offset] = (num >> 24) & 0xFF; + dest[offset + 1] = (num >> 16) & 0xFF; + dest[offset + 2] = (num >> 8) & 0xFF; + dest[offset + 3] = num & 0xFF; + } + + function writeData(dest, offset, data) { + var i, ii; + if (data instanceof Uint8Array) { + dest.set(data, offset); + } else if (typeof data === 'string') { + for (i = 0, ii = data.length; i < ii; i++) { + dest[offset++] = data.charCodeAt(i) & 0xFF; + } + } else { + // treating everything else as array + for (i = 0, ii = data.length; i < ii; i++) { + dest[offset++] = data[i] & 0xFF; + } + } + } + + function OpenTypeFileBuilder(sfnt) { + this.sfnt = sfnt; + this.tables = Object.create(null); + } + + OpenTypeFileBuilder.getSearchParams = + function OpenTypeFileBuilder_getSearchParams(entriesCount, entrySize) { + var maxPower2 = 1, log2 = 0; + while ((maxPower2 ^ entriesCount) > maxPower2) { + maxPower2 <<= 1; + log2++; + } + var searchRange = maxPower2 * entrySize; + return { + range: searchRange, + entry: log2, + rangeShift: entrySize * entriesCount - searchRange + }; + }; + + var OTF_HEADER_SIZE = 12; + var OTF_TABLE_ENTRY_SIZE = 16; + + OpenTypeFileBuilder.prototype = { + toArray: function OpenTypeFileBuilder_toArray() { + var sfnt = this.sfnt; + + // Tables needs to be written by ascendant alphabetic order + var tables = this.tables; + var tablesNames = Object.keys(tables); + tablesNames.sort(); + var numTables = tablesNames.length; + + var i, j, jj, table, tableName; + // layout the tables data + var offset = OTF_HEADER_SIZE + numTables * OTF_TABLE_ENTRY_SIZE; + var tableOffsets = [offset]; + for (i = 0; i < numTables; i++) { + table = tables[tablesNames[i]]; + var paddedLength = ((table.length + 3) & ~3) >>> 0; + offset += paddedLength; + tableOffsets.push(offset); + } + + var file = new Uint8Array(offset); + // write the table data first (mostly for checksum) + for (i = 0; i < numTables; i++) { + table = tables[tablesNames[i]]; + writeData(file, tableOffsets[i], table); + } + + // sfnt version (4 bytes) + if (sfnt === 'true') { + // Windows hates the Mac TrueType sfnt version number + sfnt = string32(0x00010000); + } + file[0] = sfnt.charCodeAt(0) & 0xFF; + file[1] = sfnt.charCodeAt(1) & 0xFF; + file[2] = sfnt.charCodeAt(2) & 0xFF; + file[3] = sfnt.charCodeAt(3) & 0xFF; + + // numTables (2 bytes) + writeInt16(file, 4, numTables); + + var searchParams = OpenTypeFileBuilder.getSearchParams(numTables, 16); + + // searchRange (2 bytes) + writeInt16(file, 6, searchParams.range); + // entrySelector (2 bytes) + writeInt16(file, 8, searchParams.entry); + // rangeShift (2 bytes) + writeInt16(file, 10, searchParams.rangeShift); + + offset = OTF_HEADER_SIZE; + // writing table entries + for (i = 0; i < numTables; i++) { + tableName = tablesNames[i]; + file[offset] = tableName.charCodeAt(0) & 0xFF; + file[offset + 1] = tableName.charCodeAt(1) & 0xFF; + file[offset + 2] = tableName.charCodeAt(2) & 0xFF; + file[offset + 3] = tableName.charCodeAt(3) & 0xFF; + + // checksum + var checksum = 0; + for (j = tableOffsets[i], jj = tableOffsets[i + 1]; j < jj; j += 4) { + var quad = (file[j] << 24) + (file[j + 1] << 16) + + (file[j + 2] << 8) + file[j + 3]; + checksum = (checksum + quad) | 0; + } + writeInt32(file, offset + 4, checksum); + + // offset + writeInt32(file, offset + 8, tableOffsets[i]); + // length + writeInt32(file, offset + 12, tables[tableName].length); + + offset += OTF_TABLE_ENTRY_SIZE; + } + return file; + }, + + addTable: function OpenTypeFileBuilder_addTable(tag, data) { + if (tag in this.tables) { + throw new Error('Table ' + tag + ' already exists'); + } + this.tables[tag] = data; + } + }; + + return OpenTypeFileBuilder; +})(); + +// Problematic Unicode characters in the fonts that needs to be moved to avoid +// issues when they are painted on the canvas, e.g. complex-script shaping or +// control/whitespace characters. The ranges are listed in pairs: the first item +// is a code of the first problematic code, the second one is the next +// non-problematic code. The ranges must be in sorted order. +var ProblematicCharRanges = new Int32Array([ + // Control characters. + 0x0000, 0x0020, + 0x007F, 0x00A1, + 0x00AD, 0x00AE, + // Chars that is used in complex-script shaping. + 0x0600, 0x0780, + 0x08A0, 0x10A0, + 0x1780, 0x1800, + // General punctuation chars. + 0x2000, 0x2010, + 0x2011, 0x2012, + 0x2028, 0x2030, + 0x205F, 0x2070, + 0x25CC, 0x25CD, + // Chars that is used in complex-script shaping. + 0xAA60, 0xAA80, + // Specials Unicode block. + 0xFFF0, 0x10000 +]); + +/** + * 'Font' is the class the outside world should use, it encapsulate all the font + * decoding logics whatever type it is (assuming the font type is supported). + * + * For example to read a Type1 font and to attach it to the document: + * var type1Font = new Font("MyFontName", binaryFile, propertiesObject); + * type1Font.bind(); + */ +var Font = (function FontClosure() { + function Font(name, file, properties) { + var charCode, glyphName, fontChar; + + this.name = name; + this.loadedName = properties.loadedName; + this.isType3Font = properties.isType3Font; + this.sizes = []; + + this.glyphCache = {}; + + var names = name.split('+'); + names = names.length > 1 ? names[1] : names[0]; + names = names.split(/[-,_]/g)[0]; + this.isSerifFont = !!(properties.flags & FontFlags.Serif); + this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic); + this.isMonospace = !!(properties.flags & FontFlags.FixedPitch); + + var type = properties.type; + var subtype = properties.subtype; + this.type = type; + + this.fallbackName = (this.isMonospace ? 'monospace' : + (this.isSerifFont ? 'serif' : 'sans-serif')); + + this.differences = properties.differences; + this.widths = properties.widths; + this.defaultWidth = properties.defaultWidth; + this.composite = properties.composite; + this.wideChars = properties.wideChars; + this.cMap = properties.cMap; + this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS; + this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS; + this.fontMatrix = properties.fontMatrix; + this.bbox = properties.bbox; + + this.toUnicode = properties.toUnicode = this.buildToUnicode(properties); + + this.toFontChar = []; + + if (properties.type === 'Type3') { + for (charCode = 0; charCode < 256; charCode++) { + this.toFontChar[charCode] = (this.differences[charCode] || + properties.defaultEncoding[charCode]); + } + this.fontType = FontType.TYPE3; + return; + } + + this.cidEncoding = properties.cidEncoding; + this.vertical = properties.vertical; + if (this.vertical) { + this.vmetrics = properties.vmetrics; + this.defaultVMetrics = properties.defaultVMetrics; + } + + if (!file || file.isEmpty) { + if (file) { + // Some bad PDF generators will include empty font files, + // attempting to recover by assuming that no file exists. + warn('Font file is empty in "' + name + '" (' + this.loadedName + ')'); + } + + this.missingFile = true; + // The file data is not specified. Trying to fix the font name + // to be used with the canvas.font. + var fontName = name.replace(/[,_]/g, '-'); + var isStandardFont = !!stdFontMap[fontName] || + !!(nonStdFontMap[fontName] && stdFontMap[nonStdFontMap[fontName]]); + fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName; + + this.bold = (fontName.search(/bold/gi) !== -1); + this.italic = ((fontName.search(/oblique/gi) !== -1) || + (fontName.search(/italic/gi) !== -1)); + + // Use 'name' instead of 'fontName' here because the original + // name ArialBlack for example will be replaced by Helvetica. + this.black = (name.search(/Black/g) !== -1); + + // if at least one width is present, remeasure all chars when exists + this.remeasure = Object.keys(this.widths).length > 0; + if (isStandardFont && type === 'CIDFontType2' && + properties.cidEncoding.indexOf('Identity-') === 0) { + // Standard fonts might be embedded as CID font without glyph mapping. + // Building one based on GlyphMapForStandardFonts. + var map = []; + for (charCode in GlyphMapForStandardFonts) { + map[+charCode] = GlyphMapForStandardFonts[charCode]; + } + if (/ArialBlack/i.test(name)) { + for (charCode in SupplementalGlyphMapForArialBlack) { + map[+charCode] = SupplementalGlyphMapForArialBlack[charCode]; + } + } + var isIdentityUnicode = this.toUnicode instanceof IdentityToUnicodeMap; + if (!isIdentityUnicode) { + this.toUnicode.forEach(function(charCode, unicodeCharCode) { + map[+charCode] = unicodeCharCode; + }); + } + this.toFontChar = map; + this.toUnicode = new ToUnicodeMap(map); + } else if (/Symbol/i.test(fontName)) { + var symbols = Encodings.SymbolSetEncoding; + for (charCode in symbols) { + fontChar = GlyphsUnicode[symbols[charCode]]; + if (!fontChar) { + continue; + } + this.toFontChar[charCode] = fontChar; + } + for (charCode in properties.differences) { + fontChar = GlyphsUnicode[properties.differences[charCode]]; + if (!fontChar) { + continue; + } + this.toFontChar[charCode] = fontChar; + } + } else if (/Dingbats/i.test(fontName)) { + if (/Wingdings/i.test(name)) { + warn('Wingdings font without embedded font file, ' + + 'falling back to the ZapfDingbats encoding.'); + } + var dingbats = Encodings.ZapfDingbatsEncoding; + for (charCode in dingbats) { + fontChar = DingbatsGlyphsUnicode[dingbats[charCode]]; + if (!fontChar) { + continue; + } + this.toFontChar[charCode] = fontChar; + } + for (charCode in properties.differences) { + fontChar = DingbatsGlyphsUnicode[properties.differences[charCode]]; + if (!fontChar) { + continue; + } + this.toFontChar[charCode] = fontChar; + } + } else if (isStandardFont) { + this.toFontChar = []; + for (charCode in properties.defaultEncoding) { + glyphName = (properties.differences[charCode] || + properties.defaultEncoding[charCode]); + this.toFontChar[charCode] = GlyphsUnicode[glyphName]; + } + } else { + var unicodeCharCode, notCidFont = (type.indexOf('CIDFontType') === -1); + this.toUnicode.forEach(function(charCode, unicodeCharCode) { + if (notCidFont) { + glyphName = (properties.differences[charCode] || + properties.defaultEncoding[charCode]); + unicodeCharCode = (GlyphsUnicode[glyphName] || unicodeCharCode); + } + this.toFontChar[charCode] = unicodeCharCode; + }.bind(this)); + } + this.loadedName = fontName.split('-')[0]; + this.loading = false; + this.fontType = getFontType(type, subtype); + return; + } + + // Some fonts might use wrong font types for Type1C or CIDFontType0C + if (subtype === 'Type1C' && (type !== 'Type1' && type !== 'MMType1')) { + // Some TrueType fonts by mistake claim Type1C + if (isTrueTypeFile(file)) { + subtype = 'TrueType'; + } else { + type = 'Type1'; + } + } + if (subtype === 'CIDFontType0C' && type !== 'CIDFontType0') { + type = 'CIDFontType0'; + } + if (subtype === 'OpenType') { + type = 'OpenType'; + } + // Some CIDFontType0C fonts by mistake claim CIDFontType0. + if (type === 'CIDFontType0') { + if (isType1File(file)) { + subtype = 'CIDFontType0'; + } else if (isOpenTypeFile(file)) { + // Sometimes the type/subtype can be a complete lie (see issue6782.pdf). + type = subtype = 'OpenType'; + } else { + subtype = 'CIDFontType0C'; + } + } + + var data; + switch (type) { + case 'MMType1': + info('MMType1 font (' + name + '), falling back to Type1.'); + /* falls through */ + case 'Type1': + case 'CIDFontType0': + this.mimetype = 'font/opentype'; + + var cff = (subtype === 'Type1C' || subtype === 'CIDFontType0C') ? + new CFFFont(file, properties) : new Type1Font(name, file, properties); + + adjustWidths(properties); + + // Wrap the CFF data inside an OTF font file + data = this.convert(name, cff, properties); + break; + + case 'OpenType': + case 'TrueType': + case 'CIDFontType2': + this.mimetype = 'font/opentype'; + + // Repair the TrueType file. It is can be damaged in the point of + // view of the sanitizer + data = this.checkAndRepair(name, file, properties); + if (this.isOpenType) { + adjustWidths(properties); + + type = 'OpenType'; + } + break; + + default: + error('Font ' + type + ' is not supported'); + break; + } + + this.data = data; + this.fontType = getFontType(type, subtype); + + // Transfer some properties again that could change during font conversion + this.fontMatrix = properties.fontMatrix; + this.widths = properties.widths; + this.defaultWidth = properties.defaultWidth; + this.encoding = properties.baseEncoding; + this.seacMap = properties.seacMap; + + this.loading = true; + } + + Font.getFontID = (function () { + var ID = 1; + return function Font_getFontID() { + return String(ID++); + }; + })(); + + function int16(b0, b1) { + return (b0 << 8) + b1; + } + + function int32(b0, b1, b2, b3) { + return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; + } + + function string16(value) { + return String.fromCharCode((value >> 8) & 0xff, value & 0xff); + } + + function safeString16(value) { + // clamp value to the 16-bit int range + value = (value > 0x7FFF ? 0x7FFF : (value < -0x8000 ? -0x8000 : value)); + return String.fromCharCode((value >> 8) & 0xff, value & 0xff); + } + + function isTrueTypeFile(file) { + var header = file.peekBytes(4); + return readUint32(header, 0) === 0x00010000; + } + + function isOpenTypeFile(file) { + var header = file.peekBytes(4); + return bytesToString(header) === 'OTTO'; + } + + function isType1File(file) { + var header = file.peekBytes(2); + // All Type1 font programs must begin with the comment '%!' (0x25 + 0x21). + if (header[0] === 0x25 && header[1] === 0x21) { + return true; + } + // ... obviously some fonts violate that part of the specification, + // please refer to the comment in |Type1Font| below. + if (header[0] === 0x80 && header[1] === 0x01) { // pfb file header. + return true; + } + return false; + } + + /** + * Helper function for |adjustMapping|. + * @return {boolean} + */ + function isProblematicUnicodeLocation(code) { + // Using binary search to find a range start. + var i = 0, j = ProblematicCharRanges.length - 1; + while (i < j) { + var c = (i + j + 1) >> 1; + if (code < ProblematicCharRanges[c]) { + j = c - 1; + } else { + i = c; + } + } + // Even index means code in problematic range. + return !(i & 1); + } + + /** + * Rebuilds the char code to glyph ID map by trying to replace the char codes + * with their unicode value. It also moves char codes that are in known + * problematic locations. + * @return {Object} Two properties: + * 'toFontChar' - maps original char codes(the value that will be read + * from commands such as show text) to the char codes that will be used in the + * font that we build + * 'charCodeToGlyphId' - maps the new font char codes to glyph ids + */ + function adjustMapping(charCodeToGlyphId, properties) { + var toUnicode = properties.toUnicode; + var isSymbolic = !!(properties.flags & FontFlags.Symbolic); + var isIdentityUnicode = + properties.toUnicode instanceof IdentityToUnicodeMap; + var newMap = Object.create(null); + var toFontChar = []; + var usedFontCharCodes = []; + var nextAvailableFontCharCode = PRIVATE_USE_OFFSET_START; + for (var originalCharCode in charCodeToGlyphId) { + originalCharCode |= 0; + var glyphId = charCodeToGlyphId[originalCharCode]; + var fontCharCode = originalCharCode; + // First try to map the value to a unicode position if a non identity map + // was created. + if (!isIdentityUnicode && toUnicode.has(originalCharCode)) { + var unicode = toUnicode.get(fontCharCode); + // TODO: Try to map ligatures to the correct spot. + if (unicode.length === 1) { + fontCharCode = unicode.charCodeAt(0); + } + } + // Try to move control characters, special characters and already mapped + // characters to the private use area since they will not be drawn by + // canvas if left in their current position. Also, move characters if the + // font was symbolic and there is only an identity unicode map since the + // characters probably aren't in the correct position (fixes an issue + // with firefox and thuluthfont). + if ((usedFontCharCodes[fontCharCode] !== undefined || + isProblematicUnicodeLocation(fontCharCode) || + (isSymbolic && isIdentityUnicode)) && + nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END) { // Room left. + // Loop to try and find a free spot in the private use area. + do { + fontCharCode = nextAvailableFontCharCode++; + + if (SKIP_PRIVATE_USE_RANGE_F000_TO_F01F && fontCharCode === 0xF000) { + fontCharCode = 0xF020; + nextAvailableFontCharCode = fontCharCode + 1; + } + + } while (usedFontCharCodes[fontCharCode] !== undefined && + nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END); + } + + newMap[fontCharCode] = glyphId; + toFontChar[originalCharCode] = fontCharCode; + usedFontCharCodes[fontCharCode] = true; + } + return { + toFontChar: toFontChar, + charCodeToGlyphId: newMap, + nextAvailableFontCharCode: nextAvailableFontCharCode + }; + } + + function getRanges(glyphs, numGlyphs) { + // Array.sort() sorts by characters, not numerically, so convert to an + // array of characters. + var codes = []; + for (var charCode in glyphs) { + // Remove an invalid glyph ID mappings to make OTS happy. + if (glyphs[charCode] >= numGlyphs) { + continue; + } + codes.push({ fontCharCode: charCode | 0, glyphId: glyphs[charCode] }); + } + codes.sort(function fontGetRangesSort(a, b) { + return a.fontCharCode - b.fontCharCode; + }); + + // Split the sorted codes into ranges. + var ranges = []; + var length = codes.length; + for (var n = 0; n < length; ) { + var start = codes[n].fontCharCode; + var codeIndices = [codes[n].glyphId]; + ++n; + var end = start; + while (n < length && end + 1 === codes[n].fontCharCode) { + codeIndices.push(codes[n].glyphId); + ++end; + ++n; + if (end === 0xFFFF) { + break; + } + } + ranges.push([start, end, codeIndices]); + } + + return ranges; + } + + function createCmapTable(glyphs, numGlyphs) { + var ranges = getRanges(glyphs, numGlyphs); + var numTables = ranges[ranges.length - 1][1] > 0xFFFF ? 2 : 1; + var cmap = '\x00\x00' + // version + string16(numTables) + // numTables + '\x00\x03' + // platformID + '\x00\x01' + // encodingID + string32(4 + numTables * 8); // start of the table record + + var i, ii, j, jj; + for (i = ranges.length - 1; i >= 0; --i) { + if (ranges[i][0] <= 0xFFFF) { break; } + } + var bmpLength = i + 1; + + if (ranges[i][0] < 0xFFFF && ranges[i][1] === 0xFFFF) { + ranges[i][1] = 0xFFFE; + } + var trailingRangesCount = ranges[i][1] < 0xFFFF ? 1 : 0; + var segCount = bmpLength + trailingRangesCount; + var searchParams = OpenTypeFileBuilder.getSearchParams(segCount, 2); + + // Fill up the 4 parallel arrays describing the segments. + var startCount = ''; + var endCount = ''; + var idDeltas = ''; + var idRangeOffsets = ''; + var glyphsIds = ''; + var bias = 0; + + var range, start, end, codes; + for (i = 0, ii = bmpLength; i < ii; i++) { + range = ranges[i]; + start = range[0]; + end = range[1]; + startCount += string16(start); + endCount += string16(end); + codes = range[2]; + var contiguous = true; + for (j = 1, jj = codes.length; j < jj; ++j) { + if (codes[j] !== codes[j - 1] + 1) { + contiguous = false; + break; + } + } + if (!contiguous) { + var offset = (segCount - i) * 2 + bias * 2; + bias += (end - start + 1); + + idDeltas += string16(0); + idRangeOffsets += string16(offset); + + for (j = 0, jj = codes.length; j < jj; ++j) { + glyphsIds += string16(codes[j]); + } + } else { + var startCode = codes[0]; + + idDeltas += string16((startCode - start) & 0xFFFF); + idRangeOffsets += string16(0); + } + } + + if (trailingRangesCount > 0) { + endCount += '\xFF\xFF'; + startCount += '\xFF\xFF'; + idDeltas += '\x00\x01'; + idRangeOffsets += '\x00\x00'; + } + + var format314 = '\x00\x00' + // language + string16(2 * segCount) + + string16(searchParams.range) + + string16(searchParams.entry) + + string16(searchParams.rangeShift) + + endCount + '\x00\x00' + startCount + + idDeltas + idRangeOffsets + glyphsIds; + + var format31012 = ''; + var header31012 = ''; + if (numTables > 1) { + cmap += '\x00\x03' + // platformID + '\x00\x0A' + // encodingID + string32(4 + numTables * 8 + + 4 + format314.length); // start of the table record + format31012 = ''; + for (i = 0, ii = ranges.length; i < ii; i++) { + range = ranges[i]; + start = range[0]; + codes = range[2]; + var code = codes[0]; + for (j = 1, jj = codes.length; j < jj; ++j) { + if (codes[j] !== codes[j - 1] + 1) { + end = range[0] + j - 1; + format31012 += string32(start) + // startCharCode + string32(end) + // endCharCode + string32(code); // startGlyphID + start = end + 1; + code = codes[j]; + } + } + format31012 += string32(start) + // startCharCode + string32(range[1]) + // endCharCode + string32(code); // startGlyphID + } + header31012 = '\x00\x0C' + // format + '\x00\x00' + // reserved + string32(format31012.length + 16) + // length + '\x00\x00\x00\x00' + // language + string32(format31012.length / 12); // nGroups + } + + return cmap + '\x00\x04' + // format + string16(format314.length + 4) + // length + format314 + header31012 + format31012; + } + + function validateOS2Table(os2) { + var stream = new Stream(os2.data); + var version = stream.getUint16(); + // TODO verify all OS/2 tables fields, but currently we validate only those + // that give us issues + stream.getBytes(60); // skipping type, misc sizes, panose, unicode ranges + var selection = stream.getUint16(); + if (version < 4 && (selection & 0x0300)) { + return false; + } + var firstChar = stream.getUint16(); + var lastChar = stream.getUint16(); + if (firstChar > lastChar) { + return false; + } + stream.getBytes(6); // skipping sTypoAscender/Descender/LineGap + var usWinAscent = stream.getUint16(); + if (usWinAscent === 0) { // makes font unreadable by windows + return false; + } + + // OS/2 appears to be valid, resetting some fields + os2.data[8] = os2.data[9] = 0; // IE rejects fonts if fsType != 0 + return true; + } + + function createOS2Table(properties, charstrings, override) { + override = override || { + unitsPerEm: 0, + yMax: 0, + yMin: 0, + ascent: 0, + descent: 0 + }; + + var ulUnicodeRange1 = 0; + var ulUnicodeRange2 = 0; + var ulUnicodeRange3 = 0; + var ulUnicodeRange4 = 0; + + var firstCharIndex = null; + var lastCharIndex = 0; + + if (charstrings) { + for (var code in charstrings) { + code |= 0; + if (firstCharIndex > code || !firstCharIndex) { + firstCharIndex = code; + } + if (lastCharIndex < code) { + lastCharIndex = code; + } + + var position = getUnicodeRangeFor(code); + if (position < 32) { + ulUnicodeRange1 |= 1 << position; + } else if (position < 64) { + ulUnicodeRange2 |= 1 << position - 32; + } else if (position < 96) { + ulUnicodeRange3 |= 1 << position - 64; + } else if (position < 123) { + ulUnicodeRange4 |= 1 << position - 96; + } else { + error('Unicode ranges Bits > 123 are reserved for internal usage'); + } + } + } else { + // TODO + firstCharIndex = 0; + lastCharIndex = 255; + } + + var bbox = properties.bbox || [0, 0, 0, 0]; + var unitsPerEm = (override.unitsPerEm || + 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0]); + + // if the font units differ to the PDF glyph space units + // then scale up the values + var scale = (properties.ascentScaled ? 1.0 : + unitsPerEm / PDF_GLYPH_SPACE_UNITS); + + var typoAscent = (override.ascent || + Math.round(scale * (properties.ascent || bbox[3]))); + var typoDescent = (override.descent || + Math.round(scale * (properties.descent || bbox[1]))); + if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) { + typoDescent = -typoDescent; // fixing incorrect descent + } + var winAscent = override.yMax || typoAscent; + var winDescent = -override.yMin || -typoDescent; + + return '\x00\x03' + // version + '\x02\x24' + // xAvgCharWidth + '\x01\xF4' + // usWeightClass + '\x00\x05' + // usWidthClass + '\x00\x00' + // fstype (0 to let the font loads via font-face on IE) + '\x02\x8A' + // ySubscriptXSize + '\x02\xBB' + // ySubscriptYSize + '\x00\x00' + // ySubscriptXOffset + '\x00\x8C' + // ySubscriptYOffset + '\x02\x8A' + // ySuperScriptXSize + '\x02\xBB' + // ySuperScriptYSize + '\x00\x00' + // ySuperScriptXOffset + '\x01\xDF' + // ySuperScriptYOffset + '\x00\x31' + // yStrikeOutSize + '\x01\x02' + // yStrikeOutPosition + '\x00\x00' + // sFamilyClass + '\x00\x00\x06' + + String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) + + '\x00\x00\x00\x00\x00\x00' + // Panose + string32(ulUnicodeRange1) + // ulUnicodeRange1 (Bits 0-31) + string32(ulUnicodeRange2) + // ulUnicodeRange2 (Bits 32-63) + string32(ulUnicodeRange3) + // ulUnicodeRange3 (Bits 64-95) + string32(ulUnicodeRange4) + // ulUnicodeRange4 (Bits 96-127) + '\x2A\x32\x31\x2A' + // achVendID + string16(properties.italicAngle ? 1 : 0) + // fsSelection + string16(firstCharIndex || + properties.firstChar) + // usFirstCharIndex + string16(lastCharIndex || properties.lastChar) + // usLastCharIndex + string16(typoAscent) + // sTypoAscender + string16(typoDescent) + // sTypoDescender + '\x00\x64' + // sTypoLineGap (7%-10% of the unitsPerEM value) + string16(winAscent) + // usWinAscent + string16(winDescent) + // usWinDescent + '\x00\x00\x00\x00' + // ulCodePageRange1 (Bits 0-31) + '\x00\x00\x00\x00' + // ulCodePageRange2 (Bits 32-63) + string16(properties.xHeight) + // sxHeight + string16(properties.capHeight) + // sCapHeight + string16(0) + // usDefaultChar + string16(firstCharIndex || properties.firstChar) + // usBreakChar + '\x00\x03'; // usMaxContext + } + + function createPostTable(properties) { + var angle = Math.floor(properties.italicAngle * (Math.pow(2, 16))); + return ('\x00\x03\x00\x00' + // Version number + string32(angle) + // italicAngle + '\x00\x00' + // underlinePosition + '\x00\x00' + // underlineThickness + string32(properties.fixedPitch) + // isFixedPitch + '\x00\x00\x00\x00' + // minMemType42 + '\x00\x00\x00\x00' + // maxMemType42 + '\x00\x00\x00\x00' + // minMemType1 + '\x00\x00\x00\x00'); // maxMemType1 + } + + function createNameTable(name, proto) { + if (!proto) { + proto = [[], []]; // no strings and unicode strings + } + + var strings = [ + proto[0][0] || 'Original licence', // 0.Copyright + proto[0][1] || name, // 1.Font family + proto[0][2] || 'Unknown', // 2.Font subfamily (font weight) + proto[0][3] || 'uniqueID', // 3.Unique ID + proto[0][4] || name, // 4.Full font name + proto[0][5] || 'Version 0.11', // 5.Version + proto[0][6] || '', // 6.Postscript name + proto[0][7] || 'Unknown', // 7.Trademark + proto[0][8] || 'Unknown', // 8.Manufacturer + proto[0][9] || 'Unknown' // 9.Designer + ]; + + // Mac want 1-byte per character strings while Windows want + // 2-bytes per character, so duplicate the names table + var stringsUnicode = []; + var i, ii, j, jj, str; + for (i = 0, ii = strings.length; i < ii; i++) { + str = proto[1][i] || strings[i]; + + var strBufUnicode = []; + for (j = 0, jj = str.length; j < jj; j++) { + strBufUnicode.push(string16(str.charCodeAt(j))); + } + stringsUnicode.push(strBufUnicode.join('')); + } + + var names = [strings, stringsUnicode]; + var platforms = ['\x00\x01', '\x00\x03']; + var encodings = ['\x00\x00', '\x00\x01']; + var languages = ['\x00\x00', '\x04\x09']; + + var namesRecordCount = strings.length * platforms.length; + var nameTable = + '\x00\x00' + // format + string16(namesRecordCount) + // Number of names Record + string16(namesRecordCount * 12 + 6); // Storage + + // Build the name records field + var strOffset = 0; + for (i = 0, ii = platforms.length; i < ii; i++) { + var strs = names[i]; + for (j = 0, jj = strs.length; j < jj; j++) { + str = strs[j]; + var nameRecord = + platforms[i] + // platform ID + encodings[i] + // encoding ID + languages[i] + // language ID + string16(j) + // name ID + string16(str.length) + + string16(strOffset); + nameTable += nameRecord; + strOffset += str.length; + } + } + + nameTable += strings.join('') + stringsUnicode.join(''); + return nameTable; + } + + Font.prototype = { + name: null, + font: null, + mimetype: null, + encoding: null, + get renderer() { + var renderer = FontRendererFactory.create(this); + return shadow(this, 'renderer', renderer); + }, + + exportData: function Font_exportData() { + var data = {}; + for (var i in this) { + if (this.hasOwnProperty(i)) { + data[i] = this[i]; + } + } + return data; + }, + + checkAndRepair: function Font_checkAndRepair(name, font, properties) { + function readTableEntry(file) { + var tag = bytesToString(file.getBytes(4)); + + var checksum = file.getInt32(); + var offset = file.getInt32() >>> 0; + var length = file.getInt32() >>> 0; + + // Read the table associated data + var previousPosition = file.pos; + file.pos = file.start ? file.start : 0; + file.skip(offset); + var data = file.getBytes(length); + file.pos = previousPosition; + + if (tag === 'head') { + // clearing checksum adjustment + data[8] = data[9] = data[10] = data[11] = 0; + data[17] |= 0x20; //Set font optimized for cleartype flag + } + + return { + tag: tag, + checksum: checksum, + length: length, + offset: offset, + data: data + }; + } + + function readOpenTypeHeader(ttf) { + return { + version: bytesToString(ttf.getBytes(4)), + numTables: ttf.getUint16(), + searchRange: ttf.getUint16(), + entrySelector: ttf.getUint16(), + rangeShift: ttf.getUint16() + }; + } + + /** + * Read the appropriate subtable from the cmap according to 9.6.6.4 from + * PDF spec + */ + function readCmapTable(cmap, font, isSymbolicFont, hasEncoding) { + if (!cmap) { + warn('No cmap table available.'); + return { + platformId: -1, + encodingId: -1, + mappings: [], + hasShortCmap: false + }; + } + var segment; + var start = (font.start ? font.start : 0) + cmap.offset; + font.pos = start; + + var version = font.getUint16(); + var numTables = font.getUint16(); + + var potentialTable; + var canBreak = false; + // There's an order of preference in terms of which cmap subtable to + // use: + // - non-symbolic fonts the preference is a 3,1 table then a 1,0 table + // - symbolic fonts the preference is a 3,0 table then a 1,0 table + // The following takes advantage of the fact that the tables are sorted + // to work. + for (var i = 0; i < numTables; i++) { + var platformId = font.getUint16(); + var encodingId = font.getUint16(); + var offset = font.getInt32() >>> 0; + var useTable = false; + + if (platformId === 0 && encodingId === 0) { + useTable = true; + // Continue the loop since there still may be a higher priority + // table. + } else if (platformId === 1 && encodingId === 0) { + useTable = true; + // Continue the loop since there still may be a higher priority + // table. + } else if (platformId === 3 && encodingId === 1 && + ((!isSymbolicFont && hasEncoding) || !potentialTable)) { + useTable = true; + if (!isSymbolicFont) { + canBreak = true; + } + } else if (isSymbolicFont && platformId === 3 && encodingId === 0) { + useTable = true; + canBreak = true; + } + + if (useTable) { + potentialTable = { + platformId: platformId, + encodingId: encodingId, + offset: offset + }; + } + if (canBreak) { + break; + } + } + + if (potentialTable) { + font.pos = start + potentialTable.offset; + } + if (!potentialTable || font.peekByte() === -1) { + warn('Could not find a preferred cmap table.'); + return { + platformId: -1, + encodingId: -1, + mappings: [], + hasShortCmap: false + }; + } + + var format = font.getUint16(); + var length = font.getUint16(); + var language = font.getUint16(); + + var hasShortCmap = false; + var mappings = []; + var j, glyphId; + + // TODO(mack): refactor this cmap subtable reading logic out + if (format === 0) { + for (j = 0; j < 256; j++) { + var index = font.getByte(); + if (!index) { + continue; + } + mappings.push({ + charCode: j, + glyphId: index + }); + } + hasShortCmap = true; + } else if (format === 4) { + // re-creating the table in format 4 since the encoding + // might be changed + var segCount = (font.getUint16() >> 1); + font.getBytes(6); // skipping range fields + var segIndex, segments = []; + for (segIndex = 0; segIndex < segCount; segIndex++) { + segments.push({ end: font.getUint16() }); + } + font.getUint16(); + for (segIndex = 0; segIndex < segCount; segIndex++) { + segments[segIndex].start = font.getUint16(); + } + + for (segIndex = 0; segIndex < segCount; segIndex++) { + segments[segIndex].delta = font.getUint16(); + } + + var offsetsCount = 0; + for (segIndex = 0; segIndex < segCount; segIndex++) { + segment = segments[segIndex]; + var rangeOffset = font.getUint16(); + if (!rangeOffset) { + segment.offsetIndex = -1; + continue; + } + + var offsetIndex = (rangeOffset >> 1) - (segCount - segIndex); + segment.offsetIndex = offsetIndex; + offsetsCount = Math.max(offsetsCount, offsetIndex + + segment.end - segment.start + 1); + } + + var offsets = []; + for (j = 0; j < offsetsCount; j++) { + offsets.push(font.getUint16()); + } + + for (segIndex = 0; segIndex < segCount; segIndex++) { + segment = segments[segIndex]; + start = segment.start; + var end = segment.end; + var delta = segment.delta; + offsetIndex = segment.offsetIndex; + + for (j = start; j <= end; j++) { + if (j === 0xFFFF) { + continue; + } + + glyphId = (offsetIndex < 0 ? + j : offsets[offsetIndex + j - start]); + glyphId = (glyphId + delta) & 0xFFFF; + if (glyphId === 0) { + continue; + } + mappings.push({ + charCode: j, + glyphId: glyphId + }); + } + } + } else if (format === 6) { + // Format 6 is a 2-bytes dense mapping, which means the font data + // lives glue together even if they are pretty far in the unicode + // table. (This looks weird, so I can have missed something), this + // works on Linux but seems to fails on Mac so let's rewrite the + // cmap table to a 3-1-4 style + var firstCode = font.getUint16(); + var entryCount = font.getUint16(); + + for (j = 0; j < entryCount; j++) { + glyphId = font.getUint16(); + var charCode = firstCode + j; + + mappings.push({ + charCode: charCode, + glyphId: glyphId + }); + } + } else { + warn('cmap table has unsupported format: ' + format); + return { + platformId: -1, + encodingId: -1, + mappings: [], + hasShortCmap: false + }; + } + + // removing duplicate entries + mappings.sort(function (a, b) { + return a.charCode - b.charCode; + }); + for (i = 1; i < mappings.length; i++) { + if (mappings[i - 1].charCode === mappings[i].charCode) { + mappings.splice(i, 1); + i--; + } + } + + return { + platformId: potentialTable.platformId, + encodingId: potentialTable.encodingId, + mappings: mappings, + hasShortCmap: hasShortCmap + }; + } + + function sanitizeMetrics(font, header, metrics, numGlyphs) { + if (!header) { + if (metrics) { + metrics.data = null; + } + return; + } + + font.pos = (font.start ? font.start : 0) + header.offset; + font.pos += header.length - 2; + var numOfMetrics = font.getUint16(); + + if (numOfMetrics > numGlyphs) { + info('The numOfMetrics (' + numOfMetrics + ') should not be ' + + 'greater than the numGlyphs (' + numGlyphs + ')'); + // Reduce numOfMetrics if it is greater than numGlyphs + numOfMetrics = numGlyphs; + header.data[34] = (numOfMetrics & 0xff00) >> 8; + header.data[35] = numOfMetrics & 0x00ff; + } + + var numOfSidebearings = numGlyphs - numOfMetrics; + var numMissing = numOfSidebearings - + ((metrics.length - numOfMetrics * 4) >> 1); + + if (numMissing > 0) { + // For each missing glyph, we set both the width and lsb to 0 (zero). + // Since we need to add two properties for each glyph, this explains + // the use of |numMissing * 2| when initializing the typed array. + var entries = new Uint8Array(metrics.length + numMissing * 2); + entries.set(metrics.data); + metrics.data = entries; + } + } + + function sanitizeGlyph(source, sourceStart, sourceEnd, dest, destStart, + hintsValid) { + if (sourceEnd - sourceStart <= 12) { + // glyph with data less than 12 is invalid one + return 0; + } + var glyf = source.subarray(sourceStart, sourceEnd); + var contoursCount = (glyf[0] << 8) | glyf[1]; + if (contoursCount & 0x8000) { + // complex glyph, writing as is + dest.set(glyf, destStart); + return glyf.length; + } + + var i, j = 10, flagsCount = 0; + for (i = 0; i < contoursCount; i++) { + var endPoint = (glyf[j] << 8) | glyf[j + 1]; + flagsCount = endPoint + 1; + j += 2; + } + // skipping instructions + var instructionsStart = j; + var instructionsLength = (glyf[j] << 8) | glyf[j + 1]; + j += 2 + instructionsLength; + var instructionsEnd = j; + // validating flags + var coordinatesLength = 0; + for (i = 0; i < flagsCount; i++) { + var flag = glyf[j++]; + if (flag & 0xC0) { + // reserved flags must be zero, cleaning up + glyf[j - 1] = flag & 0x3F; + } + var xyLength = ((flag & 2) ? 1 : (flag & 16) ? 0 : 2) + + ((flag & 4) ? 1 : (flag & 32) ? 0 : 2); + coordinatesLength += xyLength; + if (flag & 8) { + var repeat = glyf[j++]; + i += repeat; + coordinatesLength += repeat * xyLength; + } + } + // glyph without coordinates will be rejected + if (coordinatesLength === 0) { + return 0; + } + var glyphDataLength = j + coordinatesLength; + if (glyphDataLength > glyf.length) { + // not enough data for coordinates + return 0; + } + if (!hintsValid && instructionsLength > 0) { + dest.set(glyf.subarray(0, instructionsStart), destStart); + dest.set([0, 0], destStart + instructionsStart); + dest.set(glyf.subarray(instructionsEnd, glyphDataLength), + destStart + instructionsStart + 2); + glyphDataLength -= instructionsLength; + if (glyf.length - glyphDataLength > 3) { + glyphDataLength = (glyphDataLength + 3) & ~3; + } + return glyphDataLength; + } + if (glyf.length - glyphDataLength > 3) { + // truncating and aligning to 4 bytes the long glyph data + glyphDataLength = (glyphDataLength + 3) & ~3; + dest.set(glyf.subarray(0, glyphDataLength), destStart); + return glyphDataLength; + } + // glyph data is fine + dest.set(glyf, destStart); + return glyf.length; + } + + function sanitizeHead(head, numGlyphs, locaLength) { + var data = head.data; + + // Validate version: + // Should always be 0x00010000 + var version = int32(data[0], data[1], data[2], data[3]); + if (version >> 16 !== 1) { + info('Attempting to fix invalid version in head table: ' + version); + data[0] = 0; + data[1] = 1; + data[2] = 0; + data[3] = 0; + } + + var indexToLocFormat = int16(data[50], data[51]); + if (indexToLocFormat < 0 || indexToLocFormat > 1) { + info('Attempting to fix invalid indexToLocFormat in head table: ' + + indexToLocFormat); + + // The value of indexToLocFormat should be 0 if the loca table + // consists of short offsets, and should be 1 if the loca table + // consists of long offsets. + // + // The number of entries in the loca table should be numGlyphs + 1. + // + // Using this information, we can work backwards to deduce if the + // size of each offset in the loca table, and thus figure out the + // appropriate value for indexToLocFormat. + + var numGlyphsPlusOne = numGlyphs + 1; + if (locaLength === numGlyphsPlusOne << 1) { + // 0x0000 indicates the loca table consists of short offsets + data[50] = 0; + data[51] = 0; + } else if (locaLength === numGlyphsPlusOne << 2) { + // 0x0001 indicates the loca table consists of long offsets + data[50] = 0; + data[51] = 1; + } else { + warn('Could not fix indexToLocFormat: ' + indexToLocFormat); + } + } + } + + function sanitizeGlyphLocations(loca, glyf, numGlyphs, + isGlyphLocationsLong, hintsValid, + dupFirstEntry) { + var itemSize, itemDecode, itemEncode; + if (isGlyphLocationsLong) { + itemSize = 4; + itemDecode = function fontItemDecodeLong(data, offset) { + return (data[offset] << 24) | (data[offset + 1] << 16) | + (data[offset + 2] << 8) | data[offset + 3]; + }; + itemEncode = function fontItemEncodeLong(data, offset, value) { + data[offset] = (value >>> 24) & 0xFF; + data[offset + 1] = (value >> 16) & 0xFF; + data[offset + 2] = (value >> 8) & 0xFF; + data[offset + 3] = value & 0xFF; + }; + } else { + itemSize = 2; + itemDecode = function fontItemDecode(data, offset) { + return (data[offset] << 9) | (data[offset + 1] << 1); + }; + itemEncode = function fontItemEncode(data, offset, value) { + data[offset] = (value >> 9) & 0xFF; + data[offset + 1] = (value >> 1) & 0xFF; + }; + } + var locaData = loca.data; + var locaDataSize = itemSize * (1 + numGlyphs); + // is loca.data too short or long? + if (locaData.length !== locaDataSize) { + locaData = new Uint8Array(locaDataSize); + locaData.set(loca.data.subarray(0, locaDataSize)); + loca.data = locaData; + } + // removing the invalid glyphs + var oldGlyfData = glyf.data; + var oldGlyfDataLength = oldGlyfData.length; + var newGlyfData = new Uint8Array(oldGlyfDataLength); + var startOffset = itemDecode(locaData, 0); + var writeOffset = 0; + var missingGlyphData = {}; + itemEncode(locaData, 0, writeOffset); + var i, j; + for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) { + var endOffset = itemDecode(locaData, j); + if (endOffset > oldGlyfDataLength && + ((oldGlyfDataLength + 3) & ~3) === endOffset) { + // Aspose breaks fonts by aligning the glyphs to the qword, but not + // the glyf table size, which makes last glyph out of range. + endOffset = oldGlyfDataLength; + } + if (endOffset > oldGlyfDataLength) { + // glyph end offset points outside glyf data, rejecting the glyph + itemEncode(locaData, j, writeOffset); + startOffset = endOffset; + continue; + } + + if (startOffset === endOffset) { + missingGlyphData[i] = true; + } + + var newLength = sanitizeGlyph(oldGlyfData, startOffset, endOffset, + newGlyfData, writeOffset, hintsValid); + writeOffset += newLength; + itemEncode(locaData, j, writeOffset); + startOffset = endOffset; + } + + if (writeOffset === 0) { + // glyf table cannot be empty -- redoing the glyf and loca tables + // to have single glyph with one point + var simpleGlyph = new Uint8Array( + [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0]); + for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) { + itemEncode(locaData, j, simpleGlyph.length); + } + glyf.data = simpleGlyph; + return missingGlyphData; + } + + if (dupFirstEntry) { + var firstEntryLength = itemDecode(locaData, itemSize); + if (newGlyfData.length > firstEntryLength + writeOffset) { + glyf.data = newGlyfData.subarray(0, firstEntryLength + writeOffset); + } else { + glyf.data = new Uint8Array(firstEntryLength + writeOffset); + glyf.data.set(newGlyfData.subarray(0, writeOffset)); + } + glyf.data.set(newGlyfData.subarray(0, firstEntryLength), writeOffset); + itemEncode(loca.data, locaData.length - itemSize, + writeOffset + firstEntryLength); + } else { + glyf.data = newGlyfData.subarray(0, writeOffset); + } + return missingGlyphData; + } + + function readPostScriptTable(post, properties, maxpNumGlyphs) { + var start = (font.start ? font.start : 0) + post.offset; + font.pos = start; + + var length = post.length, end = start + length; + var version = font.getInt32(); + // skip rest to the tables + font.getBytes(28); + + var glyphNames; + var valid = true; + var i; + + switch (version) { + case 0x00010000: + glyphNames = MacStandardGlyphOrdering; + break; + case 0x00020000: + var numGlyphs = font.getUint16(); + if (numGlyphs !== maxpNumGlyphs) { + valid = false; + break; + } + var glyphNameIndexes = []; + for (i = 0; i < numGlyphs; ++i) { + var index = font.getUint16(); + if (index >= 32768) { + valid = false; + break; + } + glyphNameIndexes.push(index); + } + if (!valid) { + break; + } + var customNames = []; + var strBuf = []; + while (font.pos < end) { + var stringLength = font.getByte(); + strBuf.length = stringLength; + for (i = 0; i < stringLength; ++i) { + strBuf[i] = String.fromCharCode(font.getByte()); + } + customNames.push(strBuf.join('')); + } + glyphNames = []; + for (i = 0; i < numGlyphs; ++i) { + var j = glyphNameIndexes[i]; + if (j < 258) { + glyphNames.push(MacStandardGlyphOrdering[j]); + continue; + } + glyphNames.push(customNames[j - 258]); + } + break; + case 0x00030000: + break; + default: + warn('Unknown/unsupported post table version ' + version); + valid = false; + if (properties.defaultEncoding) { + glyphNames = properties.defaultEncoding; + } + break; + } + properties.glyphNames = glyphNames; + return valid; + } + + function readNameTable(nameTable) { + var start = (font.start ? font.start : 0) + nameTable.offset; + font.pos = start; + + var names = [[], []]; + var length = nameTable.length, end = start + length; + var format = font.getUint16(); + var FORMAT_0_HEADER_LENGTH = 6; + if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) { + // unsupported name table format or table "too" small + return names; + } + var numRecords = font.getUint16(); + var stringsStart = font.getUint16(); + var records = []; + var NAME_RECORD_LENGTH = 12; + var i, ii; + + for (i = 0; i < numRecords && + font.pos + NAME_RECORD_LENGTH <= end; i++) { + var r = { + platform: font.getUint16(), + encoding: font.getUint16(), + language: font.getUint16(), + name: font.getUint16(), + length: font.getUint16(), + offset: font.getUint16() + }; + // using only Macintosh and Windows platform/encoding names + if ((r.platform === 1 && r.encoding === 0 && r.language === 0) || + (r.platform === 3 && r.encoding === 1 && r.language === 0x409)) { + records.push(r); + } + } + for (i = 0, ii = records.length; i < ii; i++) { + var record = records[i]; + var pos = start + stringsStart + record.offset; + if (pos + record.length > end) { + continue; // outside of name table, ignoring + } + font.pos = pos; + var nameIndex = record.name; + if (record.encoding) { + // unicode + var str = ''; + for (var j = 0, jj = record.length; j < jj; j += 2) { + str += String.fromCharCode(font.getUint16()); + } + names[1][nameIndex] = str; + } else { + names[0][nameIndex] = bytesToString(font.getBytes(record.length)); + } + } + return names; + } + + var TTOpsStackDeltas = [ + 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, -2, 0, 0, -2, -5, + -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, -1, -1, + 1, -1, -999, 0, 1, 0, -1, -2, 0, -1, -2, -1, -1, 0, -1, -1, + 0, 0, -999, -999, -1, -1, -1, -1, -2, -999, -2, -2, -999, 0, -2, -2, + 0, 0, -2, 0, -2, 0, 0, 0, -2, -1, -1, 1, 1, 0, 0, -1, + -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, 0, -999, -1, -1, + -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + -2, -999, -999, -999, -999, -999, -1, -1, -2, -2, 0, 0, 0, 0, -1, -1, + -999, -2, -2, 0, 0, -1, -2, -2, 0, 0, 0, -1, -1, -1, -2]; + // 0xC0-DF == -1 and 0xE0-FF == -2 + + function sanitizeTTProgram(table, ttContext) { + var data = table.data; + var i = 0, j, n, b, funcId, pc, lastEndf = 0, lastDeff = 0; + var stack = []; + var callstack = []; + var functionsCalled = []; + var tooComplexToFollowFunctions = + ttContext.tooComplexToFollowFunctions; + var inFDEF = false, ifLevel = 0, inELSE = 0; + for (var ii = data.length; i < ii;) { + var op = data[i++]; + // The TrueType instruction set docs can be found at + // https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html + if (op === 0x40) { // NPUSHB - pushes n bytes + n = data[i++]; + if (inFDEF || inELSE) { + i += n; + } else { + for (j = 0; j < n; j++) { + stack.push(data[i++]); + } + } + } else if (op === 0x41) { // NPUSHW - pushes n words + n = data[i++]; + if (inFDEF || inELSE) { + i += n * 2; + } else { + for (j = 0; j < n; j++) { + b = data[i++]; + stack.push((b << 8) | data[i++]); + } + } + } else if ((op & 0xF8) === 0xB0) { // PUSHB - pushes bytes + n = op - 0xB0 + 1; + if (inFDEF || inELSE) { + i += n; + } else { + for (j = 0; j < n; j++) { + stack.push(data[i++]); + } + } + } else if ((op & 0xF8) === 0xB8) { // PUSHW - pushes words + n = op - 0xB8 + 1; + if (inFDEF || inELSE) { + i += n * 2; + } else { + for (j = 0; j < n; j++) { + b = data[i++]; + stack.push((b << 8) | data[i++]); + } + } + } else if (op === 0x2B && !tooComplexToFollowFunctions) { // CALL + if (!inFDEF && !inELSE) { + // collecting inforamtion about which functions are used + funcId = stack[stack.length - 1]; + ttContext.functionsUsed[funcId] = true; + if (funcId in ttContext.functionsStackDeltas) { + stack.length += ttContext.functionsStackDeltas[funcId]; + } else if (funcId in ttContext.functionsDefined && + functionsCalled.indexOf(funcId) < 0) { + callstack.push({data: data, i: i, stackTop: stack.length - 1}); + functionsCalled.push(funcId); + pc = ttContext.functionsDefined[funcId]; + if (!pc) { + warn('TT: CALL non-existent function'); + ttContext.hintsValid = false; + return; + } + data = pc.data; + i = pc.i; + } + } + } else if (op === 0x2C && !tooComplexToFollowFunctions) { // FDEF + if (inFDEF || inELSE) { + warn('TT: nested FDEFs not allowed'); + tooComplexToFollowFunctions = true; + } + inFDEF = true; + // collecting inforamtion about which functions are defined + lastDeff = i; + funcId = stack.pop(); + ttContext.functionsDefined[funcId] = {data: data, i: i}; + } else if (op === 0x2D) { // ENDF - end of function + if (inFDEF) { + inFDEF = false; + lastEndf = i; + } else { + pc = callstack.pop(); + if (!pc) { + warn('TT: ENDF bad stack'); + ttContext.hintsValid = false; + return; + } + funcId = functionsCalled.pop(); + data = pc.data; + i = pc.i; + ttContext.functionsStackDeltas[funcId] = + stack.length - pc.stackTop; + } + } else if (op === 0x89) { // IDEF - instruction definition + if (inFDEF || inELSE) { + warn('TT: nested IDEFs not allowed'); + tooComplexToFollowFunctions = true; + } + inFDEF = true; + // recording it as a function to track ENDF + lastDeff = i; + } else if (op === 0x58) { // IF + ++ifLevel; + } else if (op === 0x1B) { // ELSE + inELSE = ifLevel; + } else if (op === 0x59) { // EIF + if (inELSE === ifLevel) { + inELSE = 0; + } + --ifLevel; + } else if (op === 0x1C) { // JMPR + if (!inFDEF && !inELSE) { + var offset = stack[stack.length - 1]; + // only jumping forward to prevent infinite loop + if (offset > 0) { + i += offset - 1; + } + } + } + // Adjusting stack not extactly, but just enough to get function id + if (!inFDEF && !inELSE) { + var stackDelta = op <= 0x8E ? TTOpsStackDeltas[op] : + op >= 0xC0 && op <= 0xDF ? -1 : op >= 0xE0 ? -2 : 0; + if (op >= 0x71 && op <= 0x75) { + n = stack.pop(); + if (n === n) { + stackDelta = -n * 2; + } + } + while (stackDelta < 0 && stack.length > 0) { + stack.pop(); + stackDelta++; + } + while (stackDelta > 0) { + stack.push(NaN); // pushing any number into stack + stackDelta--; + } + } + } + ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions; + var content = [data]; + if (i > data.length) { + content.push(new Uint8Array(i - data.length)); + } + if (lastDeff > lastEndf) { + warn('TT: complementing a missing function tail'); + // new function definition started, but not finished + // complete function by [CLEAR, ENDF] + content.push(new Uint8Array([0x22, 0x2D])); + } + foldTTTable(table, content); + } + + function checkInvalidFunctions(ttContext, maxFunctionDefs) { + if (ttContext.tooComplexToFollowFunctions) { + return; + } + if (ttContext.functionsDefined.length > maxFunctionDefs) { + warn('TT: more functions defined than expected'); + ttContext.hintsValid = false; + return; + } + for (var j = 0, jj = ttContext.functionsUsed.length; j < jj; j++) { + if (j > maxFunctionDefs) { + warn('TT: invalid function id: ' + j); + ttContext.hintsValid = false; + return; + } + if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) { + warn('TT: undefined function: ' + j); + ttContext.hintsValid = false; + return; + } + } + } + + function foldTTTable(table, content) { + if (content.length > 1) { + // concatenating the content items + var newLength = 0; + var j, jj; + for (j = 0, jj = content.length; j < jj; j++) { + newLength += content[j].length; + } + newLength = (newLength + 3) & ~3; + var result = new Uint8Array(newLength); + var pos = 0; + for (j = 0, jj = content.length; j < jj; j++) { + result.set(content[j], pos); + pos += content[j].length; + } + table.data = result; + table.length = newLength; + } + } + + function sanitizeTTPrograms(fpgm, prep, cvt) { + var ttContext = { + functionsDefined: [], + functionsUsed: [], + functionsStackDeltas: [], + tooComplexToFollowFunctions: false, + hintsValid: true + }; + if (fpgm) { + sanitizeTTProgram(fpgm, ttContext); + } + if (prep) { + sanitizeTTProgram(prep, ttContext); + } + if (fpgm) { + checkInvalidFunctions(ttContext, maxFunctionDefs); + } + if (cvt && (cvt.length & 1)) { + var cvtData = new Uint8Array(cvt.length + 1); + cvtData.set(cvt.data); + cvt.data = cvtData; + } + return ttContext.hintsValid; + } + + // The following steps modify the original font data, making copy + font = new Stream(new Uint8Array(font.getBytes())); + + var VALID_TABLES = ['OS/2', 'cmap', 'head', 'hhea', 'hmtx', 'maxp', + 'name', 'post', 'loca', 'glyf', 'fpgm', 'prep', 'cvt ', 'CFF ']; + + var header = readOpenTypeHeader(font); + var numTables = header.numTables; + var cff, cffFile; + + var tables = { 'OS/2': null, cmap: null, head: null, hhea: null, + hmtx: null, maxp: null, name: null, post: null }; + var table; + for (var i = 0; i < numTables; i++) { + table = readTableEntry(font); + if (VALID_TABLES.indexOf(table.tag) < 0) { + continue; // skipping table if it's not a required or optional table + } + if (table.length === 0) { + continue; // skipping empty tables + } + tables[table.tag] = table; + } + + var isTrueType = !tables['CFF ']; + if (!isTrueType) { + // OpenType font + if ((header.version === 'OTTO' && properties.type !== 'CIDFontType2') || + !tables.head || !tables.hhea || !tables.maxp || !tables.post) { + // no major tables: throwing everything at CFFFont + cffFile = new Stream(tables['CFF '].data); + cff = new CFFFont(cffFile, properties); + + adjustWidths(properties); + + return this.convert(name, cff, properties); + } + + delete tables.glyf; + delete tables.loca; + delete tables.fpgm; + delete tables.prep; + delete tables['cvt ']; + this.isOpenType = true; + } else { + if (!tables.loca) { + error('Required "loca" table is not found'); + } + if (!tables.glyf) { + warn('Required "glyf" table is not found -- trying to recover.'); + // Note: We use `sanitizeGlyphLocations` to add dummy glyf data below. + tables.glyf = { + tag: 'glyf', + data: new Uint8Array(0), + }; + } + this.isOpenType = false; + } + + if (!tables.maxp) { + error('Required "maxp" table is not found'); + } + + font.pos = (font.start || 0) + tables.maxp.offset; + var version = font.getInt32(); + var numGlyphs = font.getUint16(); + var maxFunctionDefs = 0; + if (version >= 0x00010000 && tables.maxp.length >= 22) { + // maxZones can be invalid + font.pos += 8; + var maxZones = font.getUint16(); + if (maxZones > 2) { // reset to 2 if font has invalid maxZones + tables.maxp.data[14] = 0; + tables.maxp.data[15] = 2; + } + font.pos += 4; + maxFunctionDefs = font.getUint16(); + } + + var dupFirstEntry = false; + if (properties.type === 'CIDFontType2' && properties.toUnicode && + properties.toUnicode.get(0) > '\u0000') { + // oracle's defect (see 3427), duplicating first entry + dupFirstEntry = true; + numGlyphs++; + tables.maxp.data[4] = numGlyphs >> 8; + tables.maxp.data[5] = numGlyphs & 255; + } + + var hintsValid = sanitizeTTPrograms(tables.fpgm, tables.prep, + tables['cvt '], maxFunctionDefs); + if (!hintsValid) { + delete tables.fpgm; + delete tables.prep; + delete tables['cvt ']; + } + + // Ensure the hmtx table contains the advance width and + // sidebearings information for numGlyphs in the maxp table + sanitizeMetrics(font, tables.hhea, tables.hmtx, numGlyphs); + + if (!tables.head) { + error('Required "head" table is not found'); + } + + sanitizeHead(tables.head, numGlyphs, isTrueType ? tables.loca.length : 0); + + var missingGlyphs = {}; + if (isTrueType) { + var isGlyphLocationsLong = int16(tables.head.data[50], + tables.head.data[51]); + missingGlyphs = sanitizeGlyphLocations(tables.loca, tables.glyf, + numGlyphs, isGlyphLocationsLong, + hintsValid, dupFirstEntry); + } + + if (!tables.hhea) { + error('Required "hhea" table is not found'); + } + + // Sanitizer reduces the glyph advanceWidth to the maxAdvanceWidth + // Sometimes it's 0. That needs to be fixed + if (tables.hhea.data[10] === 0 && tables.hhea.data[11] === 0) { + tables.hhea.data[10] = 0xFF; + tables.hhea.data[11] = 0xFF; + } + + // Extract some more font properties from the OpenType head and + // hhea tables; yMin and descent value are always negative. + var metricsOverride = { + unitsPerEm: int16(tables.head.data[18], tables.head.data[19]), + yMax: int16(tables.head.data[42], tables.head.data[43]), + yMin: int16(tables.head.data[38], tables.head.data[39]) - 0x10000, + ascent: int16(tables.hhea.data[4], tables.hhea.data[5]), + descent: int16(tables.hhea.data[6], tables.hhea.data[7]) - 0x10000 + }; + + // PDF FontDescriptor metrics lie -- using data from actual font. + this.ascent = metricsOverride.ascent / metricsOverride.unitsPerEm; + this.descent = metricsOverride.descent / metricsOverride.unitsPerEm; + + // The 'post' table has glyphs names. + if (tables.post) { + var valid = readPostScriptTable(tables.post, properties, numGlyphs); + if (!valid) { + tables.post = null; + } + } + + var charCodeToGlyphId = [], charCode; + var toUnicode = properties.toUnicode, widths = properties.widths; + var skipToUnicode = (toUnicode instanceof IdentityToUnicodeMap || + toUnicode.length === 0x10000); + + // Helper function to try to skip mapping of empty glyphs. + // Note: In some cases, just relying on the glyph data doesn't work, + // hence we also use a few heuristics to fix various PDF files. + function hasGlyph(glyphId, charCode, widthCode) { + if (!missingGlyphs[glyphId]) { + return true; + } + if (!skipToUnicode && charCode >= 0 && toUnicode.has(charCode)) { + return true; + } + if (widths && widthCode >= 0 && isNum(widths[widthCode])) { + return true; + } + return false; + } + + if (properties.type === 'CIDFontType2') { + var cidToGidMap = properties.cidToGidMap || []; + var isCidToGidMapEmpty = cidToGidMap.length === 0; + + properties.cMap.forEach(function(charCode, cid) { + assert(cid <= 0xffff, 'Max size of CID is 65,535'); + var glyphId = -1; + if (isCidToGidMapEmpty) { + glyphId = charCode; + } else if (cidToGidMap[cid] !== undefined) { + glyphId = cidToGidMap[cid]; + } + + if (glyphId >= 0 && glyphId < numGlyphs && + hasGlyph(glyphId, charCode, cid)) { + charCodeToGlyphId[charCode] = glyphId; + } + }); + if (dupFirstEntry) { + charCodeToGlyphId[0] = numGlyphs - 1; + } + } else { + // Most of the following logic in this code branch is based on the + // 9.6.6.4 of the PDF spec. + var hasEncoding = + properties.differences.length > 0 || !!properties.baseEncodingName; + var cmapTable = + readCmapTable(tables.cmap, font, this.isSymbolicFont, hasEncoding); + var cmapPlatformId = cmapTable.platformId; + var cmapEncodingId = cmapTable.encodingId; + var cmapMappings = cmapTable.mappings; + var cmapMappingsLength = cmapMappings.length; + + // The spec seems to imply that if the font is symbolic the encoding + // should be ignored, this doesn't appear to work for 'preistabelle.pdf' + // where the the font is symbolic and it has an encoding. + if (hasEncoding && + (cmapPlatformId === 3 && cmapEncodingId === 1 || + cmapPlatformId === 1 && cmapEncodingId === 0) || + (cmapPlatformId === -1 && cmapEncodingId === -1 && // Temporary hack + !!Encodings[properties.baseEncodingName])) { // Temporary hack + // When no preferred cmap table was found and |baseEncodingName| is + // one of the predefined encodings, we seem to obtain a better + // |charCodeToGlyphId| map from the code below (fixes bug 1057544). + // TODO: Note that this is a hack which should be removed as soon as + // we have proper support for more exotic cmap tables. + + var baseEncoding = []; + if (properties.baseEncodingName === 'MacRomanEncoding' || + properties.baseEncodingName === 'WinAnsiEncoding') { + baseEncoding = Encodings[properties.baseEncodingName]; + } + for (charCode = 0; charCode < 256; charCode++) { + var glyphName; + if (this.differences && charCode in this.differences) { + glyphName = this.differences[charCode]; + } else if (charCode in baseEncoding && + baseEncoding[charCode] !== '') { + glyphName = baseEncoding[charCode]; + } else { + glyphName = Encodings.StandardEncoding[charCode]; + } + if (!glyphName) { + continue; + } + var unicodeOrCharCode, isUnicode = false; + if (cmapPlatformId === 3 && cmapEncodingId === 1) { + unicodeOrCharCode = GlyphsUnicode[glyphName]; + isUnicode = true; + } else if (cmapPlatformId === 1 && cmapEncodingId === 0) { + // TODO: the encoding needs to be updated with mac os table. + unicodeOrCharCode = Encodings.MacRomanEncoding.indexOf(glyphName); + } + + var found = false; + for (i = 0; i < cmapMappingsLength; ++i) { + if (cmapMappings[i].charCode !== unicodeOrCharCode) { + continue; + } + var code = isUnicode ? charCode : unicodeOrCharCode; + if (hasGlyph(cmapMappings[i].glyphId, code, -1)) { + charCodeToGlyphId[charCode] = cmapMappings[i].glyphId; + found = true; + break; + } + } + if (!found && properties.glyphNames) { + // Try to map using the post table. + var glyphId = properties.glyphNames.indexOf(glyphName); + if (glyphId > 0 && hasGlyph(glyphId, -1, -1)) { + charCodeToGlyphId[charCode] = glyphId; + found = true; + } + } + if (!found) { + charCodeToGlyphId[charCode] = 0; // notdef + } + } + } else if (cmapPlatformId === 0 && cmapEncodingId === 0) { + // Default Unicode semantics, use the charcodes as is. + for (i = 0; i < cmapMappingsLength; ++i) { + charCodeToGlyphId[cmapMappings[i].charCode] = + cmapMappings[i].glyphId; + } + } else { + // For (3, 0) cmap tables: + // The charcode key being stored in charCodeToGlyphId is the lower + // byte of the two-byte charcodes of the cmap table since according to + // the spec: 'each byte from the string shall be prepended with the + // high byte of the range [of charcodes in the cmap table], to form + // a two-byte character, which shall be used to select the + // associated glyph description from the subtable'. + // + // For (1, 0) cmap tables: + // 'single bytes from the string shall be used to look up the + // associated glyph descriptions from the subtable'. This means + // charcodes in the cmap will be single bytes, so no-op since + // glyph.charCode & 0xFF === glyph.charCode + for (i = 0; i < cmapMappingsLength; ++i) { + charCode = cmapMappings[i].charCode & 0xFF; + charCodeToGlyphId[charCode] = cmapMappings[i].glyphId; + } + } + } + + if (charCodeToGlyphId.length === 0) { + // defines at least one glyph + charCodeToGlyphId[0] = 0; + } + + // Converting glyphs and ids into font's cmap table + var newMapping = adjustMapping(charCodeToGlyphId, properties); + this.toFontChar = newMapping.toFontChar; + tables.cmap = { + tag: 'cmap', + data: createCmapTable(newMapping.charCodeToGlyphId, numGlyphs) + }; + + if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) { + tables['OS/2'] = { + tag: 'OS/2', + data: createOS2Table(properties, newMapping.charCodeToGlyphId, + metricsOverride) + }; + } + + // Rewrite the 'post' table if needed + if (!tables.post) { + tables.post = { + tag: 'post', + data: createPostTable(properties) + }; + } + + if (!isTrueType) { + try { + // Trying to repair CFF file + cffFile = new Stream(tables['CFF '].data); + var parser = new CFFParser(cffFile, properties); + cff = parser.parse(); + var compiler = new CFFCompiler(cff); + tables['CFF '].data = compiler.compile(); + } catch (e) { + warn('Failed to compile font ' + properties.loadedName); + } + } + + // Re-creating 'name' table + if (!tables.name) { + tables.name = { + tag: 'name', + data: createNameTable(this.name) + }; + } else { + // ... using existing 'name' table as prototype + var namePrototype = readNameTable(tables.name); + tables.name.data = createNameTable(name, namePrototype); + } + + var builder = new OpenTypeFileBuilder(header.version); + for (var tableTag in tables) { + builder.addTable(tableTag, tables[tableTag].data); + } + return builder.toArray(); + }, + + convert: function Font_convert(fontName, font, properties) { + // TODO: Check the charstring widths to determine this. + properties.fixedPitch = false; + + var mapping = font.getGlyphMapping(properties); + var newMapping = adjustMapping(mapping, properties); + this.toFontChar = newMapping.toFontChar; + var numGlyphs = font.numGlyphs; + + function getCharCodes(charCodeToGlyphId, glyphId) { + var charCodes = null; + for (var charCode in charCodeToGlyphId) { + if (glyphId === charCodeToGlyphId[charCode]) { + if (!charCodes) { + charCodes = []; + } + charCodes.push(charCode | 0); + } + } + return charCodes; + } + + function createCharCode(charCodeToGlyphId, glyphId) { + for (var charCode in charCodeToGlyphId) { + if (glyphId === charCodeToGlyphId[charCode]) { + return charCode | 0; + } + } + newMapping.charCodeToGlyphId[newMapping.nextAvailableFontCharCode] = + glyphId; + return newMapping.nextAvailableFontCharCode++; + } + + var seacs = font.seacs; + if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) { + var matrix = properties.fontMatrix || FONT_IDENTITY_MATRIX; + var charset = font.getCharset(); + var seacMap = Object.create(null); + for (var glyphId in seacs) { + glyphId |= 0; + var seac = seacs[glyphId]; + var baseGlyphName = Encodings.StandardEncoding[seac[2]]; + var accentGlyphName = Encodings.StandardEncoding[seac[3]]; + var baseGlyphId = charset.indexOf(baseGlyphName); + var accentGlyphId = charset.indexOf(accentGlyphName); + if (baseGlyphId < 0 || accentGlyphId < 0) { + continue; + } + var accentOffset = { + x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4], + y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5] + }; + + var charCodes = getCharCodes(mapping, glyphId); + if (!charCodes) { + // There's no point in mapping it if the char code was never mapped + // to begin with. + continue; + } + for (var i = 0, ii = charCodes.length; i < ii; i++) { + var charCode = charCodes[i]; + // Find a fontCharCode that maps to the base and accent glyphs. + // If one doesn't exists, create it. + var charCodeToGlyphId = newMapping.charCodeToGlyphId; + var baseFontCharCode = createCharCode(charCodeToGlyphId, + baseGlyphId); + var accentFontCharCode = createCharCode(charCodeToGlyphId, + accentGlyphId); + seacMap[charCode] = { + baseFontCharCode: baseFontCharCode, + accentFontCharCode: accentFontCharCode, + accentOffset: accentOffset + }; + } + } + properties.seacMap = seacMap; + } + + var unitsPerEm = 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0]; + + var builder = new OpenTypeFileBuilder('\x4F\x54\x54\x4F'); + // PostScript Font Program + builder.addTable('CFF ', font.data); + // OS/2 and Windows Specific metrics + builder.addTable('OS/2', createOS2Table(properties, + newMapping.charCodeToGlyphId)); + // Character to glyphs mapping + builder.addTable('cmap', createCmapTable(newMapping.charCodeToGlyphId, + numGlyphs)); + // Font header + builder.addTable('head', + '\x00\x01\x00\x00' + // Version number + '\x00\x00\x10\x00' + // fontRevision + '\x00\x00\x00\x00' + // checksumAdjustement + '\x5F\x0F\x3C\xF5' + // magicNumber + '\x00\x00' + // Flags + safeString16(unitsPerEm) + // unitsPerEM + '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // creation date + '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // modifification date + '\x00\x00' + // xMin + safeString16(properties.descent) + // yMin + '\x0F\xFF' + // xMax + safeString16(properties.ascent) + // yMax + string16(properties.italicAngle ? 2 : 0) + // macStyle + '\x00\x11' + // lowestRecPPEM + '\x00\x00' + // fontDirectionHint + '\x00\x00' + // indexToLocFormat + '\x00\x00'); // glyphDataFormat + + // Horizontal header + builder.addTable('hhea', + '\x00\x01\x00\x00' + // Version number + safeString16(properties.ascent) + // Typographic Ascent + safeString16(properties.descent) + // Typographic Descent + '\x00\x00' + // Line Gap + '\xFF\xFF' + // advanceWidthMax + '\x00\x00' + // minLeftSidebearing + '\x00\x00' + // minRightSidebearing + '\x00\x00' + // xMaxExtent + safeString16(properties.capHeight) + // caretSlopeRise + safeString16(Math.tan(properties.italicAngle) * + properties.xHeight) + // caretSlopeRun + '\x00\x00' + // caretOffset + '\x00\x00' + // -reserved- + '\x00\x00' + // -reserved- + '\x00\x00' + // -reserved- + '\x00\x00' + // -reserved- + '\x00\x00' + // metricDataFormat + string16(numGlyphs)); // Number of HMetrics + + // Horizontal metrics + builder.addTable('hmtx', (function fontFieldsHmtx() { + var charstrings = font.charstrings; + var cffWidths = font.cff ? font.cff.widths : null; + var hmtx = '\x00\x00\x00\x00'; // Fake .notdef + for (var i = 1, ii = numGlyphs; i < ii; i++) { + var width = 0; + if (charstrings) { + var charstring = charstrings[i - 1]; + width = 'width' in charstring ? charstring.width : 0; + } else if (cffWidths) { + width = Math.ceil(cffWidths[i] || 0); + } + hmtx += string16(width) + string16(0); + } + return hmtx; + })()); + + // Maximum profile + builder.addTable('maxp', + '\x00\x00\x50\x00' + // Version number + string16(numGlyphs)); // Num of glyphs + + // Naming tables + builder.addTable('name', createNameTable(fontName)); + + // PostScript informations + builder.addTable('post', createPostTable(properties)); + + return builder.toArray(); + }, + + /** + * Builds a char code to unicode map based on section 9.10 of the spec. + * @param {Object} properties Font properties object. + * @return {Object} A ToUnicodeMap object. + */ + buildToUnicode: function Font_buildToUnicode(properties) { + // Section 9.10.2 Mapping Character Codes to Unicode Values + if (properties.toUnicode && properties.toUnicode.length !== 0) { + return properties.toUnicode; + } + // According to the spec if the font is a simple font we should only map + // to unicode if the base encoding is MacRoman, MacExpert, or WinAnsi or + // the differences array only contains adobe standard or symbol set names, + // in pratice it seems better to always try to create a toUnicode + // map based of the default encoding. + var toUnicode, charcode; + if (!properties.composite /* is simple font */) { + toUnicode = []; + var encoding = properties.defaultEncoding.slice(); + var baseEncodingName = properties.baseEncodingName; + // Merge in the differences array. + var differences = properties.differences; + for (charcode in differences) { + encoding[charcode] = differences[charcode]; + } + for (charcode in encoding) { + // a) Map the character code to a character name. + var glyphName = encoding[charcode]; + // b) Look up the character name in the Adobe Glyph List (see the + // Bibliography) to obtain the corresponding Unicode value. + if (glyphName === '') { + continue; + } else if (GlyphsUnicode[glyphName] === undefined) { + // (undocumented) c) Few heuristics to recognize unknown glyphs + // NOTE: Adobe Reader does not do this step, but OSX Preview does + var code = 0; + switch (glyphName[0]) { + case 'G': // Gxx glyph + if (glyphName.length === 3) { + code = parseInt(glyphName.substr(1), 16); + } + break; + case 'g': // g00xx glyph + if (glyphName.length === 5) { + code = parseInt(glyphName.substr(1), 16); + } + break; + case 'C': // Cddd glyph + case 'c': // cddd glyph + if (glyphName.length >= 3) { + code = +glyphName.substr(1); + } + break; + } + if (code) { + // If |baseEncodingName| is one the predefined encodings, + // and |code| equals |charcode|, using the glyph defined in the + // baseEncoding seems to yield a better |toUnicode| mapping + // (fixes issue 5070). + if (baseEncodingName && code === +charcode) { + var baseEncoding = Encodings[baseEncodingName]; + if (baseEncoding && (glyphName = baseEncoding[charcode])) { + toUnicode[charcode] = + String.fromCharCode(GlyphsUnicode[glyphName]); + continue; + } + } + toUnicode[charcode] = String.fromCharCode(code); + } + continue; + } + toUnicode[charcode] = String.fromCharCode(GlyphsUnicode[glyphName]); + } + return new ToUnicodeMap(toUnicode); + } + // If the font is a composite font that uses one of the predefined CMaps + // listed in Table 118 (except Identity–H and Identity–V) or whose + // descendant CIDFont uses the Adobe-GB1, Adobe-CNS1, Adobe-Japan1, or + // Adobe-Korea1 character collection: + if (properties.composite && ( + (properties.cMap.builtInCMap && + !(properties.cMap instanceof IdentityCMap)) || + (properties.cidSystemInfo.registry === 'Adobe' && + (properties.cidSystemInfo.ordering === 'GB1' || + properties.cidSystemInfo.ordering === 'CNS1' || + properties.cidSystemInfo.ordering === 'Japan1' || + properties.cidSystemInfo.ordering === 'Korea1')))) { + // Then: + // a) Map the character code to a character identifier (CID) according + // to the font’s CMap. + // b) Obtain the registry and ordering of the character collection used + // by the font’s CMap (for example, Adobe and Japan1) from its + // CIDSystemInfo dictionary. + var registry = properties.cidSystemInfo.registry; + var ordering = properties.cidSystemInfo.ordering; + // c) Construct a second CMap name by concatenating the registry and + // ordering obtained in step (b) in the format registry–ordering–UCS2 + // (for example, Adobe–Japan1–UCS2). + var ucs2CMapName = new Name(registry + '-' + ordering + '-UCS2'); + // d) Obtain the CMap with the name constructed in step (c) (available + // from the ASN Web site; see the Bibliography). + var ucs2CMap = CMapFactory.create(ucs2CMapName, + { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null); + var cMap = properties.cMap; + toUnicode = []; + cMap.forEach(function(charcode, cid) { + assert(cid <= 0xffff, 'Max size of CID is 65,535'); + // e) Map the CID obtained in step (a) according to the CMap obtained + // in step (d), producing a Unicode value. + var ucs2 = ucs2CMap.lookup(cid); + if (ucs2) { + toUnicode[charcode] = + String.fromCharCode((ucs2.charCodeAt(0) << 8) + + ucs2.charCodeAt(1)); + } + }); + return new ToUnicodeMap(toUnicode); + } + + // The viewer's choice, just use an identity map. + return new IdentityToUnicodeMap(properties.firstChar, + properties.lastChar); + }, + + get spaceWidth() { + if ('_shadowWidth' in this) { + return this._shadowWidth; + } + + // trying to estimate space character width + var possibleSpaceReplacements = ['space', 'minus', 'one', 'i']; + var width; + for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) { + var glyphName = possibleSpaceReplacements[i]; + // if possible, getting width by glyph name + if (glyphName in this.widths) { + width = this.widths[glyphName]; + break; + } + var glyphUnicode = GlyphsUnicode[glyphName]; + // finding the charcode via unicodeToCID map + var charcode = 0; + if (this.composite) { + if (this.cMap.contains(glyphUnicode)) { + charcode = this.cMap.lookup(glyphUnicode); + } + } + // ... via toUnicode map + if (!charcode && this.toUnicode) { + charcode = this.toUnicode.charCodeOf(glyphUnicode); + } + // setting it to unicode if negative or undefined + if (charcode <= 0) { + charcode = glyphUnicode; + } + // trying to get width via charcode + width = this.widths[charcode]; + if (width) { + break; // the non-zero width found + } + } + width = width || this.defaultWidth; + // Do not shadow the property here. See discussion: + // https://github.com/mozilla/pdf.js/pull/2127#discussion_r1662280 + this._shadowWidth = width; + return width; + }, + + charToGlyph: function Font_charToGlyph(charcode, isSpace) { + var fontCharCode, width, operatorListId; + + var widthCode = charcode; + if (this.cMap && this.cMap.contains(charcode)) { + widthCode = this.cMap.lookup(charcode); + } + width = this.widths[widthCode]; + width = isNum(width) ? width : this.defaultWidth; + var vmetric = this.vmetrics && this.vmetrics[widthCode]; + + var unicode = this.toUnicode.get(charcode) || charcode; + if (typeof unicode === 'number') { + unicode = String.fromCharCode(unicode); + } + + // First try the toFontChar map, if it's not there then try falling + // back to the char code. + fontCharCode = this.toFontChar[charcode] || charcode; + if (this.missingFile) { + fontCharCode = mapSpecialUnicodeValues(fontCharCode); + } + + if (this.isType3Font) { + // Font char code in this case is actually a glyph name. + operatorListId = fontCharCode; + } + + var accent = null; + if (this.seacMap && this.seacMap[charcode]) { + var seac = this.seacMap[charcode]; + fontCharCode = seac.baseFontCharCode; + accent = { + fontChar: String.fromCharCode(seac.accentFontCharCode), + offset: seac.accentOffset + }; + } + + var fontChar = String.fromCharCode(fontCharCode); + + var glyph = this.glyphCache[charcode]; + if (!glyph || + !glyph.matchesForCache(fontChar, unicode, accent, width, vmetric, + operatorListId, isSpace)) { + glyph = new Glyph(fontChar, unicode, accent, width, vmetric, + operatorListId, isSpace); + this.glyphCache[charcode] = glyph; + } + return glyph; + }, + + charsToGlyphs: function Font_charsToGlyphs(chars) { + var charsCache = this.charsCache; + var glyphs, glyph, charcode; + + // if we translated this string before, just grab it from the cache + if (charsCache) { + glyphs = charsCache[chars]; + if (glyphs) { + return glyphs; + } + } + + // lazily create the translation cache + if (!charsCache) { + charsCache = this.charsCache = Object.create(null); + } + + glyphs = []; + var charsCacheKey = chars; + var i = 0, ii; + + if (this.cMap) { + // composite fonts have multi-byte strings convert the string from + // single-byte to multi-byte + var c = {}; + while (i < chars.length) { + this.cMap.readCharCode(chars, i, c); + charcode = c.charcode; + var length = c.length; + i += length; + // Space is char with code 0x20 and length 1 in multiple-byte codes. + var isSpace = length === 1 && chars.charCodeAt(i - 1) === 0x20; + glyph = this.charToGlyph(charcode, isSpace); + glyphs.push(glyph); + } + } else { + for (i = 0, ii = chars.length; i < ii; ++i) { + charcode = chars.charCodeAt(i); + glyph = this.charToGlyph(charcode, charcode === 0x20); + glyphs.push(glyph); + } + } + + // Enter the translated string into the cache + return (charsCache[charsCacheKey] = glyphs); + } + }; + + return Font; +})(); + +var ErrorFont = (function ErrorFontClosure() { + function ErrorFont(error) { + this.error = error; + this.loadedName = 'g_font_error'; + this.loading = false; + } + + ErrorFont.prototype = { + charsToGlyphs: function ErrorFont_charsToGlyphs() { + return []; + }, + exportData: function ErrorFont_exportData() { + return {error: this.error}; + } + }; + + return ErrorFont; +})(); + +/** + * Shared logic for building a char code to glyph id mapping for Type1 and + * simple CFF fonts. See section 9.6.6.2 of the spec. + * @param {Object} properties Font properties object. + * @param {Object} builtInEncoding The encoding contained within the actual font + * data. + * @param {Array} Array of glyph names where the index is the glyph ID. + * @returns {Object} A char code to glyph ID map. + */ +function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) { + var charCodeToGlyphId = Object.create(null); + var glyphId, charCode, baseEncoding; + + if (properties.baseEncodingName) { + // If a valid base encoding name was used, the mapping is initialized with + // that. + baseEncoding = Encodings[properties.baseEncodingName]; + for (charCode = 0; charCode < baseEncoding.length; charCode++) { + glyphId = glyphNames.indexOf(baseEncoding[charCode]); + if (glyphId >= 0) { + charCodeToGlyphId[charCode] = glyphId; + } else { + charCodeToGlyphId[charCode] = 0; // notdef + } + } + } else if (!!(properties.flags & FontFlags.Symbolic)) { + // For a symbolic font the encoding should be the fonts built-in + // encoding. + for (charCode in builtInEncoding) { + charCodeToGlyphId[charCode] = builtInEncoding[charCode]; + } + } else { + // For non-symbolic fonts that don't have a base encoding the standard + // encoding should be used. + baseEncoding = Encodings.StandardEncoding; + for (charCode = 0; charCode < baseEncoding.length; charCode++) { + glyphId = glyphNames.indexOf(baseEncoding[charCode]); + if (glyphId >= 0) { + charCodeToGlyphId[charCode] = glyphId; + } else { + charCodeToGlyphId[charCode] = 0; // notdef + } + } + } + + // Lastly, merge in the differences. + var differences = properties.differences; + if (differences) { + for (charCode in differences) { + var glyphName = differences[charCode]; + glyphId = glyphNames.indexOf(glyphName); + if (glyphId >= 0) { + charCodeToGlyphId[charCode] = glyphId; + } else { + charCodeToGlyphId[charCode] = 0; // notdef + } + } + } + return charCodeToGlyphId; +} + +/* + * CharStrings are encoded following the the CharString Encoding sequence + * describe in Chapter 6 of the "Adobe Type1 Font Format" specification. + * The value in a byte indicates a command, a number, or subsequent bytes + * that are to be interpreted in a special way. + * + * CharString Number Encoding: + * A CharString byte containing the values from 32 through 255 inclusive + * indicate an integer. These values are decoded in four ranges. + * + * 1. A CharString byte containing a value, v, between 32 and 246 inclusive, + * indicate the integer v - 139. Thus, the integer values from -107 through + * 107 inclusive may be encoded in single byte. + * + * 2. A CharString byte containing a value, v, between 247 and 250 inclusive, + * indicates an integer involving the next byte, w, according to the formula: + * [(v - 247) x 256] + w + 108 + * + * 3. A CharString byte containing a value, v, between 251 and 254 inclusive, + * indicates an integer involving the next byte, w, according to the formula: + * -[(v - 251) * 256] - w - 108 + * + * 4. A CharString containing the value 255 indicates that the next 4 bytes + * are a two complement signed integer. The first of these bytes contains the + * highest order bits, the second byte contains the next higher order bits + * and the fourth byte contain the lowest order bits. + * + * + * CharString Command Encoding: + * CharStrings commands are encoded in 1 or 2 bytes. + * + * Single byte commands are encoded in 1 byte that contains a value between + * 0 and 31 inclusive. + * If a command byte contains the value 12, then the value in the next byte + * indicates a command. This "escape" mechanism allows many extra commands + * to be encoded and this encoding technique helps to minimize the length of + * the charStrings. + */ +var Type1CharString = (function Type1CharStringClosure() { + var COMMAND_MAP = { + 'hstem': [1], + 'vstem': [3], + 'vmoveto': [4], + 'rlineto': [5], + 'hlineto': [6], + 'vlineto': [7], + 'rrcurveto': [8], + 'callsubr': [10], + 'flex': [12, 35], + 'drop' : [12, 18], + 'endchar': [14], + 'rmoveto': [21], + 'hmoveto': [22], + 'vhcurveto': [30], + 'hvcurveto': [31] + }; + + function Type1CharString() { + this.width = 0; + this.lsb = 0; + this.flexing = false; + this.output = []; + this.stack = []; + } + + Type1CharString.prototype = { + convert: function Type1CharString_convert(encoded, subrs) { + var count = encoded.length; + var error = false; + var wx, sbx, subrNumber; + for (var i = 0; i < count; i++) { + var value = encoded[i]; + if (value < 32) { + if (value === 12) { + value = (value << 8) + encoded[++i]; + } + switch (value) { + case 1: // hstem + if (!HINTING_ENABLED) { + this.stack = []; + break; + } + error = this.executeCommand(2, COMMAND_MAP.hstem); + break; + case 3: // vstem + if (!HINTING_ENABLED) { + this.stack = []; + break; + } + error = this.executeCommand(2, COMMAND_MAP.vstem); + break; + case 4: // vmoveto + if (this.flexing) { + if (this.stack.length < 1) { + error = true; + break; + } + // Add the dx for flex and but also swap the values so they are + // the right order. + var dy = this.stack.pop(); + this.stack.push(0, dy); + break; + } + error = this.executeCommand(1, COMMAND_MAP.vmoveto); + break; + case 5: // rlineto + error = this.executeCommand(2, COMMAND_MAP.rlineto); + break; + case 6: // hlineto + error = this.executeCommand(1, COMMAND_MAP.hlineto); + break; + case 7: // vlineto + error = this.executeCommand(1, COMMAND_MAP.vlineto); + break; + case 8: // rrcurveto + error = this.executeCommand(6, COMMAND_MAP.rrcurveto); + break; + case 9: // closepath + // closepath is a Type1 command that does not take argument and is + // useless in Type2 and it can simply be ignored. + this.stack = []; + break; + case 10: // callsubr + if (this.stack.length < 1) { + error = true; + break; + } + subrNumber = this.stack.pop(); + error = this.convert(subrs[subrNumber], subrs); + break; + case 11: // return + return error; + case 13: // hsbw + if (this.stack.length < 2) { + error = true; + break; + } + // To convert to type2 we have to move the width value to the + // first part of the charstring and then use hmoveto with lsb. + wx = this.stack.pop(); + sbx = this.stack.pop(); + this.lsb = sbx; + this.width = wx; + this.stack.push(wx, sbx); + error = this.executeCommand(2, COMMAND_MAP.hmoveto); + break; + case 14: // endchar + this.output.push(COMMAND_MAP.endchar[0]); + break; + case 21: // rmoveto + if (this.flexing) { + break; + } + error = this.executeCommand(2, COMMAND_MAP.rmoveto); + break; + case 22: // hmoveto + if (this.flexing) { + // Add the dy for flex. + this.stack.push(0); + break; + } + error = this.executeCommand(1, COMMAND_MAP.hmoveto); + break; + case 30: // vhcurveto + error = this.executeCommand(4, COMMAND_MAP.vhcurveto); + break; + case 31: // hvcurveto + error = this.executeCommand(4, COMMAND_MAP.hvcurveto); + break; + case (12 << 8) + 0: // dotsection + // dotsection is a Type1 command to specify some hinting feature + // for dots that do not take a parameter and it can safely be + // ignored for Type2. + this.stack = []; + break; + case (12 << 8) + 1: // vstem3 + if (!HINTING_ENABLED) { + this.stack = []; + break; + } + // [vh]stem3 are Type1 only and Type2 supports [vh]stem with + // multiple parameters, so instead of returning [vh]stem3 take a + // shortcut and return [vhstem] instead. + error = this.executeCommand(2, COMMAND_MAP.vstem); + break; + case (12 << 8) + 2: // hstem3 + if (!HINTING_ENABLED) { + this.stack = []; + break; + } + // See vstem3. + error = this.executeCommand(2, COMMAND_MAP.hstem); + break; + case (12 << 8) + 6: // seac + // seac is like type 2's special endchar but it doesn't use the + // first argument asb, so remove it. + if (SEAC_ANALYSIS_ENABLED) { + this.seac = this.stack.splice(-4, 4); + error = this.executeCommand(0, COMMAND_MAP.endchar); + } else { + error = this.executeCommand(4, COMMAND_MAP.endchar); + } + break; + case (12 << 8) + 7: // sbw + if (this.stack.length < 4) { + error = true; + break; + } + // To convert to type2 we have to move the width value to the + // first part of the charstring and then use rmoveto with + // (dx, dy). The height argument will not be used for vmtx and + // vhea tables reconstruction -- ignoring it. + var wy = this.stack.pop(); + wx = this.stack.pop(); + var sby = this.stack.pop(); + sbx = this.stack.pop(); + this.lsb = sbx; + this.width = wx; + this.stack.push(wx, sbx, sby); + error = this.executeCommand(3, COMMAND_MAP.rmoveto); + break; + case (12 << 8) + 12: // div + if (this.stack.length < 2) { + error = true; + break; + } + var num2 = this.stack.pop(); + var num1 = this.stack.pop(); + this.stack.push(num1 / num2); + break; + case (12 << 8) + 16: // callothersubr + if (this.stack.length < 2) { + error = true; + break; + } + subrNumber = this.stack.pop(); + var numArgs = this.stack.pop(); + if (subrNumber === 0 && numArgs === 3) { + var flexArgs = this.stack.splice(this.stack.length - 17, 17); + this.stack.push( + flexArgs[2] + flexArgs[0], // bcp1x + rpx + flexArgs[3] + flexArgs[1], // bcp1y + rpy + flexArgs[4], // bcp2x + flexArgs[5], // bcp2y + flexArgs[6], // p2x + flexArgs[7], // p2y + flexArgs[8], // bcp3x + flexArgs[9], // bcp3y + flexArgs[10], // bcp4x + flexArgs[11], // bcp4y + flexArgs[12], // p3x + flexArgs[13], // p3y + flexArgs[14] // flexDepth + // 15 = finalx unused by flex + // 16 = finaly unused by flex + ); + error = this.executeCommand(13, COMMAND_MAP.flex, true); + this.flexing = false; + this.stack.push(flexArgs[15], flexArgs[16]); + } else if (subrNumber === 1 && numArgs === 0) { + this.flexing = true; + } + break; + case (12 << 8) + 17: // pop + // Ignore this since it is only used with othersubr. + break; + case (12 << 8) + 33: // setcurrentpoint + // Ignore for now. + this.stack = []; + break; + default: + warn('Unknown type 1 charstring command of "' + value + '"'); + break; + } + if (error) { + break; + } + continue; + } else if (value <= 246) { + value = value - 139; + } else if (value <= 250) { + value = ((value - 247) * 256) + encoded[++i] + 108; + } else if (value <= 254) { + value = -((value - 251) * 256) - encoded[++i] - 108; + } else { + value = (encoded[++i] & 0xff) << 24 | (encoded[++i] & 0xff) << 16 | + (encoded[++i] & 0xff) << 8 | (encoded[++i] & 0xff) << 0; + } + this.stack.push(value); + } + return error; + }, + + executeCommand: function(howManyArgs, command, keepStack) { + var stackLength = this.stack.length; + if (howManyArgs > stackLength) { + return true; + } + var start = stackLength - howManyArgs; + for (var i = start; i < stackLength; i++) { + var value = this.stack[i]; + if (value === (value | 0)) { // int + this.output.push(28, (value >> 8) & 0xff, value & 0xff); + } else { // fixed point + value = (65536 * value) | 0; + this.output.push(255, + (value >> 24) & 0xFF, + (value >> 16) & 0xFF, + (value >> 8) & 0xFF, + value & 0xFF); + } + } + this.output.push.apply(this.output, command); + if (keepStack) { + this.stack.splice(start, howManyArgs); + } else { + this.stack.length = 0; + } + return false; + } + }; + + return Type1CharString; +})(); + +/* + * Type1Parser encapsulate the needed code for parsing a Type1 font + * program. Some of its logic depends on the Type2 charstrings + * structure. + * Note: this doesn't really parse the font since that would require evaluation + * of PostScript, but it is possible in most cases to extract what we need + * without a full parse. + */ +var Type1Parser = (function Type1ParserClosure() { + /* + * Decrypt a Sequence of Ciphertext Bytes to Produce the Original Sequence + * of Plaintext Bytes. The function took a key as a parameter which can be + * for decrypting the eexec block of for decoding charStrings. + */ + var EEXEC_ENCRYPT_KEY = 55665; + var CHAR_STRS_ENCRYPT_KEY = 4330; + + function isHexDigit(code) { + return code >= 48 && code <= 57 || // '0'-'9' + code >= 65 && code <= 70 || // 'A'-'F' + code >= 97 && code <= 102; // 'a'-'f' + } + + function decrypt(data, key, discardNumber) { + var r = key | 0, c1 = 52845, c2 = 22719; + var count = data.length; + var decrypted = new Uint8Array(count); + for (var i = 0; i < count; i++) { + var value = data[i]; + decrypted[i] = value ^ (r >> 8); + r = ((value + r) * c1 + c2) & ((1 << 16) - 1); + } + return Array.prototype.slice.call(decrypted, discardNumber); + } + + function decryptAscii(data, key, discardNumber) { + var r = key | 0, c1 = 52845, c2 = 22719; + var count = data.length, maybeLength = count >>> 1; + var decrypted = new Uint8Array(maybeLength); + var i, j; + for (i = 0, j = 0; i < count; i++) { + var digit1 = data[i]; + if (!isHexDigit(digit1)) { + continue; + } + i++; + var digit2; + while (i < count && !isHexDigit(digit2 = data[i])) { + i++; + } + if (i < count) { + var value = parseInt(String.fromCharCode(digit1, digit2), 16); + decrypted[j++] = value ^ (r >> 8); + r = ((value + r) * c1 + c2) & ((1 << 16) - 1); + } + } + return Array.prototype.slice.call(decrypted, discardNumber, j); + } + + function isSpecial(c) { + return c === 0x2F || // '/' + c === 0x5B || c === 0x5D || // '[', ']' + c === 0x7B || c === 0x7D || // '{', '}' + c === 0x28 || c === 0x29; // '(', ')' + } + + function Type1Parser(stream, encrypted) { + if (encrypted) { + var data = stream.getBytes(); + var isBinary = !(isHexDigit(data[0]) && isHexDigit(data[1]) && + isHexDigit(data[2]) && isHexDigit(data[3])); + stream = new Stream(isBinary ? decrypt(data, EEXEC_ENCRYPT_KEY, 4) : + decryptAscii(data, EEXEC_ENCRYPT_KEY, 4)); + } + this.stream = stream; + this.nextChar(); + } + + Type1Parser.prototype = { + readNumberArray: function Type1Parser_readNumberArray() { + this.getToken(); // read '[' or '{' (arrays can start with either) + var array = []; + while (true) { + var token = this.getToken(); + if (token === null || token === ']' || token === '}') { + break; + } + array.push(parseFloat(token || 0)); + } + return array; + }, + + readNumber: function Type1Parser_readNumber() { + var token = this.getToken(); + return parseFloat(token || 0); + }, + + readInt: function Type1Parser_readInt() { + // Use '| 0' to prevent setting a double into length such as the double + // does not flow into the loop variable. + var token = this.getToken(); + return parseInt(token || 0, 10) | 0; + }, + + readBoolean: function Type1Parser_readBoolean() { + var token = this.getToken(); + + // Use 1 and 0 since that's what type2 charstrings use. + return token === 'true' ? 1 : 0; + }, + + nextChar : function Type1_nextChar() { + return (this.currentChar = this.stream.getByte()); + }, + + getToken: function Type1Parser_getToken() { + // Eat whitespace and comments. + var comment = false; + var ch = this.currentChar; + while (true) { + if (ch === -1) { + return null; + } + + if (comment) { + if (ch === 0x0A || ch === 0x0D) { + comment = false; + } + } else if (ch === 0x25) { // '%' + comment = true; + } else if (!Lexer.isSpace(ch)) { + break; + } + ch = this.nextChar(); + } + if (isSpecial(ch)) { + this.nextChar(); + return String.fromCharCode(ch); + } + var token = ''; + do { + token += String.fromCharCode(ch); + ch = this.nextChar(); + } while (ch >= 0 && !Lexer.isSpace(ch) && !isSpecial(ch)); + return token; + }, + + /* + * Returns an object containing a Subrs array and a CharStrings + * array extracted from and eexec encrypted block of data + */ + extractFontProgram: function Type1Parser_extractFontProgram() { + var stream = this.stream; + + var subrs = [], charstrings = []; + var program = { + subrs: [], + charstrings: [], + properties: { + 'privateData': { + 'lenIV': 4 + } + } + }; + var token, length, data, lenIV, encoded; + while ((token = this.getToken()) !== null) { + if (token !== '/') { + continue; + } + token = this.getToken(); + switch (token) { + case 'CharStrings': + // The number immediately following CharStrings must be greater or + // equal to the number of CharStrings. + this.getToken(); + this.getToken(); // read in 'dict' + this.getToken(); // read in 'dup' + this.getToken(); // read in 'begin' + while(true) { + token = this.getToken(); + if (token === null || token === 'end') { + break; + } + + if (token !== '/') { + continue; + } + var glyph = this.getToken(); + length = this.readInt(); + this.getToken(); // read in 'RD' or '-|' + data = stream.makeSubStream(stream.pos, length); + lenIV = program.properties.privateData['lenIV']; + encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV); + // Skip past the required space and binary data. + stream.skip(length); + this.nextChar(); + token = this.getToken(); // read in 'ND' or '|-' + if (token === 'noaccess') { + this.getToken(); // read in 'def' + } + charstrings.push({ + glyph: glyph, + encoded: encoded + }); + } + break; + case 'Subrs': + var num = this.readInt(); + this.getToken(); // read in 'array' + while ((token = this.getToken()) === 'dup') { + var index = this.readInt(); + length = this.readInt(); + this.getToken(); // read in 'RD' or '-|' + data = stream.makeSubStream(stream.pos, length); + lenIV = program.properties.privateData['lenIV']; + encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV); + // Skip past the required space and binary data. + stream.skip(length); + this.nextChar(); + token = this.getToken(); // read in 'NP' or '|' + if (token === 'noaccess') { + this.getToken(); // read in 'put' + } + subrs[index] = encoded; + } + break; + case 'BlueValues': + case 'OtherBlues': + case 'FamilyBlues': + case 'FamilyOtherBlues': + var blueArray = this.readNumberArray(); + // *Blue* values may contain invalid data: disables reading of + // those values when hinting is disabled. + if (blueArray.length > 0 && (blueArray.length % 2) === 0 && + HINTING_ENABLED) { + program.properties.privateData[token] = blueArray; + } + break; + case 'StemSnapH': + case 'StemSnapV': + program.properties.privateData[token] = this.readNumberArray(); + break; + case 'StdHW': + case 'StdVW': + program.properties.privateData[token] = + this.readNumberArray()[0]; + break; + case 'BlueShift': + case 'lenIV': + case 'BlueFuzz': + case 'BlueScale': + case 'LanguageGroup': + case 'ExpansionFactor': + program.properties.privateData[token] = this.readNumber(); + break; + case 'ForceBold': + program.properties.privateData[token] = this.readBoolean(); + break; + } + } + + for (var i = 0; i < charstrings.length; i++) { + glyph = charstrings[i].glyph; + encoded = charstrings[i].encoded; + var charString = new Type1CharString(); + var error = charString.convert(encoded, subrs); + var output = charString.output; + if (error) { + // It seems when FreeType encounters an error while evaluating a glyph + // that it completely ignores the glyph so we'll mimic that behaviour + // here and put an endchar to make the validator happy. + output = [14]; + } + program.charstrings.push({ + glyphName: glyph, + charstring: output, + width: charString.width, + lsb: charString.lsb, + seac: charString.seac + }); + } + + return program; + }, + + extractFontHeader: function Type1Parser_extractFontHeader(properties) { + var token; + while ((token = this.getToken()) !== null) { + if (token !== '/') { + continue; + } + token = this.getToken(); + switch (token) { + case 'FontMatrix': + var matrix = this.readNumberArray(); + properties.fontMatrix = matrix; + break; + case 'Encoding': + var encodingArg = this.getToken(); + var encoding; + if (!/^\d+$/.test(encodingArg)) { + // encoding name is specified + encoding = Encodings[encodingArg]; + } else { + encoding = []; + var size = parseInt(encodingArg, 10) | 0; + this.getToken(); // read in 'array' + + for (var j = 0; j < size; j++) { + token = this.getToken(); + // skipping till first dup or def (e.g. ignoring for statement) + while (token !== 'dup' && token !== 'def') { + token = this.getToken(); + if (token === null) { + return; // invalid header + } + } + if (token === 'def') { + break; // read all array data + } + var index = this.readInt(); + this.getToken(); // read in '/' + var glyph = this.getToken(); + encoding[index] = glyph; + this.getToken(); // read the in 'put' + } + } + properties.builtInEncoding = encoding; + break; + case 'FontBBox': + var fontBBox = this.readNumberArray(); + // adjusting ascent/descent + properties.ascent = fontBBox[3]; + properties.descent = fontBBox[1]; + properties.ascentScaled = true; + break; + } + } + } + }; + + return Type1Parser; +})(); + +/** + * The CFF class takes a Type1 file and wrap it into a + * 'Compact Font Format' which itself embed Type2 charstrings. + */ +var CFFStandardStrings = [ + '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent', + 'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus', + 'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four', + 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less', + 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', + 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', + 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', 'asciicircum', + 'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', + 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', + 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent', + 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency', + 'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft', + 'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl', + 'periodcentered', 'paragraph', 'bullet', 'quotesinglbase', 'quotedblbase', + 'quotedblright', 'guillemotright', 'ellipsis', 'perthousand', 'questiondown', + 'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve', 'dotaccent', + 'dieresis', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron', 'emdash', + 'AE', 'ordfeminine', 'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae', + 'dotlessi', 'lslash', 'oslash', 'oe', 'germandbls', 'onesuperior', + 'logicalnot', 'mu', 'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn', + 'onequarter', 'divide', 'brokenbar', 'degree', 'thorn', 'threequarters', + 'twosuperior', 'registered', 'minus', 'eth', 'multiply', 'threesuperior', + 'copyright', 'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring', + 'Atilde', 'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave', + 'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute', + 'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute', + 'Ucircumflex', 'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron', + 'aacute', 'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde', + 'ccedilla', 'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute', + 'icircumflex', 'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex', + 'odieresis', 'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex', + 'udieresis', 'ugrave', 'yacute', 'ydieresis', 'zcaron', 'exclamsmall', + 'Hungarumlautsmall', 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', + 'Acutesmall', 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader', + 'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle', + 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', + 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'commasuperior', + 'threequartersemdash', 'periodsuperior', 'questionsmall', 'asuperior', + 'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', 'isuperior', + 'lsuperior', 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior', + 'tsuperior', 'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior', + 'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall', 'Bsmall', + 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall', + 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall', + 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall', + 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah', + 'Tildesmall', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall', + 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall', + 'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior', + 'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall', 'oneeighth', + 'threeeighths', 'fiveeighths', 'seveneighths', 'onethird', 'twothirds', + 'zerosuperior', 'foursuperior', 'fivesuperior', 'sixsuperior', + 'sevensuperior', 'eightsuperior', 'ninesuperior', 'zeroinferior', + 'oneinferior', 'twoinferior', 'threeinferior', 'fourinferior', + 'fiveinferior', 'sixinferior', 'seveninferior', 'eightinferior', + 'nineinferior', 'centinferior', 'dollarinferior', 'periodinferior', + 'commainferior', 'Agravesmall', 'Aacutesmall', 'Acircumflexsmall', + 'Atildesmall', 'Adieresissmall', 'Aringsmall', 'AEsmall', 'Ccedillasmall', + 'Egravesmall', 'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall', + 'Igravesmall', 'Iacutesmall', 'Icircumflexsmall', 'Idieresissmall', + 'Ethsmall', 'Ntildesmall', 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', + 'Otildesmall', 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', + 'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', + 'Thornsmall', 'Ydieresissmall', '001.000', '001.001', '001.002', '001.003', + 'Black', 'Bold', 'Book', 'Light', 'Medium', 'Regular', 'Roman', 'Semibold' +]; + +// Type1Font is also a CIDFontType0. +var Type1Font = function Type1Font(name, file, properties) { + // Some bad generators embed pfb file as is, we have to strip 6-byte headers. + // Also, length1 and length2 might be off by 6 bytes as well. + // http://www.math.ubc.ca/~cass/piscript/type1.pdf + var PFB_HEADER_SIZE = 6; + var headerBlockLength = properties.length1; + var eexecBlockLength = properties.length2; + var pfbHeader = file.peekBytes(PFB_HEADER_SIZE); + var pfbHeaderPresent = pfbHeader[0] === 0x80 && pfbHeader[1] === 0x01; + if (pfbHeaderPresent) { + file.skip(PFB_HEADER_SIZE); + headerBlockLength = (pfbHeader[5] << 24) | (pfbHeader[4] << 16) | + (pfbHeader[3] << 8) | pfbHeader[2]; + } + + // Get the data block containing glyphs and subrs informations + var headerBlock = new Stream(file.getBytes(headerBlockLength)); + var headerBlockParser = new Type1Parser(headerBlock); + headerBlockParser.extractFontHeader(properties); + + if (pfbHeaderPresent) { + pfbHeader = file.getBytes(PFB_HEADER_SIZE); + eexecBlockLength = (pfbHeader[5] << 24) | (pfbHeader[4] << 16) | + (pfbHeader[3] << 8) | pfbHeader[2]; + } + + // Decrypt the data blocks and retrieve it's content + var eexecBlock = new Stream(file.getBytes(eexecBlockLength)); + var eexecBlockParser = new Type1Parser(eexecBlock, true); + var data = eexecBlockParser.extractFontProgram(); + for (var info in data.properties) { + properties[info] = data.properties[info]; + } + + var charstrings = data.charstrings; + var type2Charstrings = this.getType2Charstrings(charstrings); + var subrs = this.getType2Subrs(data.subrs); + + this.charstrings = charstrings; + this.data = this.wrap(name, type2Charstrings, this.charstrings, + subrs, properties); + this.seacs = this.getSeacs(data.charstrings); +}; + +Type1Font.prototype = { + get numGlyphs() { + return this.charstrings.length + 1; + }, + + getCharset: function Type1Font_getCharset() { + var charset = ['.notdef']; + var charstrings = this.charstrings; + for (var glyphId = 0; glyphId < charstrings.length; glyphId++) { + charset.push(charstrings[glyphId].glyphName); + } + return charset; + }, + + getGlyphMapping: function Type1Font_getGlyphMapping(properties) { + var charstrings = this.charstrings; + var glyphNames = ['.notdef'], glyphId; + for (glyphId = 0; glyphId < charstrings.length; glyphId++) { + glyphNames.push(charstrings[glyphId].glyphName); + } + var encoding = properties.builtInEncoding; + if (encoding) { + var builtInEncoding = {}; + for (var charCode in encoding) { + glyphId = glyphNames.indexOf(encoding[charCode]); + if (glyphId >= 0) { + builtInEncoding[charCode] = glyphId; + } + } + } + + return type1FontGlyphMapping(properties, builtInEncoding, glyphNames); + }, + + getSeacs: function Type1Font_getSeacs(charstrings) { + var i, ii; + var seacMap = []; + for (i = 0, ii = charstrings.length; i < ii; i++) { + var charstring = charstrings[i]; + if (charstring.seac) { + // Offset by 1 for .notdef + seacMap[i + 1] = charstring.seac; + } + } + return seacMap; + }, + + getType2Charstrings: function Type1Font_getType2Charstrings( + type1Charstrings) { + var type2Charstrings = []; + for (var i = 0, ii = type1Charstrings.length; i < ii; i++) { + type2Charstrings.push(type1Charstrings[i].charstring); + } + return type2Charstrings; + }, + + getType2Subrs: function Type1Font_getType2Subrs(type1Subrs) { + var bias = 0; + var count = type1Subrs.length; + if (count < 1133) { + bias = 107; + } else if (count < 33769) { + bias = 1131; + } else { + bias = 32768; + } + + // Add a bunch of empty subrs to deal with the Type2 bias + var type2Subrs = []; + var i; + for (i = 0; i < bias; i++) { + type2Subrs.push([0x0B]); + } + + for (i = 0; i < count; i++) { + type2Subrs.push(type1Subrs[i]); + } + + return type2Subrs; + }, + + wrap: function Type1Font_wrap(name, glyphs, charstrings, subrs, properties) { + var cff = new CFF(); + cff.header = new CFFHeader(1, 0, 4, 4); + + cff.names = [name]; + + var topDict = new CFFTopDict(); + // CFF strings IDs 0...390 are predefined names, so refering + // to entries in our own String INDEX starts at SID 391. + topDict.setByName('version', 391); + topDict.setByName('Notice', 392); + topDict.setByName('FullName', 393); + topDict.setByName('FamilyName', 394); + topDict.setByName('Weight', 395); + topDict.setByName('Encoding', null); // placeholder + topDict.setByName('FontMatrix', properties.fontMatrix); + topDict.setByName('FontBBox', properties.bbox); + topDict.setByName('charset', null); // placeholder + topDict.setByName('CharStrings', null); // placeholder + topDict.setByName('Private', null); // placeholder + cff.topDict = topDict; + + var strings = new CFFStrings(); + strings.add('Version 0.11'); // Version + strings.add('See original notice'); // Notice + strings.add(name); // FullName + strings.add(name); // FamilyName + strings.add('Medium'); // Weight + cff.strings = strings; + + cff.globalSubrIndex = new CFFIndex(); + + var count = glyphs.length; + var charsetArray = [0]; + var i, ii; + for (i = 0; i < count; i++) { + var index = CFFStandardStrings.indexOf(charstrings[i].glyphName); + // TODO: Insert the string and correctly map it. Previously it was + // thought mapping names that aren't in the standard strings to .notdef + // was fine, however in issue818 when mapping them all to .notdef the + // adieresis glyph no longer worked. + if (index === -1) { + index = 0; + } + charsetArray.push((index >> 8) & 0xff, index & 0xff); + } + cff.charset = new CFFCharset(false, 0, [], charsetArray); + + var charStringsIndex = new CFFIndex(); + charStringsIndex.add([0x8B, 0x0E]); // .notdef + for (i = 0; i < count; i++) { + charStringsIndex.add(glyphs[i]); + } + cff.charStrings = charStringsIndex; + + var privateDict = new CFFPrivateDict(); + privateDict.setByName('Subrs', null); // placeholder + var fields = [ + 'BlueValues', + 'OtherBlues', + 'FamilyBlues', + 'FamilyOtherBlues', + 'StemSnapH', + 'StemSnapV', + 'BlueShift', + 'BlueFuzz', + 'BlueScale', + 'LanguageGroup', + 'ExpansionFactor', + 'ForceBold', + 'StdHW', + 'StdVW' + ]; + for (i = 0, ii = fields.length; i < ii; i++) { + var field = fields[i]; + if (!properties.privateData.hasOwnProperty(field)) { + continue; + } + var value = properties.privateData[field]; + if (isArray(value)) { + // All of the private dictionary array data in CFF must be stored as + // "delta-encoded" numbers. + for (var j = value.length - 1; j > 0; j--) { + value[j] -= value[j - 1]; // ... difference from previous value + } + } + privateDict.setByName(field, value); + } + cff.topDict.privateDict = privateDict; + + var subrIndex = new CFFIndex(); + for (i = 0, ii = subrs.length; i < ii; i++) { + subrIndex.add(subrs[i]); + } + privateDict.subrsIndex = subrIndex; + + var compiler = new CFFCompiler(cff); + return compiler.compile(); + } +}; + +var CFFFont = (function CFFFontClosure() { + function CFFFont(file, properties) { + this.properties = properties; + + var parser = new CFFParser(file, properties); + this.cff = parser.parse(); + var compiler = new CFFCompiler(this.cff); + this.seacs = this.cff.seacs; + try { + this.data = compiler.compile(); + } catch (e) { + warn('Failed to compile font ' + properties.loadedName); + // There may have just been an issue with the compiler, set the data + // anyway and hope the font loaded. + this.data = file; + } + } + + CFFFont.prototype = { + get numGlyphs() { + return this.cff.charStrings.count; + }, + getCharset: function CFFFont_getCharset() { + return this.cff.charset.charset; + }, + getGlyphMapping: function CFFFont_getGlyphMapping() { + var cff = this.cff; + var properties = this.properties; + var charsets = cff.charset.charset; + var charCodeToGlyphId; + var glyphId; + + if (properties.composite) { + charCodeToGlyphId = Object.create(null); + if (cff.isCIDFont) { + // If the font is actually a CID font then we should use the charset + // to map CIDs to GIDs. + for (glyphId = 0; glyphId < charsets.length; glyphId++) { + var cid = charsets[glyphId]; + var charCode = properties.cMap.charCodeOf(cid); + charCodeToGlyphId[charCode] = glyphId; + } + } else { + // If it is NOT actually a CID font then CIDs should be mapped + // directly to GIDs. + for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) { + charCodeToGlyphId[glyphId] = glyphId; + } + } + return charCodeToGlyphId; + } + + var encoding = cff.encoding ? cff.encoding.encoding : null; + charCodeToGlyphId = type1FontGlyphMapping(properties, encoding, charsets); + return charCodeToGlyphId; + } + }; + + return CFFFont; +})(); + +var CFFParser = (function CFFParserClosure() { + var CharstringValidationData = [ + null, + { id: 'hstem', min: 2, stackClearing: true, stem: true }, + null, + { id: 'vstem', min: 2, stackClearing: true, stem: true }, + { id: 'vmoveto', min: 1, stackClearing: true }, + { id: 'rlineto', min: 2, resetStack: true }, + { id: 'hlineto', min: 1, resetStack: true }, + { id: 'vlineto', min: 1, resetStack: true }, + { id: 'rrcurveto', min: 6, resetStack: true }, + null, + { id: 'callsubr', min: 1, undefStack: true }, + { id: 'return', min: 0, undefStack: true }, + null, // 12 + null, + { id: 'endchar', min: 0, stackClearing: true }, + null, + null, + null, + { id: 'hstemhm', min: 2, stackClearing: true, stem: true }, + { id: 'hintmask', min: 0, stackClearing: true }, + { id: 'cntrmask', min: 0, stackClearing: true }, + { id: 'rmoveto', min: 2, stackClearing: true }, + { id: 'hmoveto', min: 1, stackClearing: true }, + { id: 'vstemhm', min: 2, stackClearing: true, stem: true }, + { id: 'rcurveline', min: 8, resetStack: true }, + { id: 'rlinecurve', min: 8, resetStack: true }, + { id: 'vvcurveto', min: 4, resetStack: true }, + { id: 'hhcurveto', min: 4, resetStack: true }, + null, // shortint + { id: 'callgsubr', min: 1, undefStack: true }, + { id: 'vhcurveto', min: 4, resetStack: true }, + { id: 'hvcurveto', min: 4, resetStack: true } + ]; + var CharstringValidationData12 = [ + null, + null, + null, + { id: 'and', min: 2, stackDelta: -1 }, + { id: 'or', min: 2, stackDelta: -1 }, + { id: 'not', min: 1, stackDelta: 0 }, + null, + null, + null, + { id: 'abs', min: 1, stackDelta: 0 }, + { id: 'add', min: 2, stackDelta: -1, + stackFn: function stack_div(stack, index) { + stack[index - 2] = stack[index - 2] + stack[index - 1]; + } + }, + { id: 'sub', min: 2, stackDelta: -1, + stackFn: function stack_div(stack, index) { + stack[index - 2] = stack[index - 2] - stack[index - 1]; + } + }, + { id: 'div', min: 2, stackDelta: -1, + stackFn: function stack_div(stack, index) { + stack[index - 2] = stack[index - 2] / stack[index - 1]; + } + }, + null, + { id: 'neg', min: 1, stackDelta: 0, + stackFn: function stack_div(stack, index) { + stack[index - 1] = -stack[index - 1]; + } + }, + { id: 'eq', min: 2, stackDelta: -1 }, + null, + null, + { id: 'drop', min: 1, stackDelta: -1 }, + null, + { id: 'put', min: 2, stackDelta: -2 }, + { id: 'get', min: 1, stackDelta: 0 }, + { id: 'ifelse', min: 4, stackDelta: -3 }, + { id: 'random', min: 0, stackDelta: 1 }, + { id: 'mul', min: 2, stackDelta: -1, + stackFn: function stack_div(stack, index) { + stack[index - 2] = stack[index - 2] * stack[index - 1]; + } + }, + null, + { id: 'sqrt', min: 1, stackDelta: 0 }, + { id: 'dup', min: 1, stackDelta: 1 }, + { id: 'exch', min: 2, stackDelta: 0 }, + { id: 'index', min: 2, stackDelta: 0 }, + { id: 'roll', min: 3, stackDelta: -2 }, + null, + null, + null, + { id: 'hflex', min: 7, resetStack: true }, + { id: 'flex', min: 13, resetStack: true }, + { id: 'hflex1', min: 9, resetStack: true }, + { id: 'flex1', min: 11, resetStack: true } + ]; + + function CFFParser(file, properties) { + this.bytes = file.getBytes(); + this.properties = properties; + } + CFFParser.prototype = { + parse: function CFFParser_parse() { + var properties = this.properties; + var cff = new CFF(); + this.cff = cff; + + // The first five sections must be in order, all the others are reached + // via offsets contained in one of the below. + var header = this.parseHeader(); + var nameIndex = this.parseIndex(header.endPos); + var topDictIndex = this.parseIndex(nameIndex.endPos); + var stringIndex = this.parseIndex(topDictIndex.endPos); + var globalSubrIndex = this.parseIndex(stringIndex.endPos); + + var topDictParsed = this.parseDict(topDictIndex.obj.get(0)); + var topDict = this.createDict(CFFTopDict, topDictParsed, cff.strings); + + cff.header = header.obj; + cff.names = this.parseNameIndex(nameIndex.obj); + cff.strings = this.parseStringIndex(stringIndex.obj); + cff.topDict = topDict; + cff.globalSubrIndex = globalSubrIndex.obj; + + this.parsePrivateDict(cff.topDict); + + cff.isCIDFont = topDict.hasName('ROS'); + + var charStringOffset = topDict.getByName('CharStrings'); + var charStringIndex = this.parseIndex(charStringOffset).obj; + + var fontMatrix = topDict.getByName('FontMatrix'); + if (fontMatrix) { + properties.fontMatrix = fontMatrix; + } + + var fontBBox = topDict.getByName('FontBBox'); + if (fontBBox) { + // adjusting ascent/descent + properties.ascent = fontBBox[3]; + properties.descent = fontBBox[1]; + properties.ascentScaled = true; + } + + var charset, encoding; + if (cff.isCIDFont) { + var fdArrayIndex = this.parseIndex(topDict.getByName('FDArray')).obj; + for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) { + var dictRaw = fdArrayIndex.get(i); + var fontDict = this.createDict(CFFTopDict, this.parseDict(dictRaw), + cff.strings); + this.parsePrivateDict(fontDict); + cff.fdArray.push(fontDict); + } + // cid fonts don't have an encoding + encoding = null; + charset = this.parseCharsets(topDict.getByName('charset'), + charStringIndex.count, cff.strings, true); + cff.fdSelect = this.parseFDSelect(topDict.getByName('FDSelect'), + charStringIndex.count); + } else { + charset = this.parseCharsets(topDict.getByName('charset'), + charStringIndex.count, cff.strings, false); + encoding = this.parseEncoding(topDict.getByName('Encoding'), + properties, + cff.strings, charset.charset); + } + + cff.charset = charset; + cff.encoding = encoding; + + var charStringsAndSeacs = this.parseCharStrings( + charStringIndex, + topDict.privateDict.subrsIndex, + globalSubrIndex.obj, + cff.fdSelect, + cff.fdArray); + cff.charStrings = charStringsAndSeacs.charStrings; + cff.seacs = charStringsAndSeacs.seacs; + cff.widths = charStringsAndSeacs.widths; + + return cff; + }, + parseHeader: function CFFParser_parseHeader() { + var bytes = this.bytes; + var bytesLength = bytes.length; + var offset = 0; + + // Prevent an infinite loop, by checking that the offset is within the + // bounds of the bytes array. Necessary in empty, or invalid, font files. + while (offset < bytesLength && bytes[offset] !== 1) { + ++offset; + } + if (offset >= bytesLength) { + error('Invalid CFF header'); + } else if (offset !== 0) { + info('cff data is shifted'); + bytes = bytes.subarray(offset); + this.bytes = bytes; + } + var major = bytes[0]; + var minor = bytes[1]; + var hdrSize = bytes[2]; + var offSize = bytes[3]; + var header = new CFFHeader(major, minor, hdrSize, offSize); + return { obj: header, endPos: hdrSize }; + }, + parseDict: function CFFParser_parseDict(dict) { + var pos = 0; + + function parseOperand() { + var value = dict[pos++]; + if (value === 30) { + return parseFloatOperand(pos); + } else if (value === 28) { + value = dict[pos++]; + value = ((value << 24) | (dict[pos++] << 16)) >> 16; + return value; + } else if (value === 29) { + value = dict[pos++]; + value = (value << 8) | dict[pos++]; + value = (value << 8) | dict[pos++]; + value = (value << 8) | dict[pos++]; + return value; + } else if (value >= 32 && value <= 246) { + return value - 139; + } else if (value >= 247 && value <= 250) { + return ((value - 247) * 256) + dict[pos++] + 108; + } else if (value >= 251 && value <= 254) { + return -((value - 251) * 256) - dict[pos++] - 108; + } else { + error('255 is not a valid DICT command'); + } + return -1; + } + + function parseFloatOperand() { + var str = ''; + var eof = 15; + var lookup = ['0', '1', '2', '3', '4', '5', '6', '7', '8', + '9', '.', 'E', 'E-', null, '-']; + var length = dict.length; + while (pos < length) { + var b = dict[pos++]; + var b1 = b >> 4; + var b2 = b & 15; + + if (b1 === eof) { + break; + } + str += lookup[b1]; + + if (b2 === eof) { + break; + } + str += lookup[b2]; + } + return parseFloat(str); + } + + var operands = []; + var entries = []; + + pos = 0; + var end = dict.length; + while (pos < end) { + var b = dict[pos]; + if (b <= 21) { + if (b === 12) { + b = (b << 8) | dict[++pos]; + } + entries.push([b, operands]); + operands = []; + ++pos; + } else { + operands.push(parseOperand()); + } + } + return entries; + }, + parseIndex: function CFFParser_parseIndex(pos) { + var cffIndex = new CFFIndex(); + var bytes = this.bytes; + var count = (bytes[pos++] << 8) | bytes[pos++]; + var offsets = []; + var end = pos; + var i, ii; + + if (count !== 0) { + var offsetSize = bytes[pos++]; + // add 1 for offset to determine size of last object + var startPos = pos + ((count + 1) * offsetSize) - 1; + + for (i = 0, ii = count + 1; i < ii; ++i) { + var offset = 0; + for (var j = 0; j < offsetSize; ++j) { + offset <<= 8; + offset += bytes[pos++]; + } + offsets.push(startPos + offset); + } + end = offsets[count]; + } + for (i = 0, ii = offsets.length - 1; i < ii; ++i) { + var offsetStart = offsets[i]; + var offsetEnd = offsets[i + 1]; + cffIndex.add(bytes.subarray(offsetStart, offsetEnd)); + } + return {obj: cffIndex, endPos: end}; + }, + parseNameIndex: function CFFParser_parseNameIndex(index) { + var names = []; + for (var i = 0, ii = index.count; i < ii; ++i) { + var name = index.get(i); + // OTS doesn't allow names to be over 127 characters. + var length = Math.min(name.length, 127); + var data = []; + // OTS also only permits certain characters in the name. + for (var j = 0; j < length; ++j) { + var c = name[j]; + if (j === 0 && c === 0) { + data[j] = c; + continue; + } + if ((c < 33 || c > 126) || c === 91 /* [ */ || c === 93 /* ] */ || + c === 40 /* ( */ || c === 41 /* ) */ || c === 123 /* { */ || + c === 125 /* } */ || c === 60 /* < */ || c === 62 /* > */ || + c === 47 /* / */ || c === 37 /* % */ || c === 35 /* # */) { + data[j] = 95; + continue; + } + data[j] = c; + } + names.push(bytesToString(data)); + } + return names; + }, + parseStringIndex: function CFFParser_parseStringIndex(index) { + var strings = new CFFStrings(); + for (var i = 0, ii = index.count; i < ii; ++i) { + var data = index.get(i); + strings.add(bytesToString(data)); + } + return strings; + }, + createDict: function CFFParser_createDict(Type, dict, strings) { + var cffDict = new Type(strings); + for (var i = 0, ii = dict.length; i < ii; ++i) { + var pair = dict[i]; + var key = pair[0]; + var value = pair[1]; + cffDict.setByKey(key, value); + } + return cffDict; + }, + parseCharString: function CFFParser_parseCharString(state, data, + localSubrIndex, + globalSubrIndex) { + if (state.callDepth > MAX_SUBR_NESTING) { + return false; + } + var stackSize = state.stackSize; + var stack = state.stack; + + var length = data.length; + + for (var j = 0; j < length;) { + var value = data[j++]; + var validationCommand = null; + if (value === 12) { + var q = data[j++]; + if (q === 0) { + // The CFF specification state that the 'dotsection' command + // (12, 0) is deprecated and treated as a no-op, but all Type2 + // charstrings processors should support them. Unfortunately + // the font sanitizer don't. As a workaround the sequence (12, 0) + // is replaced by a useless (0, hmoveto). + data[j - 2] = 139; + data[j - 1] = 22; + stackSize = 0; + } else { + validationCommand = CharstringValidationData12[q]; + } + } else if (value === 28) { // number (16 bit) + stack[stackSize] = ((data[j] << 24) | (data[j + 1] << 16)) >> 16; + j += 2; + stackSize++; + } else if (value === 14) { + if (stackSize >= 4) { + stackSize -= 4; + if (SEAC_ANALYSIS_ENABLED) { + state.seac = stack.slice(stackSize, stackSize + 4); + return false; + } + } + validationCommand = CharstringValidationData[value]; + } else if (value >= 32 && value <= 246) { // number + stack[stackSize] = value - 139; + stackSize++; + } else if (value >= 247 && value <= 254) { // number (+1 bytes) + stack[stackSize] = (value < 251 ? + ((value - 247) << 8) + data[j] + 108 : + -((value - 251) << 8) - data[j] - 108); + j++; + stackSize++; + } else if (value === 255) { // number (32 bit) + stack[stackSize] = ((data[j] << 24) | (data[j + 1] << 16) | + (data[j + 2] << 8) | data[j + 3]) / 65536; + j += 4; + stackSize++; + } else if (value === 19 || value === 20) { + state.hints += stackSize >> 1; + // skipping right amount of hints flag data + j += (state.hints + 7) >> 3; + stackSize %= 2; + validationCommand = CharstringValidationData[value]; + } else if (value === 10 || value === 29) { + var subrsIndex; + if (value === 10) { + subrsIndex = localSubrIndex; + } else { + subrsIndex = globalSubrIndex; + } + if (!subrsIndex) { + validationCommand = CharstringValidationData[value]; + warn('Missing subrsIndex for ' + validationCommand.id); + return false; + } + var bias = 32768; + if (subrsIndex.count < 1240) { + bias = 107; + } else if (subrsIndex.count < 33900) { + bias = 1131; + } + var subrNumber = stack[--stackSize] + bias; + if (subrNumber < 0 || subrNumber >= subrsIndex.count) { + validationCommand = CharstringValidationData[value]; + warn('Out of bounds subrIndex for ' + validationCommand.id); + return false; + } + state.stackSize = stackSize; + state.callDepth++; + var valid = this.parseCharString(state, subrsIndex.get(subrNumber), + localSubrIndex, globalSubrIndex); + if (!valid) { + return false; + } + state.callDepth--; + stackSize = state.stackSize; + continue; + } else if (value === 11) { + state.stackSize = stackSize; + return true; + } else { + validationCommand = CharstringValidationData[value]; + } + if (validationCommand) { + if (validationCommand.stem) { + state.hints += stackSize >> 1; + } + if ('min' in validationCommand) { + if (!state.undefStack && stackSize < validationCommand.min) { + warn('Not enough parameters for ' + validationCommand.id + + '; actual: ' + stackSize + + ', expected: ' + validationCommand.min); + return false; + } + } + if (state.firstStackClearing && validationCommand.stackClearing) { + state.firstStackClearing = false; + // the optional character width can be found before the first + // stack-clearing command arguments + stackSize -= validationCommand.min; + if (stackSize >= 2 && validationCommand.stem) { + // there are even amount of arguments for stem commands + stackSize %= 2; + } else if (stackSize > 1) { + warn('Found too many parameters for stack-clearing command'); + } + if (stackSize > 0 && stack[stackSize - 1] >= 0) { + state.width = stack[stackSize - 1]; + } + } + if ('stackDelta' in validationCommand) { + if ('stackFn' in validationCommand) { + validationCommand.stackFn(stack, stackSize); + } + stackSize += validationCommand.stackDelta; + } else if (validationCommand.stackClearing) { + stackSize = 0; + } else if (validationCommand.resetStack) { + stackSize = 0; + state.undefStack = false; + } else if (validationCommand.undefStack) { + stackSize = 0; + state.undefStack = true; + state.firstStackClearing = false; + } + } + } + state.stackSize = stackSize; + return true; + }, + parseCharStrings: function CFFParser_parseCharStrings(charStrings, + localSubrIndex, + globalSubrIndex, + fdSelect, + fdArray) { + var seacs = []; + var widths = []; + var count = charStrings.count; + for (var i = 0; i < count; i++) { + var charstring = charStrings.get(i); + var state = { + callDepth: 0, + stackSize: 0, + stack: [], + undefStack: true, + hints: 0, + firstStackClearing: true, + seac: null, + width: null + }; + var valid = true; + var localSubrToUse = null; + if (fdSelect && fdArray.length) { + var fdIndex = fdSelect.getFDIndex(i); + if (fdIndex === -1) { + warn('Glyph index is not in fd select.'); + valid = false; + } + if (fdIndex >= fdArray.length) { + warn('Invalid fd index for glyph index.'); + valid = false; + } + if (valid) { + localSubrToUse = fdArray[fdIndex].privateDict.subrsIndex; + } + } else if (localSubrIndex) { + localSubrToUse = localSubrIndex; + } + if (valid) { + valid = this.parseCharString(state, charstring, localSubrToUse, + globalSubrIndex); + } + if (state.width !== null) { + widths[i] = state.width; + } + if (state.seac !== null) { + seacs[i] = state.seac; + } + if (!valid) { + // resetting invalid charstring to single 'endchar' + charStrings.set(i, new Uint8Array([14])); + } + } + return { charStrings: charStrings, seacs: seacs, widths: widths }; + }, + emptyPrivateDictionary: + function CFFParser_emptyPrivateDictionary(parentDict) { + var privateDict = this.createDict(CFFPrivateDict, [], + parentDict.strings); + parentDict.setByKey(18, [0, 0]); + parentDict.privateDict = privateDict; + }, + parsePrivateDict: function CFFParser_parsePrivateDict(parentDict) { + // no private dict, do nothing + if (!parentDict.hasName('Private')) { + this.emptyPrivateDictionary(parentDict); + return; + } + var privateOffset = parentDict.getByName('Private'); + // make sure the params are formatted correctly + if (!isArray(privateOffset) || privateOffset.length !== 2) { + parentDict.removeByName('Private'); + return; + } + var size = privateOffset[0]; + var offset = privateOffset[1]; + // remove empty dicts or ones that refer to invalid location + if (size === 0 || offset >= this.bytes.length) { + this.emptyPrivateDictionary(parentDict); + return; + } + + var privateDictEnd = offset + size; + var dictData = this.bytes.subarray(offset, privateDictEnd); + var dict = this.parseDict(dictData); + var privateDict = this.createDict(CFFPrivateDict, dict, + parentDict.strings); + parentDict.privateDict = privateDict; + + // Parse the Subrs index also since it's relative to the private dict. + if (!privateDict.getByName('Subrs')) { + return; + } + var subrsOffset = privateDict.getByName('Subrs'); + var relativeOffset = offset + subrsOffset; + // Validate the offset. + if (subrsOffset === 0 || relativeOffset >= this.bytes.length) { + this.emptyPrivateDictionary(parentDict); + return; + } + var subrsIndex = this.parseIndex(relativeOffset); + privateDict.subrsIndex = subrsIndex.obj; + }, + parseCharsets: function CFFParser_parseCharsets(pos, length, strings, cid) { + if (pos === 0) { + return new CFFCharset(true, CFFCharsetPredefinedTypes.ISO_ADOBE, + ISOAdobeCharset); + } else if (pos === 1) { + return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT, + ExpertCharset); + } else if (pos === 2) { + return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT_SUBSET, + ExpertSubsetCharset); + } + + var bytes = this.bytes; + var start = pos; + var format = bytes[pos++]; + var charset = ['.notdef']; + var id, count, i; + + // subtract 1 for the .notdef glyph + length -= 1; + + switch (format) { + case 0: + for (i = 0; i < length; i++) { + id = (bytes[pos++] << 8) | bytes[pos++]; + charset.push(cid ? id : strings.get(id)); + } + break; + case 1: + while (charset.length <= length) { + id = (bytes[pos++] << 8) | bytes[pos++]; + count = bytes[pos++]; + for (i = 0; i <= count; i++) { + charset.push(cid ? id++ : strings.get(id++)); + } + } + break; + case 2: + while (charset.length <= length) { + id = (bytes[pos++] << 8) | bytes[pos++]; + count = (bytes[pos++] << 8) | bytes[pos++]; + for (i = 0; i <= count; i++) { + charset.push(cid ? id++ : strings.get(id++)); + } + } + break; + default: + error('Unknown charset format'); + } + // Raw won't be needed if we actually compile the charset. + var end = pos; + var raw = bytes.subarray(start, end); + + return new CFFCharset(false, format, charset, raw); + }, + parseEncoding: function CFFParser_parseEncoding(pos, + properties, + strings, + charset) { + var encoding = {}; + var bytes = this.bytes; + var predefined = false; + var hasSupplement = false; + var format, i, ii; + var raw = null; + + function readSupplement() { + var supplementsCount = bytes[pos++]; + for (i = 0; i < supplementsCount; i++) { + var code = bytes[pos++]; + var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff); + encoding[code] = charset.indexOf(strings.get(sid)); + } + } + + if (pos === 0 || pos === 1) { + predefined = true; + format = pos; + var baseEncoding = pos ? Encodings.ExpertEncoding : + Encodings.StandardEncoding; + for (i = 0, ii = charset.length; i < ii; i++) { + var index = baseEncoding.indexOf(charset[i]); + if (index !== -1) { + encoding[index] = i; + } + } + } else { + var dataStart = pos; + format = bytes[pos++]; + switch (format & 0x7f) { + case 0: + var glyphsCount = bytes[pos++]; + for (i = 1; i <= glyphsCount; i++) { + encoding[bytes[pos++]] = i; + } + break; + + case 1: + var rangesCount = bytes[pos++]; + var gid = 1; + for (i = 0; i < rangesCount; i++) { + var start = bytes[pos++]; + var left = bytes[pos++]; + for (var j = start; j <= start + left; j++) { + encoding[j] = gid++; + } + } + break; + + default: + error('Unknow encoding format: ' + format + ' in CFF'); + break; + } + var dataEnd = pos; + if (format & 0x80) { + // The font sanitizer does not support CFF encoding with a + // supplement, since the encoding is not really used to map + // between gid to glyph, let's overwrite what is declared in + // the top dictionary to let the sanitizer think the font use + // StandardEncoding, that's a lie but that's ok. + bytes[dataStart] &= 0x7f; + readSupplement(); + hasSupplement = true; + } + raw = bytes.subarray(dataStart, dataEnd); + } + format = format & 0x7f; + return new CFFEncoding(predefined, format, encoding, raw); + }, + parseFDSelect: function CFFParser_parseFDSelect(pos, length) { + var start = pos; + var bytes = this.bytes; + var format = bytes[pos++]; + var fdSelect = []; + var i; + + switch (format) { + case 0: + for (i = 0; i < length; ++i) { + var id = bytes[pos++]; + fdSelect.push(id); + } + break; + case 3: + var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + for (i = 0; i < rangesCount; ++i) { + var first = (bytes[pos++] << 8) | bytes[pos++]; + var fdIndex = bytes[pos++]; + var next = (bytes[pos] << 8) | bytes[pos + 1]; + for (var j = first; j < next; ++j) { + fdSelect.push(fdIndex); + } + } + // Advance past the sentinel(next). + pos += 2; + break; + default: + error('Unknown fdselect format ' + format); + break; + } + var end = pos; + return new CFFFDSelect(fdSelect, bytes.subarray(start, end)); + } + }; + return CFFParser; +})(); + +// Compact Font Format +var CFF = (function CFFClosure() { + function CFF() { + this.header = null; + this.names = []; + this.topDict = null; + this.strings = new CFFStrings(); + this.globalSubrIndex = null; + + // The following could really be per font, but since we only have one font + // store them here. + this.encoding = null; + this.charset = null; + this.charStrings = null; + this.fdArray = []; + this.fdSelect = null; + + this.isCIDFont = false; + } + return CFF; +})(); + +var CFFHeader = (function CFFHeaderClosure() { + function CFFHeader(major, minor, hdrSize, offSize) { + this.major = major; + this.minor = minor; + this.hdrSize = hdrSize; + this.offSize = offSize; + } + return CFFHeader; +})(); + +var CFFStrings = (function CFFStringsClosure() { + function CFFStrings() { + this.strings = []; + } + CFFStrings.prototype = { + get: function CFFStrings_get(index) { + if (index >= 0 && index <= 390) { + return CFFStandardStrings[index]; + } + if (index - 391 <= this.strings.length) { + return this.strings[index - 391]; + } + return CFFStandardStrings[0]; + }, + add: function CFFStrings_add(value) { + this.strings.push(value); + }, + get count() { + return this.strings.length; + } + }; + return CFFStrings; +})(); + +var CFFIndex = (function CFFIndexClosure() { + function CFFIndex() { + this.objects = []; + this.length = 0; + } + CFFIndex.prototype = { + add: function CFFIndex_add(data) { + this.length += data.length; + this.objects.push(data); + }, + set: function CFFIndex_set(index, data) { + this.length += data.length - this.objects[index].length; + this.objects[index] = data; + }, + get: function CFFIndex_get(index) { + return this.objects[index]; + }, + get count() { + return this.objects.length; + } + }; + return CFFIndex; +})(); + +var CFFDict = (function CFFDictClosure() { + function CFFDict(tables, strings) { + this.keyToNameMap = tables.keyToNameMap; + this.nameToKeyMap = tables.nameToKeyMap; + this.defaults = tables.defaults; + this.types = tables.types; + this.opcodes = tables.opcodes; + this.order = tables.order; + this.strings = strings; + this.values = {}; + } + CFFDict.prototype = { + // value should always be an array + setByKey: function CFFDict_setByKey(key, value) { + if (!(key in this.keyToNameMap)) { + return false; + } + // ignore empty values + if (value.length === 0) { + return true; + } + var type = this.types[key]; + // remove the array wrapping these types of values + if (type === 'num' || type === 'sid' || type === 'offset') { + value = value[0]; + } + this.values[key] = value; + return true; + }, + setByName: function CFFDict_setByName(name, value) { + if (!(name in this.nameToKeyMap)) { + error('Invalid dictionary name "' + name + '"'); + } + this.values[this.nameToKeyMap[name]] = value; + }, + hasName: function CFFDict_hasName(name) { + return this.nameToKeyMap[name] in this.values; + }, + getByName: function CFFDict_getByName(name) { + if (!(name in this.nameToKeyMap)) { + error('Invalid dictionary name "' + name + '"'); + } + var key = this.nameToKeyMap[name]; + if (!(key in this.values)) { + return this.defaults[key]; + } + return this.values[key]; + }, + removeByName: function CFFDict_removeByName(name) { + delete this.values[this.nameToKeyMap[name]]; + } + }; + CFFDict.createTables = function CFFDict_createTables(layout) { + var tables = { + keyToNameMap: {}, + nameToKeyMap: {}, + defaults: {}, + types: {}, + opcodes: {}, + order: [] + }; + for (var i = 0, ii = layout.length; i < ii; ++i) { + var entry = layout[i]; + var key = isArray(entry[0]) ? (entry[0][0] << 8) + entry[0][1] : entry[0]; + tables.keyToNameMap[key] = entry[1]; + tables.nameToKeyMap[entry[1]] = key; + tables.types[key] = entry[2]; + tables.defaults[key] = entry[3]; + tables.opcodes[key] = isArray(entry[0]) ? entry[0] : [entry[0]]; + tables.order.push(key); + } + return tables; + }; + return CFFDict; +})(); + +var CFFTopDict = (function CFFTopDictClosure() { + var layout = [ + [[12, 30], 'ROS', ['sid', 'sid', 'num'], null], + [[12, 20], 'SyntheticBase', 'num', null], + [0, 'version', 'sid', null], + [1, 'Notice', 'sid', null], + [[12, 0], 'Copyright', 'sid', null], + [2, 'FullName', 'sid', null], + [3, 'FamilyName', 'sid', null], + [4, 'Weight', 'sid', null], + [[12, 1], 'isFixedPitch', 'num', 0], + [[12, 2], 'ItalicAngle', 'num', 0], + [[12, 3], 'UnderlinePosition', 'num', -100], + [[12, 4], 'UnderlineThickness', 'num', 50], + [[12, 5], 'PaintType', 'num', 0], + [[12, 6], 'CharstringType', 'num', 2], + [[12, 7], 'FontMatrix', ['num', 'num', 'num', 'num', 'num', 'num'], + [0.001, 0, 0, 0.001, 0, 0]], + [13, 'UniqueID', 'num', null], + [5, 'FontBBox', ['num', 'num', 'num', 'num'], [0, 0, 0, 0]], + [[12, 8], 'StrokeWidth', 'num', 0], + [14, 'XUID', 'array', null], + [15, 'charset', 'offset', 0], + [16, 'Encoding', 'offset', 0], + [17, 'CharStrings', 'offset', 0], + [18, 'Private', ['offset', 'offset'], null], + [[12, 21], 'PostScript', 'sid', null], + [[12, 22], 'BaseFontName', 'sid', null], + [[12, 23], 'BaseFontBlend', 'delta', null], + [[12, 31], 'CIDFontVersion', 'num', 0], + [[12, 32], 'CIDFontRevision', 'num', 0], + [[12, 33], 'CIDFontType', 'num', 0], + [[12, 34], 'CIDCount', 'num', 8720], + [[12, 35], 'UIDBase', 'num', null], + // XXX: CID Fonts on DirectWrite 6.1 only seem to work if FDSelect comes + // before FDArray. + [[12, 37], 'FDSelect', 'offset', null], + [[12, 36], 'FDArray', 'offset', null], + [[12, 38], 'FontName', 'sid', null] + ]; + var tables = null; + function CFFTopDict(strings) { + if (tables === null) { + tables = CFFDict.createTables(layout); + } + CFFDict.call(this, tables, strings); + this.privateDict = null; + } + CFFTopDict.prototype = Object.create(CFFDict.prototype); + return CFFTopDict; +})(); + +var CFFPrivateDict = (function CFFPrivateDictClosure() { + var layout = [ + [6, 'BlueValues', 'delta', null], + [7, 'OtherBlues', 'delta', null], + [8, 'FamilyBlues', 'delta', null], + [9, 'FamilyOtherBlues', 'delta', null], + [[12, 9], 'BlueScale', 'num', 0.039625], + [[12, 10], 'BlueShift', 'num', 7], + [[12, 11], 'BlueFuzz', 'num', 1], + [10, 'StdHW', 'num', null], + [11, 'StdVW', 'num', null], + [[12, 12], 'StemSnapH', 'delta', null], + [[12, 13], 'StemSnapV', 'delta', null], + [[12, 14], 'ForceBold', 'num', 0], + [[12, 17], 'LanguageGroup', 'num', 0], + [[12, 18], 'ExpansionFactor', 'num', 0.06], + [[12, 19], 'initialRandomSeed', 'num', 0], + [20, 'defaultWidthX', 'num', 0], + [21, 'nominalWidthX', 'num', 0], + [19, 'Subrs', 'offset', null] + ]; + var tables = null; + function CFFPrivateDict(strings) { + if (tables === null) { + tables = CFFDict.createTables(layout); + } + CFFDict.call(this, tables, strings); + this.subrsIndex = null; + } + CFFPrivateDict.prototype = Object.create(CFFDict.prototype); + return CFFPrivateDict; +})(); + +var CFFCharsetPredefinedTypes = { + ISO_ADOBE: 0, + EXPERT: 1, + EXPERT_SUBSET: 2 +}; +var CFFCharset = (function CFFCharsetClosure() { + function CFFCharset(predefined, format, charset, raw) { + this.predefined = predefined; + this.format = format; + this.charset = charset; + this.raw = raw; + } + return CFFCharset; +})(); + +var CFFEncoding = (function CFFEncodingClosure() { + function CFFEncoding(predefined, format, encoding, raw) { + this.predefined = predefined; + this.format = format; + this.encoding = encoding; + this.raw = raw; + } + return CFFEncoding; +})(); + +var CFFFDSelect = (function CFFFDSelectClosure() { + function CFFFDSelect(fdSelect, raw) { + this.fdSelect = fdSelect; + this.raw = raw; + } + CFFFDSelect.prototype = { + getFDIndex: function CFFFDSelect_get(glyphIndex) { + if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) { + return -1; + } + return this.fdSelect[glyphIndex]; + } + }; + return CFFFDSelect; +})(); + +// Helper class to keep track of where an offset is within the data and helps +// filling in that offset once it's known. +var CFFOffsetTracker = (function CFFOffsetTrackerClosure() { + function CFFOffsetTracker() { + this.offsets = {}; + } + CFFOffsetTracker.prototype = { + isTracking: function CFFOffsetTracker_isTracking(key) { + return key in this.offsets; + }, + track: function CFFOffsetTracker_track(key, location) { + if (key in this.offsets) { + error('Already tracking location of ' + key); + } + this.offsets[key] = location; + }, + offset: function CFFOffsetTracker_offset(value) { + for (var key in this.offsets) { + this.offsets[key] += value; + } + }, + setEntryLocation: function CFFOffsetTracker_setEntryLocation(key, + values, + output) { + if (!(key in this.offsets)) { + error('Not tracking location of ' + key); + } + var data = output.data; + var dataOffset = this.offsets[key]; + var size = 5; + for (var i = 0, ii = values.length; i < ii; ++i) { + var offset0 = i * size + dataOffset; + var offset1 = offset0 + 1; + var offset2 = offset0 + 2; + var offset3 = offset0 + 3; + var offset4 = offset0 + 4; + // It's easy to screw up offsets so perform this sanity check. + if (data[offset0] !== 0x1d || data[offset1] !== 0 || + data[offset2] !== 0 || data[offset3] !== 0 || data[offset4] !== 0) { + error('writing to an offset that is not empty'); + } + var value = values[i]; + data[offset0] = 0x1d; + data[offset1] = (value >> 24) & 0xFF; + data[offset2] = (value >> 16) & 0xFF; + data[offset3] = (value >> 8) & 0xFF; + data[offset4] = value & 0xFF; + } + } + }; + return CFFOffsetTracker; +})(); + +// Takes a CFF and converts it to the binary representation. +var CFFCompiler = (function CFFCompilerClosure() { + function CFFCompiler(cff) { + this.cff = cff; + } + CFFCompiler.prototype = { + compile: function CFFCompiler_compile() { + var cff = this.cff; + var output = { + data: [], + length: 0, + add: function CFFCompiler_add(data) { + this.data = this.data.concat(data); + this.length = this.data.length; + } + }; + + // Compile the five entries that must be in order. + var header = this.compileHeader(cff.header); + output.add(header); + + var nameIndex = this.compileNameIndex(cff.names); + output.add(nameIndex); + + if (cff.isCIDFont) { + // The spec is unclear on how font matrices should relate to each other + // when there is one in the main top dict and the sub top dicts. + // Windows handles this differently than linux and osx so we have to + // normalize to work on all. + // Rules based off of some mailing list discussions: + // - If main font has a matrix and subfont doesn't, use the main matrix. + // - If no main font matrix and there is a subfont matrix, use the + // subfont matrix. + // - If both have matrices, concat together. + // - If neither have matrices, use default. + // To make this work on all platforms we move the top matrix into each + // sub top dict and concat if necessary. + if (cff.topDict.hasName('FontMatrix')) { + var base = cff.topDict.getByName('FontMatrix'); + cff.topDict.removeByName('FontMatrix'); + for (var i = 0, ii = cff.fdArray.length; i < ii; i++) { + var subDict = cff.fdArray[i]; + var matrix = base.slice(0); + if (subDict.hasName('FontMatrix')) { + matrix = Util.transform(matrix, subDict.getByName('FontMatrix')); + } + subDict.setByName('FontMatrix', matrix); + } + } + } + + var compiled = this.compileTopDicts([cff.topDict], + output.length, + cff.isCIDFont); + output.add(compiled.output); + var topDictTracker = compiled.trackers[0]; + + var stringIndex = this.compileStringIndex(cff.strings.strings); + output.add(stringIndex); + + var globalSubrIndex = this.compileIndex(cff.globalSubrIndex); + output.add(globalSubrIndex); + + // Now start on the other entries that have no specfic order. + if (cff.encoding && cff.topDict.hasName('Encoding')) { + if (cff.encoding.predefined) { + topDictTracker.setEntryLocation('Encoding', [cff.encoding.format], + output); + } else { + var encoding = this.compileEncoding(cff.encoding); + topDictTracker.setEntryLocation('Encoding', [output.length], output); + output.add(encoding); + } + } + + if (cff.charset && cff.topDict.hasName('charset')) { + if (cff.charset.predefined) { + topDictTracker.setEntryLocation('charset', [cff.charset.format], + output); + } else { + var charset = this.compileCharset(cff.charset); + topDictTracker.setEntryLocation('charset', [output.length], output); + output.add(charset); + } + } + + var charStrings = this.compileCharStrings(cff.charStrings); + topDictTracker.setEntryLocation('CharStrings', [output.length], output); + output.add(charStrings); + + if (cff.isCIDFont) { + // For some reason FDSelect must be in front of FDArray on windows. OSX + // and linux don't seem to care. + topDictTracker.setEntryLocation('FDSelect', [output.length], output); + var fdSelect = this.compileFDSelect(cff.fdSelect.raw); + output.add(fdSelect); + // It is unclear if the sub font dictionary can have CID related + // dictionary keys, but the sanitizer doesn't like them so remove them. + compiled = this.compileTopDicts(cff.fdArray, output.length, true); + topDictTracker.setEntryLocation('FDArray', [output.length], output); + output.add(compiled.output); + var fontDictTrackers = compiled.trackers; + + this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output); + } + + this.compilePrivateDicts([cff.topDict], [topDictTracker], output); + + // If the font data ends with INDEX whose object data is zero-length, + // the sanitizer will bail out. Add a dummy byte to avoid that. + output.add([0]); + + return output.data; + }, + encodeNumber: function CFFCompiler_encodeNumber(value) { + if (parseFloat(value) === parseInt(value, 10) && !isNaN(value)) { // isInt + return this.encodeInteger(value); + } else { + return this.encodeFloat(value); + } + }, + encodeFloat: function CFFCompiler_encodeFloat(num) { + var value = num.toString(); + + // rounding inaccurate doubles + var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(value); + if (m) { + var epsilon = parseFloat('1e' + ((m[2] ? +m[2] : 0) + m[1].length)); + value = (Math.round(num * epsilon) / epsilon).toString(); + } + + var nibbles = ''; + var i, ii; + for (i = 0, ii = value.length; i < ii; ++i) { + var a = value[i]; + if (a === 'e') { + nibbles += value[++i] === '-' ? 'c' : 'b'; + } else if (a === '.') { + nibbles += 'a'; + } else if (a === '-') { + nibbles += 'e'; + } else { + nibbles += a; + } + } + nibbles += (nibbles.length & 1) ? 'f' : 'ff'; + var out = [30]; + for (i = 0, ii = nibbles.length; i < ii; i += 2) { + out.push(parseInt(nibbles.substr(i, 2), 16)); + } + return out; + }, + encodeInteger: function CFFCompiler_encodeInteger(value) { + var code; + if (value >= -107 && value <= 107) { + code = [value + 139]; + } else if (value >= 108 && value <= 1131) { + value = [value - 108]; + code = [(value >> 8) + 247, value & 0xFF]; + } else if (value >= -1131 && value <= -108) { + value = -value - 108; + code = [(value >> 8) + 251, value & 0xFF]; + } else if (value >= -32768 && value <= 32767) { + code = [0x1c, (value >> 8) & 0xFF, value & 0xFF]; + } else { + code = [0x1d, + (value >> 24) & 0xFF, + (value >> 16) & 0xFF, + (value >> 8) & 0xFF, + value & 0xFF]; + } + return code; + }, + compileHeader: function CFFCompiler_compileHeader(header) { + return [ + header.major, + header.minor, + header.hdrSize, + header.offSize + ]; + }, + compileNameIndex: function CFFCompiler_compileNameIndex(names) { + var nameIndex = new CFFIndex(); + for (var i = 0, ii = names.length; i < ii; ++i) { + nameIndex.add(stringToBytes(names[i])); + } + return this.compileIndex(nameIndex); + }, + compileTopDicts: function CFFCompiler_compileTopDicts(dicts, + length, + removeCidKeys) { + var fontDictTrackers = []; + var fdArrayIndex = new CFFIndex(); + for (var i = 0, ii = dicts.length; i < ii; ++i) { + var fontDict = dicts[i]; + if (removeCidKeys) { + fontDict.removeByName('CIDFontVersion'); + fontDict.removeByName('CIDFontRevision'); + fontDict.removeByName('CIDFontType'); + fontDict.removeByName('CIDCount'); + fontDict.removeByName('UIDBase'); + } + var fontDictTracker = new CFFOffsetTracker(); + var fontDictData = this.compileDict(fontDict, fontDictTracker); + fontDictTrackers.push(fontDictTracker); + fdArrayIndex.add(fontDictData); + fontDictTracker.offset(length); + } + fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers); + return { + trackers: fontDictTrackers, + output: fdArrayIndex + }; + }, + compilePrivateDicts: function CFFCompiler_compilePrivateDicts(dicts, + trackers, + output) { + for (var i = 0, ii = dicts.length; i < ii; ++i) { + var fontDict = dicts[i]; + assert(fontDict.privateDict && fontDict.hasName('Private'), + 'There must be an private dictionary.'); + var privateDict = fontDict.privateDict; + var privateDictTracker = new CFFOffsetTracker(); + var privateDictData = this.compileDict(privateDict, privateDictTracker); + + var outputLength = output.length; + privateDictTracker.offset(outputLength); + if (!privateDictData.length) { + // The private dictionary was empty, set the output length to zero to + // ensure the offset length isn't out of bounds in the eyes of the + // sanitizer. + outputLength = 0; + } + + trackers[i].setEntryLocation('Private', + [privateDictData.length, outputLength], + output); + output.add(privateDictData); + + if (privateDict.subrsIndex && privateDict.hasName('Subrs')) { + var subrs = this.compileIndex(privateDict.subrsIndex); + privateDictTracker.setEntryLocation('Subrs', [privateDictData.length], + output); + output.add(subrs); + } + } + }, + compileDict: function CFFCompiler_compileDict(dict, offsetTracker) { + var out = []; + // The dictionary keys must be in a certain order. + var order = dict.order; + for (var i = 0; i < order.length; ++i) { + var key = order[i]; + if (!(key in dict.values)) { + continue; + } + var values = dict.values[key]; + var types = dict.types[key]; + if (!isArray(types)) { + types = [types]; + } + if (!isArray(values)) { + values = [values]; + } + + // Remove any empty dict values. + if (values.length === 0) { + continue; + } + + for (var j = 0, jj = types.length; j < jj; ++j) { + var type = types[j]; + var value = values[j]; + switch (type) { + case 'num': + case 'sid': + out = out.concat(this.encodeNumber(value)); + break; + case 'offset': + // For offsets we just insert a 32bit integer so we don't have to + // deal with figuring out the length of the offset when it gets + // replaced later on by the compiler. + var name = dict.keyToNameMap[key]; + // Some offsets have the offset and the length, so just record the + // position of the first one. + if (!offsetTracker.isTracking(name)) { + offsetTracker.track(name, out.length); + } + out = out.concat([0x1d, 0, 0, 0, 0]); + break; + case 'array': + case 'delta': + out = out.concat(this.encodeNumber(value)); + for (var k = 1, kk = values.length; k < kk; ++k) { + out = out.concat(this.encodeNumber(values[k])); + } + break; + default: + error('Unknown data type of ' + type); + break; + } + } + out = out.concat(dict.opcodes[key]); + } + return out; + }, + compileStringIndex: function CFFCompiler_compileStringIndex(strings) { + var stringIndex = new CFFIndex(); + for (var i = 0, ii = strings.length; i < ii; ++i) { + stringIndex.add(stringToBytes(strings[i])); + } + return this.compileIndex(stringIndex); + }, + compileGlobalSubrIndex: function CFFCompiler_compileGlobalSubrIndex() { + var globalSubrIndex = this.cff.globalSubrIndex; + this.out.writeByteArray(this.compileIndex(globalSubrIndex)); + }, + compileCharStrings: function CFFCompiler_compileCharStrings(charStrings) { + return this.compileIndex(charStrings); + }, + compileCharset: function CFFCompiler_compileCharset(charset) { + return this.compileTypedArray(charset.raw); + }, + compileEncoding: function CFFCompiler_compileEncoding(encoding) { + return this.compileTypedArray(encoding.raw); + }, + compileFDSelect: function CFFCompiler_compileFDSelect(fdSelect) { + return this.compileTypedArray(fdSelect); + }, + compileTypedArray: function CFFCompiler_compileTypedArray(data) { + var out = []; + for (var i = 0, ii = data.length; i < ii; ++i) { + out[i] = data[i]; + } + return out; + }, + compileIndex: function CFFCompiler_compileIndex(index, trackers) { + trackers = trackers || []; + var objects = index.objects; + // First 2 bytes contains the number of objects contained into this index + var count = objects.length; + + // If there is no object, just create an index. This technically + // should just be [0, 0] but OTS has an issue with that. + if (count === 0) { + return [0, 0, 0]; + } + + var data = [(count >> 8) & 0xFF, count & 0xff]; + + var lastOffset = 1, i; + for (i = 0; i < count; ++i) { + lastOffset += objects[i].length; + } + + var offsetSize; + if (lastOffset < 0x100) { + offsetSize = 1; + } else if (lastOffset < 0x10000) { + offsetSize = 2; + } else if (lastOffset < 0x1000000) { + offsetSize = 3; + } else { + offsetSize = 4; + } + + // Next byte contains the offset size use to reference object in the file + data.push(offsetSize); + + // Add another offset after this one because we need a new offset + var relativeOffset = 1; + for (i = 0; i < count + 1; i++) { + if (offsetSize === 1) { + data.push(relativeOffset & 0xFF); + } else if (offsetSize === 2) { + data.push((relativeOffset >> 8) & 0xFF, + relativeOffset & 0xFF); + } else if (offsetSize === 3) { + data.push((relativeOffset >> 16) & 0xFF, + (relativeOffset >> 8) & 0xFF, + relativeOffset & 0xFF); + } else { + data.push((relativeOffset >>> 24) & 0xFF, + (relativeOffset >> 16) & 0xFF, + (relativeOffset >> 8) & 0xFF, + relativeOffset & 0xFF); + } + + if (objects[i]) { + relativeOffset += objects[i].length; + } + } + + for (i = 0; i < count; i++) { + // Notify the tracker where the object will be offset in the data. + if (trackers[i]) { + trackers[i].offset(data.length); + } + for (var j = 0, jj = objects[i].length; j < jj; j++) { + data.push(objects[i][j]); + } + } + return data; + } + }; + return CFFCompiler; +})(); + +function _enableSeacAnalysis(enabled) { + exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED = enabled; +} + +// Workaround for seac on Windows. +(function checkSeacSupport() { + if (typeof navigator !== 'undefined' && /Windows/.test(navigator.userAgent)) { + SEAC_ANALYSIS_ENABLED = true; + } +})(); + +// Workaround for Private Use Area characters in Chrome on Windows +// http://code.google.com/p/chromium/issues/detail?id=122465 +// https://github.com/mozilla/pdf.js/issues/1689 +(function checkChromeWindows() { + if (typeof navigator !== 'undefined' && + /Windows.*Chrome/.test(navigator.userAgent)) { + SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = true; + } +})(); + +exports.SEAC_ANALYSIS_ENABLED = SEAC_ANALYSIS_ENABLED; +exports.CFFCompiler = CFFCompiler; +exports.CFFIndex = CFFIndex; +exports.CFFParser = CFFParser; +exports.CFFStrings = CFFStrings; +exports.Encodings = Encodings; +exports.ErrorFont = ErrorFont; +exports.FontFlags = FontFlags; +exports.Font = Font; +exports.IdentityToUnicodeMap = IdentityToUnicodeMap; +exports.NormalizedUnicodes = NormalizedUnicodes; +exports.ToUnicodeMap = ToUnicodeMap; +exports.Type1Parser = Type1Parser; +exports.getFontType = getFontType; +exports.reverseIfRtl = reverseIfRtl; +exports.serifFonts = serifFonts; +exports.symbolsFonts = symbolsFonts; +exports.stdFontMap = stdFontMap; +exports._enableSeacAnalysis = _enableSeacAnalysis; + +// TODO refactor to remove cyclic dependency on font_renderer.js +coreFontRenderer._setCoreFonts(exports); +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreFunction = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCorePsParser); + } +}(this, function (exports, sharedUtil, corePrimitives, corePsParser) { + +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isBool = sharedUtil.isBool; +var isDict = corePrimitives.isDict; +var isStream = corePrimitives.isStream; +var PostScriptLexer = corePsParser.PostScriptLexer; +var PostScriptParser = corePsParser.PostScriptParser; + +var PDFFunction = (function PDFFunctionClosure() { + var CONSTRUCT_SAMPLED = 0; + var CONSTRUCT_INTERPOLATED = 2; + var CONSTRUCT_STICHED = 3; + var CONSTRUCT_POSTSCRIPT = 4; + + return { + getSampleArray: function PDFFunction_getSampleArray(size, outputSize, bps, + str) { + var i, ii; + var length = 1; + for (i = 0, ii = size.length; i < ii; i++) { + length *= size[i]; + } + length *= outputSize; + + var array = new Array(length); + var codeSize = 0; + var codeBuf = 0; + // 32 is a valid bps so shifting won't work + var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1); + + var strBytes = str.getBytes((length * bps + 7) / 8); + var strIdx = 0; + for (i = 0; i < length; i++) { + while (codeSize < bps) { + codeBuf <<= 8; + codeBuf |= strBytes[strIdx++]; + codeSize += 8; + } + codeSize -= bps; + array[i] = (codeBuf >> codeSize) * sampleMul; + codeBuf &= (1 << codeSize) - 1; + } + return array; + }, + + getIR: function PDFFunction_getIR(xref, fn) { + var dict = fn.dict; + if (!dict) { + dict = fn; + } + + var types = [this.constructSampled, + null, + this.constructInterpolated, + this.constructStiched, + this.constructPostScript]; + + var typeNum = dict.get('FunctionType'); + var typeFn = types[typeNum]; + if (!typeFn) { + error('Unknown type of function'); + } + + return typeFn.call(this, fn, dict, xref); + }, + + fromIR: function PDFFunction_fromIR(IR) { + var type = IR[0]; + switch (type) { + case CONSTRUCT_SAMPLED: + return this.constructSampledFromIR(IR); + case CONSTRUCT_INTERPOLATED: + return this.constructInterpolatedFromIR(IR); + case CONSTRUCT_STICHED: + return this.constructStichedFromIR(IR); + //case CONSTRUCT_POSTSCRIPT: + default: + return this.constructPostScriptFromIR(IR); + } + }, + + parse: function PDFFunction_parse(xref, fn) { + var IR = this.getIR(xref, fn); + return this.fromIR(IR); + }, + + parseArray: function PDFFunction_parseArray(xref, fnObj) { + if (!isArray(fnObj)) { + // not an array -- parsing as regular function + return this.parse(xref, fnObj); + } + + var fnArray = []; + for (var j = 0, jj = fnObj.length; j < jj; j++) { + var obj = xref.fetchIfRef(fnObj[j]); + fnArray.push(PDFFunction.parse(xref, obj)); + } + return function (src, srcOffset, dest, destOffset) { + for (var i = 0, ii = fnArray.length; i < ii; i++) { + fnArray[i](src, srcOffset, dest, destOffset + i); + } + }; + }, + + constructSampled: function PDFFunction_constructSampled(str, dict) { + function toMultiArray(arr) { + var inputLength = arr.length; + var out = []; + var index = 0; + for (var i = 0; i < inputLength; i += 2) { + out[index] = [arr[i], arr[i + 1]]; + ++index; + } + return out; + } + var domain = dict.get('Domain'); + var range = dict.get('Range'); + + if (!domain || !range) { + error('No domain or range'); + } + + var inputSize = domain.length / 2; + var outputSize = range.length / 2; + + domain = toMultiArray(domain); + range = toMultiArray(range); + + var size = dict.get('Size'); + var bps = dict.get('BitsPerSample'); + var order = dict.get('Order') || 1; + if (order !== 1) { + // No description how cubic spline interpolation works in PDF32000:2008 + // As in poppler, ignoring order, linear interpolation may work as good + info('No support for cubic spline interpolation: ' + order); + } + + var encode = dict.get('Encode'); + if (!encode) { + encode = []; + for (var i = 0; i < inputSize; ++i) { + encode.push(0); + encode.push(size[i] - 1); + } + } + encode = toMultiArray(encode); + + var decode = dict.get('Decode'); + if (!decode) { + decode = range; + } else { + decode = toMultiArray(decode); + } + + var samples = this.getSampleArray(size, outputSize, bps, str); + + return [ + CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size, + outputSize, Math.pow(2, bps) - 1, range + ]; + }, + + constructSampledFromIR: function PDFFunction_constructSampledFromIR(IR) { + // See chapter 3, page 109 of the PDF reference + function interpolate(x, xmin, xmax, ymin, ymax) { + return ymin + ((x - xmin) * ((ymax - ymin) / (xmax - xmin))); + } + + return function constructSampledFromIRResult(src, srcOffset, + dest, destOffset) { + // See chapter 3, page 110 of the PDF reference. + var m = IR[1]; + var domain = IR[2]; + var encode = IR[3]; + var decode = IR[4]; + var samples = IR[5]; + var size = IR[6]; + var n = IR[7]; + //var mask = IR[8]; + var range = IR[9]; + + // Building the cube vertices: its part and sample index + // http://rjwagner49.com/Mathematics/Interpolation.pdf + var cubeVertices = 1 << m; + var cubeN = new Float64Array(cubeVertices); + var cubeVertex = new Uint32Array(cubeVertices); + var i, j; + for (j = 0; j < cubeVertices; j++) { + cubeN[j] = 1; + } + + var k = n, pos = 1; + // Map x_i to y_j for 0 <= i < m using the sampled function. + for (i = 0; i < m; ++i) { + // x_i' = min(max(x_i, Domain_2i), Domain_2i+1) + var domain_2i = domain[i][0]; + var domain_2i_1 = domain[i][1]; + var xi = Math.min(Math.max(src[srcOffset +i], domain_2i), + domain_2i_1); + + // e_i = Interpolate(x_i', Domain_2i, Domain_2i+1, + // Encode_2i, Encode_2i+1) + var e = interpolate(xi, domain_2i, domain_2i_1, + encode[i][0], encode[i][1]); + + // e_i' = min(max(e_i, 0), Size_i - 1) + var size_i = size[i]; + e = Math.min(Math.max(e, 0), size_i - 1); + + // Adjusting the cube: N and vertex sample index + var e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1; + var n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0); + var n1 = e - e0; // (e - e0) / (e1 - e0); + var offset0 = e0 * k; + var offset1 = offset0 + k; // e1 * k + for (j = 0; j < cubeVertices; j++) { + if (j & pos) { + cubeN[j] *= n1; + cubeVertex[j] += offset1; + } else { + cubeN[j] *= n0; + cubeVertex[j] += offset0; + } + } + + k *= size_i; + pos <<= 1; + } + + for (j = 0; j < n; ++j) { + // Sum all cube vertices' samples portions + var rj = 0; + for (i = 0; i < cubeVertices; i++) { + rj += samples[cubeVertex[i] + j] * cubeN[i]; + } + + // r_j' = Interpolate(r_j, 0, 2^BitsPerSample - 1, + // Decode_2j, Decode_2j+1) + rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]); + + // y_j = min(max(r_j, range_2j), range_2j+1) + dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), + range[j][1]); + } + }; + }, + + constructInterpolated: function PDFFunction_constructInterpolated(str, + dict) { + var c0 = dict.get('C0') || [0]; + var c1 = dict.get('C1') || [1]; + var n = dict.get('N'); + + if (!isArray(c0) || !isArray(c1)) { + error('Illegal dictionary for interpolated function'); + } + + var length = c0.length; + var diff = []; + for (var i = 0; i < length; ++i) { + diff.push(c1[i] - c0[i]); + } + + return [CONSTRUCT_INTERPOLATED, c0, diff, n]; + }, + + constructInterpolatedFromIR: + function PDFFunction_constructInterpolatedFromIR(IR) { + var c0 = IR[1]; + var diff = IR[2]; + var n = IR[3]; + + var length = diff.length; + + return function constructInterpolatedFromIRResult(src, srcOffset, + dest, destOffset) { + var x = n === 1 ? src[srcOffset] : Math.pow(src[srcOffset], n); + + for (var j = 0; j < length; ++j) { + dest[destOffset + j] = c0[j] + (x * diff[j]); + } + }; + }, + + constructStiched: function PDFFunction_constructStiched(fn, dict, xref) { + var domain = dict.get('Domain'); + + if (!domain) { + error('No domain'); + } + + var inputSize = domain.length / 2; + if (inputSize !== 1) { + error('Bad domain for stiched function'); + } + + var fnRefs = dict.get('Functions'); + var fns = []; + for (var i = 0, ii = fnRefs.length; i < ii; ++i) { + fns.push(PDFFunction.getIR(xref, xref.fetchIfRef(fnRefs[i]))); + } + + var bounds = dict.get('Bounds'); + var encode = dict.get('Encode'); + + return [CONSTRUCT_STICHED, domain, bounds, encode, fns]; + }, + + constructStichedFromIR: function PDFFunction_constructStichedFromIR(IR) { + var domain = IR[1]; + var bounds = IR[2]; + var encode = IR[3]; + var fnsIR = IR[4]; + var fns = []; + var tmpBuf = new Float32Array(1); + + for (var i = 0, ii = fnsIR.length; i < ii; i++) { + fns.push(PDFFunction.fromIR(fnsIR[i])); + } + + return function constructStichedFromIRResult(src, srcOffset, + dest, destOffset) { + var clip = function constructStichedFromIRClip(v, min, max) { + if (v > max) { + v = max; + } else if (v < min) { + v = min; + } + return v; + }; + + // clip to domain + var v = clip(src[srcOffset], domain[0], domain[1]); + // calulate which bound the value is in + for (var i = 0, ii = bounds.length; i < ii; ++i) { + if (v < bounds[i]) { + break; + } + } + + // encode value into domain of function + var dmin = domain[0]; + if (i > 0) { + dmin = bounds[i - 1]; + } + var dmax = domain[1]; + if (i < bounds.length) { + dmax = bounds[i]; + } + + var rmin = encode[2 * i]; + var rmax = encode[2 * i + 1]; + + // Prevent the value from becoming NaN as a result + // of division by zero (fixes issue6113.pdf). + tmpBuf[0] = dmin === dmax ? rmin : + rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin); + + // call the appropriate function + fns[i](tmpBuf, 0, dest, destOffset); + }; + }, + + constructPostScript: function PDFFunction_constructPostScript(fn, dict, + xref) { + var domain = dict.get('Domain'); + var range = dict.get('Range'); + + if (!domain) { + error('No domain.'); + } + + if (!range) { + error('No range.'); + } + + var lexer = new PostScriptLexer(fn); + var parser = new PostScriptParser(lexer); + var code = parser.parse(); + + return [CONSTRUCT_POSTSCRIPT, domain, range, code]; + }, + + constructPostScriptFromIR: function PDFFunction_constructPostScriptFromIR( + IR) { + var domain = IR[1]; + var range = IR[2]; + var code = IR[3]; + + var compiled = (new PostScriptCompiler()).compile(code, domain, range); + if (compiled) { + // Compiled function consists of simple expressions such as addition, + // subtraction, Math.max, and also contains 'var' and 'return' + // statements. See the generation in the PostScriptCompiler below. + /*jshint -W054 */ + return new Function('src', 'srcOffset', 'dest', 'destOffset', compiled); + } + + info('Unable to compile PS function'); + + var numOutputs = range.length >> 1; + var numInputs = domain.length >> 1; + var evaluator = new PostScriptEvaluator(code); + // Cache the values for a big speed up, the cache size is limited though + // since the number of possible values can be huge from a PS function. + var cache = {}; + // The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values + // seen in our tests. + var MAX_CACHE_SIZE = 2048 * 4; + var cache_available = MAX_CACHE_SIZE; + var tmpBuf = new Float32Array(numInputs); + + return function constructPostScriptFromIRResult(src, srcOffset, + dest, destOffset) { + var i, value; + var key = ''; + var input = tmpBuf; + for (i = 0; i < numInputs; i++) { + value = src[srcOffset + i]; + input[i] = value; + key += value + '_'; + } + + var cachedValue = cache[key]; + if (cachedValue !== undefined) { + dest.set(cachedValue, destOffset); + return; + } + + var output = new Float32Array(numOutputs); + var stack = evaluator.execute(input); + var stackIndex = stack.length - numOutputs; + for (i = 0; i < numOutputs; i++) { + value = stack[stackIndex + i]; + var bound = range[i * 2]; + if (value < bound) { + value = bound; + } else { + bound = range[i * 2 +1]; + if (value > bound) { + value = bound; + } + } + output[i] = value; + } + if (cache_available > 0) { + cache_available--; + cache[key] = output; + } + dest.set(output, destOffset); + }; + } + }; +})(); + +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 PostScriptStack = (function PostScriptStackClosure() { + var MAX_STACK_SIZE = 100; + function PostScriptStack(initialStack) { + this.stack = !initialStack ? [] : + Array.prototype.slice.call(initialStack, 0); + } + + PostScriptStack.prototype = { + push: function PostScriptStack_push(value) { + if (this.stack.length >= MAX_STACK_SIZE) { + error('PostScript function stack overflow.'); + } + this.stack.push(value); + }, + pop: function PostScriptStack_pop() { + if (this.stack.length <= 0) { + error('PostScript function stack underflow.'); + } + return this.stack.pop(); + }, + copy: function PostScriptStack_copy(n) { + if (this.stack.length + n >= MAX_STACK_SIZE) { + error('PostScript function stack overflow.'); + } + var stack = this.stack; + for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) { + stack.push(stack[i]); + } + }, + index: function PostScriptStack_index(n) { + this.push(this.stack[this.stack.length - n - 1]); + }, + // rotate the last n stack elements p times + roll: function PostScriptStack_roll(n, p) { + var stack = this.stack; + var l = stack.length - n; + var r = stack.length - 1, c = l + (p - Math.floor(p / n) * n), i, j, t; + for (i = l, j = r; i < j; i++, j--) { + t = stack[i]; stack[i] = stack[j]; stack[j] = t; + } + for (i = l, j = c - 1; i < j; i++, j--) { + t = stack[i]; stack[i] = stack[j]; stack[j] = t; + } + for (i = c, j = r; i < j; i++, j--) { + t = stack[i]; stack[i] = stack[j]; stack[j] = t; + } + } + }; + return PostScriptStack; +})(); +var PostScriptEvaluator = (function PostScriptEvaluatorClosure() { + function PostScriptEvaluator(operators) { + this.operators = operators; + } + PostScriptEvaluator.prototype = { + execute: function PostScriptEvaluator_execute(initialStack) { + var stack = new PostScriptStack(initialStack); + var counter = 0; + var operators = this.operators; + var length = operators.length; + var operator, a, b; + while (counter < length) { + operator = operators[counter++]; + if (typeof operator === 'number') { + // Operator is really an operand and should be pushed to the stack. + stack.push(operator); + continue; + } + switch (operator) { + // non standard ps operators + case 'jz': // jump if false + b = stack.pop(); + a = stack.pop(); + if (!a) { + counter = b; + } + break; + case 'j': // jump + a = stack.pop(); + counter = a; + break; + + // all ps operators in alphabetical order (excluding if/ifelse) + case 'abs': + a = stack.pop(); + stack.push(Math.abs(a)); + break; + case 'add': + b = stack.pop(); + a = stack.pop(); + stack.push(a + b); + break; + case 'and': + b = stack.pop(); + a = stack.pop(); + if (isBool(a) && isBool(b)) { + stack.push(a && b); + } else { + stack.push(a & b); + } + break; + case 'atan': + a = stack.pop(); + stack.push(Math.atan(a)); + break; + case 'bitshift': + b = stack.pop(); + a = stack.pop(); + if (a > 0) { + stack.push(a << b); + } else { + stack.push(a >> b); + } + break; + case 'ceiling': + a = stack.pop(); + stack.push(Math.ceil(a)); + break; + case 'copy': + a = stack.pop(); + stack.copy(a); + break; + case 'cos': + a = stack.pop(); + stack.push(Math.cos(a)); + break; + case 'cvi': + a = stack.pop() | 0; + stack.push(a); + break; + case 'cvr': + // noop + break; + case 'div': + b = stack.pop(); + a = stack.pop(); + stack.push(a / b); + break; + case 'dup': + stack.copy(1); + break; + case 'eq': + b = stack.pop(); + a = stack.pop(); + stack.push(a === b); + break; + case 'exch': + stack.roll(2, 1); + break; + case 'exp': + b = stack.pop(); + a = stack.pop(); + stack.push(Math.pow(a, b)); + break; + case 'false': + stack.push(false); + break; + case 'floor': + a = stack.pop(); + stack.push(Math.floor(a)); + break; + case 'ge': + b = stack.pop(); + a = stack.pop(); + stack.push(a >= b); + break; + case 'gt': + b = stack.pop(); + a = stack.pop(); + stack.push(a > b); + break; + case 'idiv': + b = stack.pop(); + a = stack.pop(); + stack.push((a / b) | 0); + break; + case 'index': + a = stack.pop(); + stack.index(a); + break; + case 'le': + b = stack.pop(); + a = stack.pop(); + stack.push(a <= b); + break; + case 'ln': + a = stack.pop(); + stack.push(Math.log(a)); + break; + case 'log': + a = stack.pop(); + stack.push(Math.log(a) / Math.LN10); + break; + case 'lt': + b = stack.pop(); + a = stack.pop(); + stack.push(a < b); + break; + case 'mod': + b = stack.pop(); + a = stack.pop(); + stack.push(a % b); + break; + case 'mul': + b = stack.pop(); + a = stack.pop(); + stack.push(a * b); + break; + case 'ne': + b = stack.pop(); + a = stack.pop(); + stack.push(a !== b); + break; + case 'neg': + a = stack.pop(); + stack.push(-a); + break; + case 'not': + a = stack.pop(); + if (isBool(a)) { + stack.push(!a); + } else { + stack.push(~a); + } + break; + case 'or': + b = stack.pop(); + a = stack.pop(); + if (isBool(a) && isBool(b)) { + stack.push(a || b); + } else { + stack.push(a | b); + } + break; + case 'pop': + stack.pop(); + break; + case 'roll': + b = stack.pop(); + a = stack.pop(); + stack.roll(a, b); + break; + case 'round': + a = stack.pop(); + stack.push(Math.round(a)); + break; + case 'sin': + a = stack.pop(); + stack.push(Math.sin(a)); + break; + case 'sqrt': + a = stack.pop(); + stack.push(Math.sqrt(a)); + break; + case 'sub': + b = stack.pop(); + a = stack.pop(); + stack.push(a - b); + break; + case 'true': + stack.push(true); + break; + case 'truncate': + a = stack.pop(); + a = a < 0 ? Math.ceil(a) : Math.floor(a); + stack.push(a); + break; + case 'xor': + b = stack.pop(); + a = stack.pop(); + if (isBool(a) && isBool(b)) { + stack.push(a !== b); + } else { + stack.push(a ^ b); + } + break; + default: + error('Unknown operator ' + operator); + break; + } + } + return stack.stack; + } + }; + return PostScriptEvaluator; +})(); + +// Most of the PDFs functions consist of simple operations such as: +// roll, exch, sub, cvr, pop, index, dup, mul, if, gt, add. +// +// We can compile most of such programs, and at the same moment, we can +// optimize some expressions using basic math properties. Keeping track of +// min/max values will allow us to avoid extra Math.min/Math.max calls. +var PostScriptCompiler = (function PostScriptCompilerClosure() { + function AstNode(type) { + this.type = type; + } + AstNode.prototype.visit = function (visitor) { + throw new Error('abstract method'); + }; + + function AstArgument(index, min, max) { + AstNode.call(this, 'args'); + this.index = index; + this.min = min; + this.max = max; + } + AstArgument.prototype = Object.create(AstNode.prototype); + AstArgument.prototype.visit = function (visitor) { + visitor.visitArgument(this); + }; + + function AstLiteral(number) { + AstNode.call(this, 'literal'); + this.number = number; + this.min = number; + this.max = number; + } + AstLiteral.prototype = Object.create(AstNode.prototype); + AstLiteral.prototype.visit = function (visitor) { + visitor.visitLiteral(this); + }; + + function AstBinaryOperation(op, arg1, arg2, min, max) { + AstNode.call(this, 'binary'); + this.op = op; + this.arg1 = arg1; + this.arg2 = arg2; + this.min = min; + this.max = max; + } + AstBinaryOperation.prototype = Object.create(AstNode.prototype); + AstBinaryOperation.prototype.visit = function (visitor) { + visitor.visitBinaryOperation(this); + }; + + function AstMin(arg, max) { + AstNode.call(this, 'max'); + this.arg = arg; + this.min = arg.min; + this.max = max; + } + AstMin.prototype = Object.create(AstNode.prototype); + AstMin.prototype.visit = function (visitor) { + visitor.visitMin(this); + }; + + function AstVariable(index, min, max) { + AstNode.call(this, 'var'); + this.index = index; + this.min = min; + this.max = max; + } + AstVariable.prototype = Object.create(AstNode.prototype); + AstVariable.prototype.visit = function (visitor) { + visitor.visitVariable(this); + }; + + function AstVariableDefinition(variable, arg) { + AstNode.call(this, 'definition'); + this.variable = variable; + this.arg = arg; + } + AstVariableDefinition.prototype = Object.create(AstNode.prototype); + AstVariableDefinition.prototype.visit = function (visitor) { + visitor.visitVariableDefinition(this); + }; + + function ExpressionBuilderVisitor() { + this.parts = []; + } + ExpressionBuilderVisitor.prototype = { + visitArgument: function (arg) { + this.parts.push('Math.max(', arg.min, ', Math.min(', + arg.max, ', src[srcOffset + ', arg.index, ']))'); + }, + visitVariable: function (variable) { + this.parts.push('v', variable.index); + }, + visitLiteral: function (literal) { + this.parts.push(literal.number); + }, + visitBinaryOperation: function (operation) { + this.parts.push('('); + operation.arg1.visit(this); + this.parts.push(' ', operation.op, ' '); + operation.arg2.visit(this); + this.parts.push(')'); + }, + visitVariableDefinition: function (definition) { + this.parts.push('var '); + definition.variable.visit(this); + this.parts.push(' = '); + definition.arg.visit(this); + this.parts.push(';'); + }, + visitMin: function (max) { + this.parts.push('Math.min('); + max.arg.visit(this); + this.parts.push(', ', max.max, ')'); + }, + toString: function () { + return this.parts.join(''); + } + }; + + function buildAddOperation(num1, num2) { + if (num2.type === 'literal' && num2.number === 0) { + // optimization: second operand is 0 + return num1; + } + if (num1.type === 'literal' && num1.number === 0) { + // optimization: first operand is 0 + return num2; + } + if (num2.type === 'literal' && num1.type === 'literal') { + // optimization: operands operand are literals + return new AstLiteral(num1.number + num2.number); + } + return new AstBinaryOperation('+', num1, num2, + num1.min + num2.min, num1.max + num2.max); + } + + function buildMulOperation(num1, num2) { + if (num2.type === 'literal') { + // optimization: second operands is a literal... + if (num2.number === 0) { + return new AstLiteral(0); // and it's 0 + } else if (num2.number === 1) { + return num1; // and it's 1 + } else if (num1.type === 'literal') { + // ... and first operands is a literal too + return new AstLiteral(num1.number * num2.number); + } + } + if (num1.type === 'literal') { + // optimization: first operands is a literal... + if (num1.number === 0) { + return new AstLiteral(0); // and it's 0 + } else if (num1.number === 1) { + return num2; // and it's 1 + } + } + var min = Math.min(num1.min * num2.min, num1.min * num2.max, + num1.max * num2.min, num1.max * num2.max); + var max = Math.max(num1.min * num2.min, num1.min * num2.max, + num1.max * num2.min, num1.max * num2.max); + return new AstBinaryOperation('*', num1, num2, min, max); + } + + function buildSubOperation(num1, num2) { + if (num2.type === 'literal') { + // optimization: second operands is a literal... + if (num2.number === 0) { + return num1; // ... and it's 0 + } else if (num1.type === 'literal') { + // ... and first operands is a literal too + return new AstLiteral(num1.number - num2.number); + } + } + if (num2.type === 'binary' && num2.op === '-' && + num1.type === 'literal' && num1.number === 1 && + num2.arg1.type === 'literal' && num2.arg1.number === 1) { + // optimization for case: 1 - (1 - x) + return num2.arg2; + } + return new AstBinaryOperation('-', num1, num2, + num1.min - num2.max, num1.max - num2.min); + } + + function buildMinOperation(num1, max) { + if (num1.min >= max) { + // optimization: num1 min value is not less than required max + return new AstLiteral(max); // just returning max + } else if (num1.max <= max) { + // optimization: num1 max value is not greater than required max + return num1; // just returning an argument + } + return new AstMin(num1, max); + } + + function PostScriptCompiler() {} + PostScriptCompiler.prototype = { + compile: function PostScriptCompiler_compile(code, domain, range) { + var stack = []; + var i, ii; + var instructions = []; + var inputSize = domain.length >> 1, outputSize = range.length >> 1; + var lastRegister = 0; + var n, j; + var num1, num2, ast1, ast2, tmpVar, item; + for (i = 0; i < inputSize; i++) { + stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1])); + } + + for (i = 0, ii = code.length; i < ii; i++) { + item = code[i]; + if (typeof item === 'number') { + stack.push(new AstLiteral(item)); + continue; + } + + switch (item) { + case 'add': + if (stack.length < 2) { + return null; + } + num2 = stack.pop(); + num1 = stack.pop(); + stack.push(buildAddOperation(num1, num2)); + break; + case 'cvr': + if (stack.length < 1) { + return null; + } + break; + case 'mul': + if (stack.length < 2) { + return null; + } + num2 = stack.pop(); + num1 = stack.pop(); + stack.push(buildMulOperation(num1, num2)); + break; + case 'sub': + if (stack.length < 2) { + return null; + } + num2 = stack.pop(); + num1 = stack.pop(); + stack.push(buildSubOperation(num1, num2)); + break; + case 'exch': + if (stack.length < 2) { + return null; + } + ast1 = stack.pop(); ast2 = stack.pop(); + stack.push(ast1, ast2); + break; + case 'pop': + if (stack.length < 1) { + return null; + } + stack.pop(); + break; + case 'index': + if (stack.length < 1) { + return null; + } + num1 = stack.pop(); + if (num1.type !== 'literal') { + return null; + } + n = num1.number; + if (n < 0 || (n|0) !== n || stack.length < n) { + return null; + } + ast1 = stack[stack.length - n - 1]; + if (ast1.type === 'literal' || ast1.type === 'var') { + stack.push(ast1); + break; + } + tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max); + stack[stack.length - n - 1] = tmpVar; + stack.push(tmpVar); + instructions.push(new AstVariableDefinition(tmpVar, ast1)); + break; + case 'dup': + if (stack.length < 1) { + return null; + } + if (typeof code[i + 1] === 'number' && code[i + 2] === 'gt' && + code[i + 3] === i + 7 && code[i + 4] === 'jz' && + code[i + 5] === 'pop' && code[i + 6] === code[i + 1]) { + // special case of the commands sequence for the min operation + num1 = stack.pop(); + stack.push(buildMinOperation(num1, code[i + 1])); + i += 6; + break; + } + ast1 = stack[stack.length - 1]; + if (ast1.type === 'literal' || ast1.type === 'var') { + // we don't have to save into intermediate variable a literal or + // variable. + stack.push(ast1); + break; + } + tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max); + stack[stack.length - 1] = tmpVar; + stack.push(tmpVar); + instructions.push(new AstVariableDefinition(tmpVar, ast1)); + break; + case 'roll': + if (stack.length < 2) { + return null; + } + num2 = stack.pop(); + num1 = stack.pop(); + if (num2.type !== 'literal' || num1.type !== 'literal') { + // both roll operands must be numbers + return null; + } + j = num2.number; + n = num1.number; + if (n <= 0 || (n|0) !== n || (j|0) !== j || stack.length < n) { + // ... and integers + return null; + } + j = ((j % n) + n) % n; + if (j === 0) { + break; // just skipping -- there are nothing to rotate + } + Array.prototype.push.apply(stack, + stack.splice(stack.length - n, n - j)); + break; + default: + return null; // unsupported operator + } + } + + if (stack.length !== outputSize) { + return null; + } + + var result = []; + instructions.forEach(function (instruction) { + var statementBuilder = new ExpressionBuilderVisitor(); + instruction.visit(statementBuilder); + result.push(statementBuilder.toString()); + }); + stack.forEach(function (expr, i) { + var statementBuilder = new ExpressionBuilderVisitor(); + expr.visit(statementBuilder); + var min = range[i * 2], max = range[i * 2 + 1]; + var out = [statementBuilder.toString()]; + if (min > expr.min) { + out.unshift('Math.max(', min, ', '); + out.push(')'); + } + if (max < expr.max) { + out.unshift('Math.min(', max, ', '); + out.push(')'); + } + out.unshift('dest[destOffset + ', i, '] = '); + out.push(';'); + result.push(out.join('')); + }); + return result.join('\n'); + } + }; + + return PostScriptCompiler; +})(); + +exports.isPDFFunction = isPDFFunction; +exports.PDFFunction = PDFFunction; +exports.PostScriptEvaluator = PostScriptEvaluator; +exports.PostScriptCompiler = PostScriptCompiler; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreColorSpace = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreFunction, root.pdfjsCoreStream); + } +}(this, function (exports, sharedUtil, corePrimitives, coreFunction, + coreStream) { + +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isString = sharedUtil.isString; +var shadow = sharedUtil.shadow; +var warn = sharedUtil.warn; +var isDict = corePrimitives.isDict; +var isName = corePrimitives.isName; +var isStream = corePrimitives.isStream; +var PDFFunction = coreFunction.PDFFunction; + +var coreImage; // see _setCoreImage below +var PDFImage; // = coreImage.PDFImage; + +var ColorSpace = (function ColorSpaceClosure() { + // Constructor should define this.numComps, this.defaultColor, this.name + function ColorSpace() { + error('should not call ColorSpace constructor'); + } + + ColorSpace.prototype = { + /** + * Converts the color value to the RGB color. The color components are + * located in the src array starting from the srcOffset. Returns the array + * of the rgb components, each value ranging from [0,255]. + */ + getRgb: function ColorSpace_getRgb(src, srcOffset) { + var rgb = new Uint8Array(3); + this.getRgbItem(src, srcOffset, rgb, 0); + return rgb; + }, + /** + * Converts the color value to the RGB color, similar to the getRgb method. + * The result placed into the dest array starting from the destOffset. + */ + getRgbItem: function ColorSpace_getRgbItem(src, srcOffset, + dest, destOffset) { + error('Should not call ColorSpace.getRgbItem'); + }, + /** + * Converts the specified number of the color values to the RGB colors. + * The colors are located in the src array starting from the srcOffset. + * The result is placed into the dest array starting from the destOffset. + * The src array items shall be in [0,2^bits) range, the dest array items + * will be in [0,255] range. alpha01 indicates how many alpha components + * there are in the dest array; it will be either 0 (RGB array) or 1 (RGBA + * array). + */ + getRgbBuffer: function ColorSpace_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + error('Should not call ColorSpace.getRgbBuffer'); + }, + /** + * Determines the number of bytes required to store the result of the + * conversion done by the getRgbBuffer method. As in getRgbBuffer, + * |alpha01| is either 0 (RGB output) or 1 (RGBA output). + */ + getOutputLength: function ColorSpace_getOutputLength(inputLength, + alpha01) { + error('Should not call ColorSpace.getOutputLength'); + }, + /** + * Returns true if source data will be equal the result/output data. + */ + isPassthrough: function ColorSpace_isPassthrough(bits) { + return false; + }, + /** + * Fills in the RGB colors in the destination buffer. alpha01 indicates + * how many alpha components there are in the dest array; it will be either + * 0 (RGB array) or 1 (RGBA array). + */ + fillRgb: function ColorSpace_fillRgb(dest, originalWidth, + originalHeight, width, height, + actualHeight, bpc, comps, alpha01) { + var count = originalWidth * originalHeight; + var rgbBuf = null; + var numComponentColors = 1 << bpc; + var needsResizing = originalHeight !== height || originalWidth !== width; + var i, ii; + + if (this.isPassthrough(bpc)) { + rgbBuf = comps; + } else if (this.numComps === 1 && count > numComponentColors && + this.name !== 'DeviceGray' && this.name !== 'DeviceRGB') { + // Optimization: create a color map when there is just one component and + // we are converting more colors than the size of the color map. We + // don't build the map if the colorspace is gray or rgb since those + // methods are faster than building a map. This mainly offers big speed + // ups for indexed and alternate colorspaces. + // + // TODO it may be worth while to cache the color map. While running + // testing I never hit a cache so I will leave that out for now (perhaps + // we are reparsing colorspaces too much?). + var allColors = bpc <= 8 ? new Uint8Array(numComponentColors) : + new Uint16Array(numComponentColors); + var key; + for (i = 0; i < numComponentColors; i++) { + allColors[i] = i; + } + var colorMap = new Uint8Array(numComponentColors * 3); + this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc, + /* alpha01 = */ 0); + + var destPos, rgbPos; + if (!needsResizing) { + // Fill in the RGB values directly into |dest|. + destPos = 0; + for (i = 0; i < count; ++i) { + key = comps[i] * 3; + dest[destPos++] = colorMap[key]; + dest[destPos++] = colorMap[key + 1]; + dest[destPos++] = colorMap[key + 2]; + destPos += alpha01; + } + } else { + rgbBuf = new Uint8Array(count * 3); + rgbPos = 0; + for (i = 0; i < count; ++i) { + key = comps[i] * 3; + rgbBuf[rgbPos++] = colorMap[key]; + rgbBuf[rgbPos++] = colorMap[key + 1]; + rgbBuf[rgbPos++] = colorMap[key + 2]; + } + } + } else { + if (!needsResizing) { + // Fill in the RGB values directly into |dest|. + this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc, + alpha01); + } else { + rgbBuf = new Uint8Array(count * 3); + this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc, + /* alpha01 = */ 0); + } + } + + if (rgbBuf) { + if (needsResizing) { + PDFImage.resize(rgbBuf, bpc, 3, originalWidth, originalHeight, width, + height, dest, alpha01); + } else { + rgbPos = 0; + destPos = 0; + for (i = 0, ii = width * actualHeight; i < ii; i++) { + dest[destPos++] = rgbBuf[rgbPos++]; + dest[destPos++] = rgbBuf[rgbPos++]; + dest[destPos++] = rgbBuf[rgbPos++]; + destPos += alpha01; + } + } + } + }, + /** + * True if the colorspace has components in the default range of [0, 1]. + * This should be true for all colorspaces except for lab color spaces + * which are [0,100], [-128, 127], [-128, 127]. + */ + usesZeroToOneRange: true + }; + + ColorSpace.parse = function ColorSpace_parse(cs, xref, res) { + var IR = ColorSpace.parseToIR(cs, xref, res); + if (IR instanceof AlternateCS) { + return IR; + } + return ColorSpace.fromIR(IR); + }; + + ColorSpace.fromIR = function ColorSpace_fromIR(IR) { + var name = isArray(IR) ? IR[0] : IR; + var whitePoint, blackPoint, gamma; + + switch (name) { + case 'DeviceGrayCS': + return this.singletons.gray; + case 'DeviceRgbCS': + return this.singletons.rgb; + case 'DeviceCmykCS': + return this.singletons.cmyk; + case 'CalGrayCS': + whitePoint = IR[1].WhitePoint; + blackPoint = IR[1].BlackPoint; + gamma = IR[1].Gamma; + return new CalGrayCS(whitePoint, blackPoint, gamma); + case 'CalRGBCS': + whitePoint = IR[1].WhitePoint; + blackPoint = IR[1].BlackPoint; + gamma = IR[1].Gamma; + var matrix = IR[1].Matrix; + return new CalRGBCS(whitePoint, blackPoint, gamma, matrix); + case 'PatternCS': + var basePatternCS = IR[1]; + if (basePatternCS) { + basePatternCS = ColorSpace.fromIR(basePatternCS); + } + return new PatternCS(basePatternCS); + case 'IndexedCS': + var baseIndexedCS = IR[1]; + var hiVal = IR[2]; + var lookup = IR[3]; + return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup); + case 'AlternateCS': + var numComps = IR[1]; + var alt = IR[2]; + var tintFnIR = IR[3]; + + return new AlternateCS(numComps, ColorSpace.fromIR(alt), + PDFFunction.fromIR(tintFnIR)); + case 'LabCS': + whitePoint = IR[1].WhitePoint; + blackPoint = IR[1].BlackPoint; + var range = IR[1].Range; + return new LabCS(whitePoint, blackPoint, range); + default: + error('Unknown name ' + name); + } + return null; + }; + + ColorSpace.parseToIR = function ColorSpace_parseToIR(cs, xref, res) { + if (isName(cs)) { + var colorSpaces = res.get('ColorSpace'); + if (isDict(colorSpaces)) { + var refcs = colorSpaces.get(cs.name); + if (refcs) { + cs = refcs; + } + } + } + + cs = xref.fetchIfRef(cs); + var mode; + + if (isName(cs)) { + mode = cs.name; + this.mode = mode; + + switch (mode) { + case 'DeviceGray': + case 'G': + return 'DeviceGrayCS'; + case 'DeviceRGB': + case 'RGB': + return 'DeviceRgbCS'; + case 'DeviceCMYK': + case 'CMYK': + return 'DeviceCmykCS'; + case 'Pattern': + return ['PatternCS', null]; + default: + error('unrecognized colorspace ' + mode); + } + } else if (isArray(cs)) { + mode = xref.fetchIfRef(cs[0]).name; + this.mode = mode; + var numComps, params, alt; + + switch (mode) { + case 'DeviceGray': + case 'G': + return 'DeviceGrayCS'; + case 'DeviceRGB': + case 'RGB': + return 'DeviceRgbCS'; + case 'DeviceCMYK': + case 'CMYK': + return 'DeviceCmykCS'; + case 'CalGray': + params = xref.fetchIfRef(cs[1]).getAll(); + return ['CalGrayCS', params]; + case 'CalRGB': + params = xref.fetchIfRef(cs[1]).getAll(); + return ['CalRGBCS', params]; + case 'ICCBased': + var stream = xref.fetchIfRef(cs[1]); + var dict = stream.dict; + numComps = dict.get('N'); + alt = dict.get('Alternate'); + if (alt) { + var altIR = ColorSpace.parseToIR(alt, xref, res); + // Parse the /Alternate CS to ensure that the number of components + // are correct, and also (indirectly) that it is not a PatternCS. + var altCS = ColorSpace.fromIR(altIR); + if (altCS.numComps === numComps) { + return altIR; + } + warn('ICCBased color space: Ignoring incorrect /Alternate entry.'); + } + if (numComps === 1) { + return 'DeviceGrayCS'; + } else if (numComps === 3) { + return 'DeviceRgbCS'; + } else if (numComps === 4) { + return 'DeviceCmykCS'; + } + break; + case 'Pattern': + var basePatternCS = cs[1] || null; + if (basePatternCS) { + basePatternCS = ColorSpace.parseToIR(basePatternCS, xref, res); + } + return ['PatternCS', basePatternCS]; + case 'Indexed': + case 'I': + var baseIndexedCS = ColorSpace.parseToIR(cs[1], xref, res); + var hiVal = xref.fetchIfRef(cs[2]) + 1; + var lookup = xref.fetchIfRef(cs[3]); + if (isStream(lookup)) { + lookup = lookup.getBytes(); + } + return ['IndexedCS', baseIndexedCS, hiVal, lookup]; + case 'Separation': + case 'DeviceN': + var name = xref.fetchIfRef(cs[1]); + numComps = 1; + if (isName(name)) { + numComps = 1; + } else if (isArray(name)) { + numComps = name.length; + } + alt = ColorSpace.parseToIR(cs[2], xref, res); + var tintFnIR = PDFFunction.getIR(xref, xref.fetchIfRef(cs[3])); + return ['AlternateCS', numComps, alt, tintFnIR]; + case 'Lab': + params = xref.fetchIfRef(cs[1]).getAll(); + return ['LabCS', params]; + default: + error('unimplemented color space object "' + mode + '"'); + } + } else { + error('unrecognized color space object: "' + cs + '"'); + } + return null; + }; + /** + * Checks if a decode map matches the default decode map for a color space. + * This handles the general decode maps where there are two values per + * component. e.g. [0, 1, 0, 1, 0, 1] for a RGB color. + * This does not handle Lab, Indexed, or Pattern decode maps since they are + * slightly different. + * @param {Array} decode Decode map (usually from an image). + * @param {Number} n Number of components the color space has. + */ + ColorSpace.isDefaultDecode = function ColorSpace_isDefaultDecode(decode, n) { + if (!isArray(decode)) { + return true; + } + + if (n * 2 !== decode.length) { + warn('The decode map is not the correct length'); + return true; + } + for (var i = 0, ii = decode.length; i < ii; i += 2) { + if (decode[i] !== 0 || decode[i + 1] !== 1) { + return false; + } + } + return true; + }; + + ColorSpace.singletons = { + get gray() { + return shadow(this, 'gray', new DeviceGrayCS()); + }, + get rgb() { + return shadow(this, 'rgb', new DeviceRgbCS()); + }, + get cmyk() { + return shadow(this, 'cmyk', new DeviceCmykCS()); + } + }; + + return ColorSpace; +})(); + +/** + * Alternate color space handles both Separation and DeviceN color spaces. A + * Separation color space is actually just a DeviceN with one color component. + * Both color spaces use a tinting function to convert colors to a base color + * space. + */ +var AlternateCS = (function AlternateCSClosure() { + function AlternateCS(numComps, base, tintFn) { + this.name = 'Alternate'; + this.numComps = numComps; + this.defaultColor = new Float32Array(numComps); + for (var i = 0; i < numComps; ++i) { + this.defaultColor[i] = 1; + } + this.base = base; + this.tintFn = tintFn; + this.tmpBuf = new Float32Array(base.numComps); + } + + AlternateCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function AlternateCS_getRgbItem(src, srcOffset, + dest, destOffset) { + var tmpBuf = this.tmpBuf; + this.tintFn(src, srcOffset, tmpBuf, 0); + this.base.getRgbItem(tmpBuf, 0, dest, destOffset); + }, + getRgbBuffer: function AlternateCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var tintFn = this.tintFn; + var base = this.base; + var scale = 1 / ((1 << bits) - 1); + var baseNumComps = base.numComps; + var usesZeroToOneRange = base.usesZeroToOneRange; + var isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) && + alpha01 === 0; + var pos = isPassthrough ? destOffset : 0; + var baseBuf = isPassthrough ? dest : new Uint8Array(baseNumComps * count); + var numComps = this.numComps; + + var scaled = new Float32Array(numComps); + var tinted = new Float32Array(baseNumComps); + var i, j; + if (usesZeroToOneRange) { + for (i = 0; i < count; i++) { + for (j = 0; j < numComps; j++) { + scaled[j] = src[srcOffset++] * scale; + } + tintFn(scaled, 0, tinted, 0); + for (j = 0; j < baseNumComps; j++) { + baseBuf[pos++] = tinted[j] * 255; + } + } + } else { + for (i = 0; i < count; i++) { + for (j = 0; j < numComps; j++) { + scaled[j] = src[srcOffset++] * scale; + } + tintFn(scaled, 0, tinted, 0); + base.getRgbItem(tinted, 0, baseBuf, pos); + pos += baseNumComps; + } + } + if (!isPassthrough) { + base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01); + } + }, + getOutputLength: function AlternateCS_getOutputLength(inputLength, + alpha01) { + return this.base.getOutputLength(inputLength * + this.base.numComps / this.numComps, + alpha01); + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function AlternateCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + + return AlternateCS; +})(); + +var PatternCS = (function PatternCSClosure() { + function PatternCS(baseCS) { + this.name = 'Pattern'; + this.base = baseCS; + } + PatternCS.prototype = {}; + + return PatternCS; +})(); + +var IndexedCS = (function IndexedCSClosure() { + function IndexedCS(base, highVal, lookup) { + this.name = 'Indexed'; + this.numComps = 1; + this.defaultColor = new Uint8Array([0]); + this.base = base; + this.highVal = highVal; + + var baseNumComps = base.numComps; + var length = baseNumComps * highVal; + var lookupArray; + + if (isStream(lookup)) { + lookupArray = new Uint8Array(length); + var bytes = lookup.getBytes(length); + lookupArray.set(bytes); + } else if (isString(lookup)) { + lookupArray = new Uint8Array(length); + for (var i = 0; i < length; ++i) { + lookupArray[i] = lookup.charCodeAt(i); + } + } else if (lookup instanceof Uint8Array || lookup instanceof Array) { + lookupArray = lookup; + } else { + error('Unrecognized lookup table: ' + lookup); + } + this.lookup = lookupArray; + } + + IndexedCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function IndexedCS_getRgbItem(src, srcOffset, + dest, destOffset) { + var numComps = this.base.numComps; + var start = src[srcOffset] * numComps; + this.base.getRgbItem(this.lookup, start, dest, destOffset); + }, + getRgbBuffer: function IndexedCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var base = this.base; + var numComps = base.numComps; + var outputDelta = base.getOutputLength(numComps, alpha01); + var lookup = this.lookup; + + for (var i = 0; i < count; ++i) { + var lookupPos = src[srcOffset++] * numComps; + base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01); + destOffset += outputDelta; + } + }, + getOutputLength: function IndexedCS_getOutputLength(inputLength, alpha01) { + return this.base.getOutputLength(inputLength * this.base.numComps, + alpha01); + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function IndexedCS_isDefaultDecode(decodeMap) { + // indexed color maps shouldn't be changed + return true; + }, + usesZeroToOneRange: true + }; + return IndexedCS; +})(); + +var DeviceGrayCS = (function DeviceGrayCSClosure() { + function DeviceGrayCS() { + this.name = 'DeviceGray'; + this.numComps = 1; + this.defaultColor = new Float32Array([0]); + } + + DeviceGrayCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function DeviceGrayCS_getRgbItem(src, srcOffset, + dest, destOffset) { + var c = (src[srcOffset] * 255) | 0; + c = c < 0 ? 0 : c > 255 ? 255 : c; + dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c; + }, + getRgbBuffer: function DeviceGrayCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var scale = 255 / ((1 << bits) - 1); + var j = srcOffset, q = destOffset; + for (var i = 0; i < count; ++i) { + var c = (scale * src[j++]) | 0; + dest[q++] = c; + dest[q++] = c; + dest[q++] = c; + q += alpha01; + } + }, + getOutputLength: function DeviceGrayCS_getOutputLength(inputLength, + alpha01) { + return inputLength * (3 + alpha01); + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function DeviceGrayCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + return DeviceGrayCS; +})(); + +var DeviceRgbCS = (function DeviceRgbCSClosure() { + function DeviceRgbCS() { + this.name = 'DeviceRGB'; + this.numComps = 3; + this.defaultColor = new Float32Array([0, 0, 0]); + } + DeviceRgbCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function DeviceRgbCS_getRgbItem(src, srcOffset, + dest, destOffset) { + var r = (src[srcOffset] * 255) | 0; + var g = (src[srcOffset + 1] * 255) | 0; + var b = (src[srcOffset + 2] * 255) | 0; + dest[destOffset] = r < 0 ? 0 : r > 255 ? 255 : r; + dest[destOffset + 1] = g < 0 ? 0 : g > 255 ? 255 : g; + dest[destOffset + 2] = b < 0 ? 0 : b > 255 ? 255 : b; + }, + getRgbBuffer: function DeviceRgbCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + if (bits === 8 && alpha01 === 0) { + dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset); + return; + } + var scale = 255 / ((1 << bits) - 1); + var j = srcOffset, q = destOffset; + for (var i = 0; i < count; ++i) { + dest[q++] = (scale * src[j++]) | 0; + dest[q++] = (scale * src[j++]) | 0; + dest[q++] = (scale * src[j++]) | 0; + q += alpha01; + } + }, + getOutputLength: function DeviceRgbCS_getOutputLength(inputLength, + alpha01) { + return (inputLength * (3 + alpha01) / 3) | 0; + }, + isPassthrough: function DeviceRgbCS_isPassthrough(bits) { + return bits === 8; + }, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function DeviceRgbCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + return DeviceRgbCS; +})(); + +var DeviceCmykCS = (function DeviceCmykCSClosure() { + // The coefficients below was found using numerical analysis: the method of + // steepest descent for the sum((f_i - color_value_i)^2) for r/g/b colors, + // where color_value is the tabular value from the table of sampled RGB colors + // from CMYK US Web Coated (SWOP) colorspace, and f_i is the corresponding + // CMYK color conversion using the estimation below: + // f(A, B,.. N) = Acc+Bcm+Ccy+Dck+c+Fmm+Gmy+Hmk+Im+Jyy+Kyk+Ly+Mkk+Nk+255 + function convertToRgb(src, srcOffset, srcScale, dest, destOffset) { + var c = src[srcOffset + 0] * srcScale; + var m = src[srcOffset + 1] * srcScale; + var y = src[srcOffset + 2] * srcScale; + var k = src[srcOffset + 3] * srcScale; + + var r = + (c * (-4.387332384609988 * c + 54.48615194189176 * m + + 18.82290502165302 * y + 212.25662451639585 * k + + -285.2331026137004) + + m * (1.7149763477362134 * m - 5.6096736904047315 * y + + -17.873870861415444 * k - 5.497006427196366) + + y * (-2.5217340131683033 * y - 21.248923337353073 * k + + 17.5119270841813) + + k * (-21.86122147463605 * k - 189.48180835922747) + 255) | 0; + var g = + (c * (8.841041422036149 * c + 60.118027045597366 * m + + 6.871425592049007 * y + 31.159100130055922 * k + + -79.2970844816548) + + m * (-15.310361306967817 * m + 17.575251261109482 * y + + 131.35250912493976 * k - 190.9453302588951) + + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) + + k * (-20.737325471181034 * k - 187.80453709719578) + 255) | 0; + var b = + (c * (0.8842522430003296 * c + 8.078677503112928 * m + + 30.89978309703729 * y - 0.23883238689178934 * k + + -14.183576799673286) + + m * (10.49593273432072 * m + 63.02378494754052 * y + + 50.606957656360734 * k - 112.23884253719248) + + y * (0.03296041114873217 * y + 115.60384449646641 * k + + -193.58209356861505) + + k * (-22.33816807309886 * k - 180.12613974708367) + 255) | 0; + + dest[destOffset] = r > 255 ? 255 : r < 0 ? 0 : r; + dest[destOffset + 1] = g > 255 ? 255 : g < 0 ? 0 : g; + dest[destOffset + 2] = b > 255 ? 255 : b < 0 ? 0 : b; + } + + function DeviceCmykCS() { + this.name = 'DeviceCMYK'; + this.numComps = 4; + this.defaultColor = new Float32Array([0, 0, 0, 1]); + } + DeviceCmykCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function DeviceCmykCS_getRgbItem(src, srcOffset, + dest, destOffset) { + convertToRgb(src, srcOffset, 1, dest, destOffset); + }, + getRgbBuffer: function DeviceCmykCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var scale = 1 / ((1 << bits) - 1); + for (var i = 0; i < count; i++) { + convertToRgb(src, srcOffset, scale, dest, destOffset); + srcOffset += 4; + destOffset += 3 + alpha01; + } + }, + getOutputLength: function DeviceCmykCS_getOutputLength(inputLength, + alpha01) { + return (inputLength / 4 * (3 + alpha01)) | 0; + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function DeviceCmykCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + + return DeviceCmykCS; +})(); + +// +// CalGrayCS: Based on "PDF Reference, Sixth Ed", p.245 +// +var CalGrayCS = (function CalGrayCSClosure() { + function CalGrayCS(whitePoint, blackPoint, gamma) { + this.name = 'CalGray'; + this.numComps = 1; + this.defaultColor = new Float32Array([0]); + + if (!whitePoint) { + error('WhitePoint missing - required for color space CalGray'); + } + blackPoint = blackPoint || [0, 0, 0]; + gamma = gamma || 1; + + // Translate arguments to spec variables. + this.XW = whitePoint[0]; + this.YW = whitePoint[1]; + this.ZW = whitePoint[2]; + + this.XB = blackPoint[0]; + this.YB = blackPoint[1]; + this.ZB = blackPoint[2]; + + this.G = gamma; + + // Validate variables as per spec. + if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) { + error('Invalid WhitePoint components for ' + this.name + + ', no fallback available'); + } + + if (this.XB < 0 || this.YB < 0 || this.ZB < 0) { + info('Invalid BlackPoint for ' + this.name + ', falling back to default'); + this.XB = this.YB = this.ZB = 0; + } + + if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) { + warn(this.name + ', BlackPoint: XB: ' + this.XB + ', YB: ' + this.YB + + ', ZB: ' + this.ZB + ', only default values are supported.'); + } + + if (this.G < 1) { + info('Invalid Gamma: ' + this.G + ' for ' + this.name + + ', falling back to default'); + this.G = 1; + } + } + + function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) { + // A represents a gray component of a calibrated gray space. + // A <---> AG in the spec + var A = src[srcOffset] * scale; + var AG = Math.pow(A, cs.G); + + // Computes L as per spec. ( = cs.YW * AG ) + // Except if other than default BlackPoint values are used. + var L = cs.YW * AG; + // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html, Ch 4. + // Convert values to rgb range [0, 255]. + var val = Math.max(295.8 * Math.pow(L, 0.333333333333333333) - 40.8, 0) | 0; + dest[destOffset] = val; + dest[destOffset + 1] = val; + dest[destOffset + 2] = val; + } + + CalGrayCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function CalGrayCS_getRgbItem(src, srcOffset, + dest, destOffset) { + convertToRgb(this, src, srcOffset, dest, destOffset, 1); + }, + getRgbBuffer: function CalGrayCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var scale = 1 / ((1 << bits) - 1); + + for (var i = 0; i < count; ++i) { + convertToRgb(this, src, srcOffset, dest, destOffset, scale); + srcOffset += 1; + destOffset += 3 + alpha01; + } + }, + getOutputLength: function CalGrayCS_getOutputLength(inputLength, alpha01) { + return inputLength * (3 + alpha01); + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function CalGrayCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + return CalGrayCS; +})(); + +// +// CalRGBCS: Based on "PDF Reference, Sixth Ed", p.247 +// +var CalRGBCS = (function CalRGBCSClosure() { + + // See http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html for these + // matrices. + var BRADFORD_SCALE_MATRIX = new Float32Array([ + 0.8951, 0.2664, -0.1614, + -0.7502, 1.7135, 0.0367, + 0.0389, -0.0685, 1.0296]); + + var BRADFORD_SCALE_INVERSE_MATRIX = new Float32Array([ + 0.9869929, -0.1470543, 0.1599627, + 0.4323053, 0.5183603, 0.0492912, + -0.0085287, 0.0400428, 0.9684867]); + + // See http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html. + var SRGB_D65_XYZ_TO_RGB_MATRIX = new Float32Array([ + 3.2404542, -1.5371385, -0.4985314, + -0.9692660, 1.8760108, 0.0415560, + 0.0556434, -0.2040259, 1.0572252]); + + var FLAT_WHITEPOINT_MATRIX = new Float32Array([1, 1, 1]); + + var tempNormalizeMatrix = new Float32Array(3); + var tempConvertMatrix1 = new Float32Array(3); + var tempConvertMatrix2 = new Float32Array(3); + + var DECODE_L_CONSTANT = Math.pow(((8 + 16) / 116), 3) / 8.0; + + function CalRGBCS(whitePoint, blackPoint, gamma, matrix) { + this.name = 'CalRGB'; + this.numComps = 3; + this.defaultColor = new Float32Array(3); + + if (!whitePoint) { + error('WhitePoint missing - required for color space CalRGB'); + } + blackPoint = blackPoint || new Float32Array(3); + gamma = gamma || new Float32Array([1, 1, 1]); + matrix = matrix || new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]); + + // Translate arguments to spec variables. + var XW = whitePoint[0]; + var YW = whitePoint[1]; + var ZW = whitePoint[2]; + this.whitePoint = whitePoint; + + var XB = blackPoint[0]; + var YB = blackPoint[1]; + var ZB = blackPoint[2]; + this.blackPoint = blackPoint; + + this.GR = gamma[0]; + this.GG = gamma[1]; + this.GB = gamma[2]; + + this.MXA = matrix[0]; + this.MYA = matrix[1]; + this.MZA = matrix[2]; + this.MXB = matrix[3]; + this.MYB = matrix[4]; + this.MZB = matrix[5]; + this.MXC = matrix[6]; + this.MYC = matrix[7]; + this.MZC = matrix[8]; + + // Validate variables as per spec. + if (XW < 0 || ZW < 0 || YW !== 1) { + error('Invalid WhitePoint components for ' + this.name + + ', no fallback available'); + } + + if (XB < 0 || YB < 0 || ZB < 0) { + info('Invalid BlackPoint for ' + this.name + ' [' + XB + ', ' + YB + + ', ' + ZB + '], falling back to default'); + this.blackPoint = new Float32Array(3); + } + + if (this.GR < 0 || this.GG < 0 || this.GB < 0) { + info('Invalid Gamma [' + this.GR + ', ' + this.GG + ', ' + this.GB + + '] for ' + this.name + ', falling back to default'); + this.GR = this.GG = this.GB = 1; + } + + if (this.MXA < 0 || this.MYA < 0 || this.MZA < 0 || + this.MXB < 0 || this.MYB < 0 || this.MZB < 0 || + this.MXC < 0 || this.MYC < 0 || this.MZC < 0) { + info('Invalid Matrix for ' + this.name + ' [' + + this.MXA + ', ' + this.MYA + ', ' + this.MZA + + this.MXB + ', ' + this.MYB + ', ' + this.MZB + + this.MXC + ', ' + this.MYC + ', ' + this.MZC + + '], falling back to default'); + this.MXA = this.MYB = this.MZC = 1; + this.MXB = this.MYA = this.MZA = this.MXC = this.MYC = this.MZB = 0; + } + } + + function matrixProduct(a, b, result) { + result[0] = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + result[1] = a[3] * b[0] + a[4] * b[1] + a[5] * b[2]; + result[2] = a[6] * b[0] + a[7] * b[1] + a[8] * b[2]; + } + + function convertToFlat(sourceWhitePoint, LMS, result) { + result[0] = LMS[0] * 1 / sourceWhitePoint[0]; + result[1] = LMS[1] * 1 / sourceWhitePoint[1]; + result[2] = LMS[2] * 1 / sourceWhitePoint[2]; + } + + function convertToD65(sourceWhitePoint, LMS, result) { + var D65X = 0.95047; + var D65Y = 1; + var D65Z = 1.08883; + + result[0] = LMS[0] * D65X / sourceWhitePoint[0]; + result[1] = LMS[1] * D65Y / sourceWhitePoint[1]; + result[2] = LMS[2] * D65Z / sourceWhitePoint[2]; + } + + function sRGBTransferFunction(color) { + // See http://en.wikipedia.org/wiki/SRGB. + if (color <= 0.0031308){ + return adjustToRange(0, 1, 12.92 * color); + } + + return adjustToRange(0, 1, (1 + 0.055) * Math.pow(color, 1 / 2.4) - 0.055); + } + + function adjustToRange(min, max, value) { + return Math.max(min, Math.min(max, value)); + } + + function decodeL(L) { + if (L < 0) { + return -decodeL(-L); + } + + if (L > 8.0) { + return Math.pow(((L + 16) / 116), 3); + } + + return L * DECODE_L_CONSTANT; + } + + function compensateBlackPoint(sourceBlackPoint, XYZ_Flat, result) { + + // In case the blackPoint is already the default blackPoint then there is + // no need to do compensation. + if (sourceBlackPoint[0] === 0 && + sourceBlackPoint[1] === 0 && + sourceBlackPoint[2] === 0) { + result[0] = XYZ_Flat[0]; + result[1] = XYZ_Flat[1]; + result[2] = XYZ_Flat[2]; + return; + } + + // For the blackPoint calculation details, please see + // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/ + // AdobeBPC.pdf. + // The destination blackPoint is the default blackPoint [0, 0, 0]. + var zeroDecodeL = decodeL(0); + + var X_DST = zeroDecodeL; + var X_SRC = decodeL(sourceBlackPoint[0]); + + var Y_DST = zeroDecodeL; + var Y_SRC = decodeL(sourceBlackPoint[1]); + + var Z_DST = zeroDecodeL; + var Z_SRC = decodeL(sourceBlackPoint[2]); + + var X_Scale = (1 - X_DST) / (1 - X_SRC); + var X_Offset = 1 - X_Scale; + + var Y_Scale = (1 - Y_DST) / (1 - Y_SRC); + var Y_Offset = 1 - Y_Scale; + + var Z_Scale = (1 - Z_DST) / (1 - Z_SRC); + var Z_Offset = 1 - Z_Scale; + + result[0] = XYZ_Flat[0] * X_Scale + X_Offset; + result[1] = XYZ_Flat[1] * Y_Scale + Y_Offset; + result[2] = XYZ_Flat[2] * Z_Scale + Z_Offset; + } + + function normalizeWhitePointToFlat(sourceWhitePoint, XYZ_In, result) { + + // In case the whitePoint is already flat then there is no need to do + // normalization. + if (sourceWhitePoint[0] === 1 && sourceWhitePoint[2] === 1) { + result[0] = XYZ_In[0]; + result[1] = XYZ_In[1]; + result[2] = XYZ_In[2]; + return; + } + + var LMS = result; + matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS); + + var LMS_Flat = tempNormalizeMatrix; + convertToFlat(sourceWhitePoint, LMS, LMS_Flat); + + matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_Flat, result); + } + + function normalizeWhitePointToD65(sourceWhitePoint, XYZ_In, result) { + + var LMS = result; + matrixProduct(BRADFORD_SCALE_MATRIX, XYZ_In, LMS); + + var LMS_D65 = tempNormalizeMatrix; + convertToD65(sourceWhitePoint, LMS, LMS_D65); + + matrixProduct(BRADFORD_SCALE_INVERSE_MATRIX, LMS_D65, result); + } + + function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) { + // A, B and C represent a red, green and blue components of a calibrated + // rgb space. + var A = adjustToRange(0, 1, src[srcOffset] * scale); + var B = adjustToRange(0, 1, src[srcOffset + 1] * scale); + var C = adjustToRange(0, 1, src[srcOffset + 2] * scale); + + // A <---> AGR in the spec + // B <---> BGG in the spec + // C <---> CGB in the spec + var AGR = Math.pow(A, cs.GR); + var BGG = Math.pow(B, cs.GG); + var CGB = Math.pow(C, cs.GB); + + // Computes intermediate variables L, M, N as per spec. + // To decode X, Y, Z values map L, M, N directly to them. + var X = cs.MXA * AGR + cs.MXB * BGG + cs.MXC * CGB; + var Y = cs.MYA * AGR + cs.MYB * BGG + cs.MYC * CGB; + var Z = cs.MZA * AGR + cs.MZB * BGG + cs.MZC * CGB; + + // The following calculations are based on this document: + // http://www.adobe.com/content/dam/Adobe/en/devnet/photoshop/sdk/ + // AdobeBPC.pdf. + var XYZ = tempConvertMatrix1; + XYZ[0] = X; + XYZ[1] = Y; + XYZ[2] = Z; + var XYZ_Flat = tempConvertMatrix2; + + normalizeWhitePointToFlat(cs.whitePoint, XYZ, XYZ_Flat); + + var XYZ_Black = tempConvertMatrix1; + compensateBlackPoint(cs.blackPoint, XYZ_Flat, XYZ_Black); + + var XYZ_D65 = tempConvertMatrix2; + normalizeWhitePointToD65(FLAT_WHITEPOINT_MATRIX, XYZ_Black, XYZ_D65); + + var SRGB = tempConvertMatrix1; + matrixProduct(SRGB_D65_XYZ_TO_RGB_MATRIX, XYZ_D65, SRGB); + + var sR = sRGBTransferFunction(SRGB[0]); + var sG = sRGBTransferFunction(SRGB[1]); + var sB = sRGBTransferFunction(SRGB[2]); + + // Convert the values to rgb range [0, 255]. + dest[destOffset] = Math.round(sR * 255); + dest[destOffset + 1] = Math.round(sG * 255); + dest[destOffset + 2] = Math.round(sB * 255); + } + + CalRGBCS.prototype = { + getRgb: function CalRGBCS_getRgb(src, srcOffset) { + var rgb = new Uint8Array(3); + this.getRgbItem(src, srcOffset, rgb, 0); + return rgb; + }, + getRgbItem: function CalRGBCS_getRgbItem(src, srcOffset, + dest, destOffset) { + convertToRgb(this, src, srcOffset, dest, destOffset, 1); + }, + getRgbBuffer: function CalRGBCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var scale = 1 / ((1 << bits) - 1); + + for (var i = 0; i < count; ++i) { + convertToRgb(this, src, srcOffset, dest, destOffset, scale); + srcOffset += 3; + destOffset += 3 + alpha01; + } + }, + getOutputLength: function CalRGBCS_getOutputLength(inputLength, alpha01) { + return (inputLength * (3 + alpha01) / 3) | 0; + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function CalRGBCS_isDefaultDecode(decodeMap) { + return ColorSpace.isDefaultDecode(decodeMap, this.numComps); + }, + usesZeroToOneRange: true + }; + return CalRGBCS; +})(); + +// +// LabCS: Based on "PDF Reference, Sixth Ed", p.250 +// +var LabCS = (function LabCSClosure() { + function LabCS(whitePoint, blackPoint, range) { + this.name = 'Lab'; + this.numComps = 3; + this.defaultColor = new Float32Array([0, 0, 0]); + + if (!whitePoint) { + error('WhitePoint missing - required for color space Lab'); + } + blackPoint = blackPoint || [0, 0, 0]; + range = range || [-100, 100, -100, 100]; + + // Translate args to spec variables + this.XW = whitePoint[0]; + this.YW = whitePoint[1]; + this.ZW = whitePoint[2]; + this.amin = range[0]; + this.amax = range[1]; + this.bmin = range[2]; + this.bmax = range[3]; + + // These are here just for completeness - the spec doesn't offer any + // formulas that use BlackPoint in Lab + this.XB = blackPoint[0]; + this.YB = blackPoint[1]; + this.ZB = blackPoint[2]; + + // Validate vars as per spec + if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) { + error('Invalid WhitePoint components, no fallback available'); + } + + if (this.XB < 0 || this.YB < 0 || this.ZB < 0) { + info('Invalid BlackPoint, falling back to default'); + this.XB = this.YB = this.ZB = 0; + } + + if (this.amin > this.amax || this.bmin > this.bmax) { + info('Invalid Range, falling back to defaults'); + this.amin = -100; + this.amax = 100; + this.bmin = -100; + this.bmax = 100; + } + } + + // Function g(x) from spec + function fn_g(x) { + if (x >= 6 / 29) { + return x * x * x; + } else { + return (108 / 841) * (x - 4 / 29); + } + } + + function decode(value, high1, low2, high2) { + return low2 + (value) * (high2 - low2) / (high1); + } + + // If decoding is needed maxVal should be 2^bits per component - 1. + function convertToRgb(cs, src, srcOffset, maxVal, dest, destOffset) { + // XXX: Lab input is in the range of [0, 100], [amin, amax], [bmin, bmax] + // not the usual [0, 1]. If a command like setFillColor is used the src + // values will already be within the correct range. However, if we are + // converting an image we have to map the values to the correct range given + // above. + // Ls,as,bs <---> L*,a*,b* in the spec + var Ls = src[srcOffset]; + var as = src[srcOffset + 1]; + var bs = src[srcOffset + 2]; + if (maxVal !== false) { + Ls = decode(Ls, maxVal, 0, 100); + as = decode(as, maxVal, cs.amin, cs.amax); + bs = decode(bs, maxVal, cs.bmin, cs.bmax); + } + + // Adjust limits of 'as' and 'bs' + as = as > cs.amax ? cs.amax : as < cs.amin ? cs.amin : as; + bs = bs > cs.bmax ? cs.bmax : bs < cs.bmin ? cs.bmin : bs; + + // Computes intermediate variables X,Y,Z as per spec + var M = (Ls + 16) / 116; + var L = M + (as / 500); + var N = M - (bs / 200); + + var X = cs.XW * fn_g(L); + var Y = cs.YW * fn_g(M); + var Z = cs.ZW * fn_g(N); + + var r, g, b; + // Using different conversions for D50 and D65 white points, + // per http://www.color.org/srgb.pdf + if (cs.ZW < 1) { + // Assuming D50 (X=0.9642, Y=1.00, Z=0.8249) + r = X * 3.1339 + Y * -1.6170 + Z * -0.4906; + g = X * -0.9785 + Y * 1.9160 + Z * 0.0333; + b = X * 0.0720 + Y * -0.2290 + Z * 1.4057; + } else { + // Assuming D65 (X=0.9505, Y=1.00, Z=1.0888) + r = X * 3.2406 + Y * -1.5372 + Z * -0.4986; + g = X * -0.9689 + Y * 1.8758 + Z * 0.0415; + b = X * 0.0557 + Y * -0.2040 + Z * 1.0570; + } + // clamp color values to [0,1] range then convert to [0,255] range. + dest[destOffset] = r <= 0 ? 0 : r >= 1 ? 255 : Math.sqrt(r) * 255 | 0; + dest[destOffset + 1] = g <= 0 ? 0 : g >= 1 ? 255 : Math.sqrt(g) * 255 | 0; + dest[destOffset + 2] = b <= 0 ? 0 : b >= 1 ? 255 : Math.sqrt(b) * 255 | 0; + } + + LabCS.prototype = { + getRgb: ColorSpace.prototype.getRgb, + getRgbItem: function LabCS_getRgbItem(src, srcOffset, dest, destOffset) { + convertToRgb(this, src, srcOffset, false, dest, destOffset); + }, + getRgbBuffer: function LabCS_getRgbBuffer(src, srcOffset, count, + dest, destOffset, bits, + alpha01) { + var maxVal = (1 << bits) - 1; + for (var i = 0; i < count; i++) { + convertToRgb(this, src, srcOffset, maxVal, dest, destOffset); + srcOffset += 3; + destOffset += 3 + alpha01; + } + }, + getOutputLength: function LabCS_getOutputLength(inputLength, alpha01) { + return (inputLength * (3 + alpha01) / 3) | 0; + }, + isPassthrough: ColorSpace.prototype.isPassthrough, + fillRgb: ColorSpace.prototype.fillRgb, + isDefaultDecode: function LabCS_isDefaultDecode(decodeMap) { + // XXX: Decoding is handled with the lab conversion because of the strange + // ranges that are used. + return true; + }, + usesZeroToOneRange: false + }; + return LabCS; +})(); + +// TODO refactor to remove dependency on image.js +function _setCoreImage(coreImage_) { + coreImage = coreImage_; + PDFImage = coreImage_.PDFImage; +} +exports._setCoreImage = _setCoreImage; + +exports.ColorSpace = ColorSpace; + +// TODO refactor to remove dependency on colorspace.js +coreStream._setCoreColorSpace(exports); +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreImage = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreColorSpace, root.pdfjsCoreStream, + root.pdfjsCoreJpx); + } +}(this, function (exports, sharedUtil, corePrimitives, coreColorSpace, + coreStream, coreJpx) { + +var ImageKind = sharedUtil.ImageKind; +var assert = sharedUtil.assert; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var warn = sharedUtil.warn; +var Name = corePrimitives.Name; +var isStream = corePrimitives.isStream; +var ColorSpace = coreColorSpace.ColorSpace; +var DecodeStream = coreStream.DecodeStream; +var Stream = coreStream.Stream; +var JpegStream = coreStream.JpegStream; +var JpxImage = coreJpx.JpxImage; + +var PDFImage = (function PDFImageClosure() { + /** + * Decode the image in the main thread if it supported. Resovles the promise + * when the image data is ready. + */ + function handleImageData(handler, xref, res, image) { + if (image instanceof JpegStream && image.isNativelyDecodable(xref, res)) { + // For natively supported jpegs send them to the main thread for decoding. + var dict = image.dict; + var colorSpace = dict.get('ColorSpace', 'CS'); + colorSpace = ColorSpace.parse(colorSpace, xref, res); + var numComps = colorSpace.numComps; + var decodePromise = handler.sendWithPromise('JpegDecode', + [image.getIR(), numComps]); + return decodePromise.then(function (message) { + var data = message.data; + return new Stream(data, 0, data.length, image.dict); + }); + } else { + return Promise.resolve(image); + } + } + + /** + * Decode and clamp a value. The formula is different from the spec because we + * don't decode to float range [0,1], we decode it in the [0,max] range. + */ + function decodeAndClamp(value, addend, coefficient, max) { + value = addend + value * coefficient; + // Clamp the value to the range + return (value < 0 ? 0 : (value > max ? max : value)); + } + + function PDFImage(xref, res, image, inline, smask, mask, isMask) { + this.image = image; + var dict = image.dict; + if (dict.has('Filter')) { + var filter = dict.get('Filter').name; + if (filter === 'JPXDecode') { + var jpxImage = new JpxImage(); + jpxImage.parseImageProperties(image.stream); + image.stream.reset(); + image.bitsPerComponent = jpxImage.bitsPerComponent; + image.numComps = jpxImage.componentsCount; + } else if (filter === 'JBIG2Decode') { + image.bitsPerComponent = 1; + image.numComps = 1; + } + } + // TODO cache rendered images? + + this.width = dict.get('Width', 'W'); + this.height = dict.get('Height', 'H'); + + if (this.width < 1 || this.height < 1) { + error('Invalid image width: ' + this.width + ' or height: ' + + this.height); + } + + this.interpolate = dict.get('Interpolate', 'I') || false; + this.imageMask = dict.get('ImageMask', 'IM') || false; + this.matte = dict.get('Matte') || false; + + var bitsPerComponent = image.bitsPerComponent; + if (!bitsPerComponent) { + bitsPerComponent = dict.get('BitsPerComponent', 'BPC'); + if (!bitsPerComponent) { + if (this.imageMask) { + bitsPerComponent = 1; + } else { + error('Bits per component missing in image: ' + this.imageMask); + } + } + } + this.bpc = bitsPerComponent; + + if (!this.imageMask) { + var colorSpace = dict.get('ColorSpace', 'CS'); + if (!colorSpace) { + info('JPX images (which do not require color spaces)'); + switch (image.numComps) { + case 1: + colorSpace = Name.get('DeviceGray'); + break; + case 3: + colorSpace = Name.get('DeviceRGB'); + break; + case 4: + colorSpace = Name.get('DeviceCMYK'); + break; + default: + error('JPX images with ' + this.numComps + + ' color components not supported.'); + } + } + this.colorSpace = ColorSpace.parse(colorSpace, xref, res); + this.numComps = this.colorSpace.numComps; + } + + this.decode = dict.get('Decode', 'D'); + this.needsDecode = false; + if (this.decode && + ((this.colorSpace && !this.colorSpace.isDefaultDecode(this.decode)) || + (isMask && !ColorSpace.isDefaultDecode(this.decode, 1)))) { + this.needsDecode = true; + // Do some preprocessing to avoid more math. + var max = (1 << bitsPerComponent) - 1; + this.decodeCoefficients = []; + this.decodeAddends = []; + for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) { + var dmin = this.decode[i]; + var dmax = this.decode[i + 1]; + this.decodeCoefficients[j] = dmax - dmin; + this.decodeAddends[j] = max * dmin; + } + } + + if (smask) { + this.smask = new PDFImage(xref, res, smask, false); + } else if (mask) { + if (isStream(mask)) { + var maskDict = mask.dict, imageMask = maskDict.get('ImageMask', 'IM'); + if (!imageMask) { + warn('Ignoring /Mask in image without /ImageMask.'); + } else { + this.mask = new PDFImage(xref, res, mask, false, null, null, true); + } + } else { + // Color key mask (just an array). + this.mask = mask; + } + } + } + /** + * Handles processing of image data and returns the Promise that is resolved + * with a PDFImage when the image is ready to be used. + */ + PDFImage.buildImage = function PDFImage_buildImage(handler, xref, + res, image, inline) { + var imagePromise = handleImageData(handler, xref, res, image); + var smaskPromise; + var maskPromise; + + var smask = image.dict.get('SMask'); + var mask = image.dict.get('Mask'); + + if (smask) { + smaskPromise = handleImageData(handler, xref, res, smask); + maskPromise = Promise.resolve(null); + } else { + smaskPromise = Promise.resolve(null); + if (mask) { + if (isStream(mask)) { + maskPromise = handleImageData(handler, xref, res, mask); + } else if (isArray(mask)) { + maskPromise = Promise.resolve(mask); + } else { + warn('Unsupported mask format.'); + maskPromise = Promise.resolve(null); + } + } else { + maskPromise = Promise.resolve(null); + } + } + return Promise.all([imagePromise, smaskPromise, maskPromise]).then( + function(results) { + var imageData = results[0]; + var smaskData = results[1]; + var maskData = results[2]; + return new PDFImage(xref, res, imageData, inline, smaskData, maskData); + }); + }; + + /** + * Resize an image using the nearest neighbor algorithm. Currently only + * supports one and three component images. + * @param {TypedArray} pixels The original image with one component. + * @param {Number} bpc Number of bits per component. + * @param {Number} components Number of color components, 1 or 3 is supported. + * @param {Number} w1 Original width. + * @param {Number} h1 Original height. + * @param {Number} w2 New width. + * @param {Number} h2 New height. + * @param {TypedArray} dest (Optional) The destination buffer. + * @param {Number} alpha01 (Optional) Size reserved for the alpha channel. + * @return {TypedArray} Resized image data. + */ + PDFImage.resize = function PDFImage_resize(pixels, bpc, components, + w1, h1, w2, h2, dest, alpha01) { + + if (components !== 1 && components !== 3) { + error('Unsupported component count for resizing.'); + } + + var length = w2 * h2 * components; + var temp = dest ? dest : (bpc <= 8 ? new Uint8Array(length) : + (bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length))); + var xRatio = w1 / w2; + var yRatio = h1 / h2; + var i, j, py, newIndex = 0, oldIndex; + var xScaled = new Uint16Array(w2); + var w1Scanline = w1 * components; + if (alpha01 !== 1) { + alpha01 = 0; + } + + for (j = 0; j < w2; j++) { + xScaled[j] = Math.floor(j * xRatio) * components; + } + + if (components === 1) { + for (i = 0; i < h2; i++) { + py = Math.floor(i * yRatio) * w1Scanline; + for (j = 0; j < w2; j++) { + oldIndex = py + xScaled[j]; + temp[newIndex++] = pixels[oldIndex]; + } + } + } else if (components === 3) { + for (i = 0; i < h2; i++) { + py = Math.floor(i * yRatio) * w1Scanline; + for (j = 0; j < w2; j++) { + oldIndex = py + xScaled[j]; + temp[newIndex++] = pixels[oldIndex++]; + temp[newIndex++] = pixels[oldIndex++]; + temp[newIndex++] = pixels[oldIndex++]; + newIndex += alpha01; + } + } + } + return temp; + }; + + PDFImage.createMask = + function PDFImage_createMask(imgArray, width, height, + imageIsFromDecodeStream, inverseDecode) { + + // |imgArray| might not contain full data for every pixel of the mask, so + // we need to distinguish between |computedLength| and |actualLength|. + // In particular, if inverseDecode is true, then the array we return must + // have a length of |computedLength|. + + var computedLength = ((width + 7) >> 3) * height; + var actualLength = imgArray.byteLength; + var haveFullData = computedLength === actualLength; + var data, i; + + if (imageIsFromDecodeStream && (!inverseDecode || haveFullData)) { + // imgArray came from a DecodeStream and its data is in an appropriate + // form, so we can just transfer it. + data = imgArray; + } else if (!inverseDecode) { + data = new Uint8Array(actualLength); + data.set(imgArray); + } else { + data = new Uint8Array(computedLength); + data.set(imgArray); + for (i = actualLength; i < computedLength; i++) { + data[i] = 0xff; + } + } + + // If necessary, invert the original mask data (but not any extra we might + // have added above). It's safe to modify the array -- whether it's the + // original or a copy, we're about to transfer it anyway, so nothing else + // in this thread can be relying on its contents. + if (inverseDecode) { + for (i = 0; i < actualLength; i++) { + data[i] = ~data[i]; + } + } + + return {data: data, width: width, height: height}; + }; + + PDFImage.prototype = { + get drawWidth() { + return Math.max(this.width, + this.smask && this.smask.width || 0, + this.mask && this.mask.width || 0); + }, + + get drawHeight() { + return Math.max(this.height, + this.smask && this.smask.height || 0, + this.mask && this.mask.height || 0); + }, + + decodeBuffer: function PDFImage_decodeBuffer(buffer) { + var bpc = this.bpc; + var numComps = this.numComps; + + var decodeAddends = this.decodeAddends; + var decodeCoefficients = this.decodeCoefficients; + var max = (1 << bpc) - 1; + var i, ii; + + if (bpc === 1) { + // If the buffer needed decode that means it just needs to be inverted. + for (i = 0, ii = buffer.length; i < ii; i++) { + buffer[i] = +!(buffer[i]); + } + return; + } + var index = 0; + for (i = 0, ii = this.width * this.height; i < ii; i++) { + for (var j = 0; j < numComps; j++) { + buffer[index] = decodeAndClamp(buffer[index], decodeAddends[j], + decodeCoefficients[j], max); + index++; + } + } + }, + + getComponents: function PDFImage_getComponents(buffer) { + var bpc = this.bpc; + + // This image doesn't require any extra work. + if (bpc === 8) { + return buffer; + } + + var width = this.width; + var height = this.height; + var numComps = this.numComps; + + var length = width * height * numComps; + var bufferPos = 0; + var output = (bpc <= 8 ? new Uint8Array(length) : + (bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length))); + var rowComps = width * numComps; + + var max = (1 << bpc) - 1; + var i = 0, ii, buf; + + if (bpc === 1) { + // Optimization for reading 1 bpc images. + var mask, loop1End, loop2End; + for (var j = 0; j < height; j++) { + loop1End = i + (rowComps & ~7); + loop2End = i + rowComps; + + // unroll loop for all full bytes + while (i < loop1End) { + buf = buffer[bufferPos++]; + output[i] = (buf >> 7) & 1; + output[i + 1] = (buf >> 6) & 1; + output[i + 2] = (buf >> 5) & 1; + output[i + 3] = (buf >> 4) & 1; + output[i + 4] = (buf >> 3) & 1; + output[i + 5] = (buf >> 2) & 1; + output[i + 6] = (buf >> 1) & 1; + output[i + 7] = buf & 1; + i += 8; + } + + // handle remaing bits + if (i < loop2End) { + buf = buffer[bufferPos++]; + mask = 128; + while (i < loop2End) { + output[i++] = +!!(buf & mask); + mask >>= 1; + } + } + } + } else { + // The general case that handles all other bpc values. + var bits = 0; + buf = 0; + for (i = 0, ii = length; i < ii; ++i) { + if (i % rowComps === 0) { + buf = 0; + bits = 0; + } + + while (bits < bpc) { + buf = (buf << 8) | buffer[bufferPos++]; + bits += 8; + } + + var remainingBits = bits - bpc; + var value = buf >> remainingBits; + output[i] = (value < 0 ? 0 : (value > max ? max : value)); + buf = buf & ((1 << remainingBits) - 1); + bits = remainingBits; + } + } + return output; + }, + + fillOpacity: function PDFImage_fillOpacity(rgbaBuf, width, height, + actualHeight, image) { + var smask = this.smask; + var mask = this.mask; + var alphaBuf, sw, sh, i, ii, j; + + if (smask) { + sw = smask.width; + sh = smask.height; + alphaBuf = new Uint8Array(sw * sh); + smask.fillGrayBuffer(alphaBuf); + if (sw !== width || sh !== height) { + alphaBuf = PDFImage.resize(alphaBuf, smask.bpc, 1, sw, sh, width, + height); + } + } else if (mask) { + if (mask instanceof PDFImage) { + sw = mask.width; + sh = mask.height; + alphaBuf = new Uint8Array(sw * sh); + mask.numComps = 1; + mask.fillGrayBuffer(alphaBuf); + + // Need to invert values in rgbaBuf + for (i = 0, ii = sw * sh; i < ii; ++i) { + alphaBuf[i] = 255 - alphaBuf[i]; + } + + if (sw !== width || sh !== height) { + alphaBuf = PDFImage.resize(alphaBuf, mask.bpc, 1, sw, sh, width, + height); + } + } else if (isArray(mask)) { + // Color key mask: if any of the compontents are outside the range + // then they should be painted. + alphaBuf = new Uint8Array(width * height); + var numComps = this.numComps; + for (i = 0, ii = width * height; i < ii; ++i) { + var opacity = 0; + var imageOffset = i * numComps; + for (j = 0; j < numComps; ++j) { + var color = image[imageOffset + j]; + var maskOffset = j * 2; + if (color < mask[maskOffset] || color > mask[maskOffset + 1]) { + opacity = 255; + break; + } + } + alphaBuf[i] = opacity; + } + } else { + error('Unknown mask format.'); + } + } + + if (alphaBuf) { + for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) { + rgbaBuf[j] = alphaBuf[i]; + } + } else { + // No mask. + for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) { + rgbaBuf[j] = 255; + } + } + }, + + undoPreblend: function PDFImage_undoPreblend(buffer, width, height) { + var matte = this.smask && this.smask.matte; + if (!matte) { + return; + } + var matteRgb = this.colorSpace.getRgb(matte, 0); + var matteR = matteRgb[0]; + var matteG = matteRgb[1]; + var matteB = matteRgb[2]; + var length = width * height * 4; + var r, g, b; + for (var i = 0; i < length; i += 4) { + var alpha = buffer[i + 3]; + if (alpha === 0) { + // according formula we have to get Infinity in all components + // making it white (typical paper color) should be okay + buffer[i] = 255; + buffer[i + 1] = 255; + buffer[i + 2] = 255; + continue; + } + var k = 255 / alpha; + r = (buffer[i] - matteR) * k + matteR; + g = (buffer[i + 1] - matteG) * k + matteG; + b = (buffer[i + 2] - matteB) * k + matteB; + buffer[i] = r <= 0 ? 0 : r >= 255 ? 255 : r | 0; + buffer[i + 1] = g <= 0 ? 0 : g >= 255 ? 255 : g | 0; + buffer[i + 2] = b <= 0 ? 0 : b >= 255 ? 255 : b | 0; + } + }, + + createImageData: function PDFImage_createImageData(forceRGBA) { + var drawWidth = this.drawWidth; + var drawHeight = this.drawHeight; + var imgData = { // other fields are filled in below + width: drawWidth, + height: drawHeight + }; + + var numComps = this.numComps; + var originalWidth = this.width; + var originalHeight = this.height; + var bpc = this.bpc; + + // Rows start at byte boundary. + var rowBytes = (originalWidth * numComps * bpc + 7) >> 3; + var imgArray; + + if (!forceRGBA) { + // If it is a 1-bit-per-pixel grayscale (i.e. black-and-white) image + // without any complications, we pass a same-sized copy to the main + // thread rather than expanding by 32x to RGBA form. This saves *lots* + // of memory for many scanned documents. It's also much faster. + // + // Similarly, if it is a 24-bit-per pixel RGB image without any + // complications, we avoid expanding by 1.333x to RGBA form. + var kind; + if (this.colorSpace.name === 'DeviceGray' && bpc === 1) { + kind = ImageKind.GRAYSCALE_1BPP; + } else if (this.colorSpace.name === 'DeviceRGB' && bpc === 8 && + !this.needsDecode) { + kind = ImageKind.RGB_24BPP; + } + if (kind && !this.smask && !this.mask && + drawWidth === originalWidth && drawHeight === originalHeight) { + imgData.kind = kind; + + imgArray = this.getImageBytes(originalHeight * rowBytes); + // If imgArray came from a DecodeStream, we're safe to transfer it + // (and thus neuter it) because it will constitute the entire + // DecodeStream's data. But if it came from a Stream, we need to + // copy it because it'll only be a portion of the Stream's data, and + // the rest will be read later on. + if (this.image instanceof DecodeStream) { + imgData.data = imgArray; + } else { + var newArray = new Uint8Array(imgArray.length); + newArray.set(imgArray); + imgData.data = newArray; + } + if (this.needsDecode) { + // Invert the buffer (which must be grayscale if we reached here). + assert(kind === ImageKind.GRAYSCALE_1BPP); + var buffer = imgData.data; + for (var i = 0, ii = buffer.length; i < ii; i++) { + buffer[i] ^= 0xff; + } + } + return imgData; + } + if (this.image instanceof JpegStream && !this.smask && !this.mask && + (this.colorSpace.name === 'DeviceGray' || + this.colorSpace.name === 'DeviceRGB' || + this.colorSpace.name === 'DeviceCMYK')) { + imgData.kind = ImageKind.RGB_24BPP; + imgData.data = this.getImageBytes(originalHeight * rowBytes, + drawWidth, drawHeight, true); + return imgData; + } + } + + imgArray = this.getImageBytes(originalHeight * rowBytes); + // imgArray can be incomplete (e.g. after CCITT fax encoding). + var actualHeight = 0 | (imgArray.length / rowBytes * + drawHeight / originalHeight); + + var comps = this.getComponents(imgArray); + + // If opacity data is present, use RGBA_32BPP form. Otherwise, use the + // more compact RGB_24BPP form if allowable. + var alpha01, maybeUndoPreblend; + if (!forceRGBA && !this.smask && !this.mask) { + imgData.kind = ImageKind.RGB_24BPP; + imgData.data = new Uint8Array(drawWidth * drawHeight * 3); + alpha01 = 0; + maybeUndoPreblend = false; + } else { + imgData.kind = ImageKind.RGBA_32BPP; + imgData.data = new Uint8Array(drawWidth * drawHeight * 4); + alpha01 = 1; + maybeUndoPreblend = true; + + // Color key masking (opacity) must be performed before decoding. + this.fillOpacity(imgData.data, drawWidth, drawHeight, actualHeight, + comps); + } + + if (this.needsDecode) { + this.decodeBuffer(comps); + } + this.colorSpace.fillRgb(imgData.data, originalWidth, originalHeight, + drawWidth, drawHeight, actualHeight, bpc, comps, + alpha01); + if (maybeUndoPreblend) { + this.undoPreblend(imgData.data, drawWidth, actualHeight); + } + + return imgData; + }, + + fillGrayBuffer: function PDFImage_fillGrayBuffer(buffer) { + var numComps = this.numComps; + if (numComps !== 1) { + error('Reading gray scale from a color image: ' + numComps); + } + + var width = this.width; + var height = this.height; + var bpc = this.bpc; + + // rows start at byte boundary + var rowBytes = (width * numComps * bpc + 7) >> 3; + var imgArray = this.getImageBytes(height * rowBytes); + + var comps = this.getComponents(imgArray); + var i, length; + + if (bpc === 1) { + // inline decoding (= inversion) for 1 bpc images + length = width * height; + if (this.needsDecode) { + // invert and scale to {0, 255} + for (i = 0; i < length; ++i) { + buffer[i] = (comps[i] - 1) & 255; + } + } else { + // scale to {0, 255} + for (i = 0; i < length; ++i) { + buffer[i] = (-comps[i]) & 255; + } + } + return; + } + + if (this.needsDecode) { + this.decodeBuffer(comps); + } + length = width * height; + // we aren't using a colorspace so we need to scale the value + var scale = 255 / ((1 << bpc) - 1); + for (i = 0; i < length; ++i) { + buffer[i] = (scale * comps[i]) | 0; + } + }, + + getImageBytes: function PDFImage_getImageBytes(length, + drawWidth, drawHeight, + forceRGB) { + this.image.reset(); + this.image.drawWidth = drawWidth || this.width; + this.image.drawHeight = drawHeight || this.height; + this.image.forceRGB = !!forceRGB; + return this.image.getBytes(length); + } + }; + return PDFImage; +})(); + +exports.PDFImage = PDFImage; + +// TODO refactor to remove dependency on colorspace.js +coreColorSpace._setCoreImage(exports); +})); + + +(function (root, factory) { + { + factory((root.pdfjsCorePattern = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreFunction, + root.pdfjsCoreColorSpace); + } +}(this, function (exports, sharedUtil, corePrimitives, coreFunction, + coreColorSpace) { + +var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES; +var MissingDataException = sharedUtil.MissingDataException; +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var error = sharedUtil.error; +var info = sharedUtil.info; +var warn = sharedUtil.warn; +var isStream = corePrimitives.isStream; +var PDFFunction = coreFunction.PDFFunction; +var ColorSpace = coreColorSpace.ColorSpace; + +var ShadingType = { + FUNCTION_BASED: 1, + AXIAL: 2, + RADIAL: 3, + FREE_FORM_MESH: 4, + LATTICE_FORM_MESH: 5, + COONS_PATCH_MESH: 6, + TENSOR_PATCH_MESH: 7 +}; + +var Pattern = (function PatternClosure() { + // Constructor should define this.getPattern + function Pattern() { + error('should not call Pattern constructor'); + } + + Pattern.prototype = { + // Input: current Canvas context + // Output: the appropriate fillStyle or strokeStyle + getPattern: function Pattern_getPattern(ctx) { + error('Should not call Pattern.getStyle: ' + ctx); + } + }; + + Pattern.parseShading = function Pattern_parseShading(shading, matrix, xref, + res, handler) { + + var dict = isStream(shading) ? shading.dict : shading; + var type = dict.get('ShadingType'); + + try { + switch (type) { + case ShadingType.AXIAL: + case ShadingType.RADIAL: + // Both radial and axial shadings are handled by RadialAxial shading. + return new Shadings.RadialAxial(dict, matrix, xref, res); + case ShadingType.FREE_FORM_MESH: + case ShadingType.LATTICE_FORM_MESH: + case ShadingType.COONS_PATCH_MESH: + case ShadingType.TENSOR_PATCH_MESH: + return new Shadings.Mesh(shading, matrix, xref, res); + default: + throw new Error('Unsupported ShadingType: ' + type); + } + } catch (ex) { + if (ex instanceof MissingDataException) { + throw ex; + } + handler.send('UnsupportedFeature', + {featureId: UNSUPPORTED_FEATURES.shadingPattern}); + warn(ex); + return new Shadings.Dummy(); + } + }; + return Pattern; +})(); + +var Shadings = {}; + +// A small number to offset the first/last color stops so we can insert ones to +// support extend. Number.MIN_VALUE is too small and breaks the extend. +Shadings.SMALL_NUMBER = 1e-6; + +// Radial and axial shading have very similar implementations +// If needed, the implementations can be broken into two classes +Shadings.RadialAxial = (function RadialAxialClosure() { + function RadialAxial(dict, matrix, xref, res) { + this.matrix = matrix; + this.coordsArr = dict.get('Coords'); + this.shadingType = dict.get('ShadingType'); + this.type = 'Pattern'; + var cs = dict.get('ColorSpace', 'CS'); + cs = ColorSpace.parse(cs, xref, res); + this.cs = cs; + + var t0 = 0.0, t1 = 1.0; + if (dict.has('Domain')) { + var domainArr = dict.get('Domain'); + t0 = domainArr[0]; + t1 = domainArr[1]; + } + + var extendStart = false, extendEnd = false; + if (dict.has('Extend')) { + var extendArr = dict.get('Extend'); + extendStart = extendArr[0]; + extendEnd = extendArr[1]; + } + + if (this.shadingType === ShadingType.RADIAL && + (!extendStart || !extendEnd)) { + // Radial gradient only currently works if either circle is fully within + // the other circle. + var x1 = this.coordsArr[0]; + var y1 = this.coordsArr[1]; + var r1 = this.coordsArr[2]; + var x2 = this.coordsArr[3]; + var y2 = this.coordsArr[4]; + var r2 = this.coordsArr[5]; + var distance = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); + if (r1 <= r2 + distance && + r2 <= r1 + distance) { + warn('Unsupported radial gradient.'); + } + } + + this.extendStart = extendStart; + this.extendEnd = extendEnd; + + var fnObj = dict.get('Function'); + var fn = PDFFunction.parseArray(xref, fnObj); + + // 10 samples seems good enough for now, but probably won't work + // if there are sharp color changes. Ideally, we would implement + // the spec faithfully and add lossless optimizations. + var diff = t1 - t0; + var step = diff / 10; + + var colorStops = this.colorStops = []; + + // Protect against bad domains so we don't end up in an infinte loop below. + if (t0 >= t1 || step <= 0) { + // Acrobat doesn't seem to handle these cases so we'll ignore for + // now. + info('Bad shading domain.'); + return; + } + + var color = new Float32Array(cs.numComps), ratio = new Float32Array(1); + var rgbColor; + for (var i = t0; i <= t1; i += step) { + ratio[0] = i; + fn(ratio, 0, color, 0); + rgbColor = cs.getRgb(color, 0); + var cssColor = Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]); + colorStops.push([(i - t0) / diff, cssColor]); + } + + var background = 'transparent'; + if (dict.has('Background')) { + rgbColor = cs.getRgb(dict.get('Background'), 0); + background = Util.makeCssRgb(rgbColor[0], rgbColor[1], rgbColor[2]); + } + + if (!extendStart) { + // Insert a color stop at the front and offset the first real color stop + // so it doesn't conflict with the one we insert. + colorStops.unshift([0, background]); + colorStops[1][0] += Shadings.SMALL_NUMBER; + } + if (!extendEnd) { + // Same idea as above in extendStart but for the end. + colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER; + colorStops.push([1, background]); + } + + this.colorStops = colorStops; + } + + RadialAxial.prototype = { + getIR: function RadialAxial_getIR() { + var coordsArr = this.coordsArr; + var shadingType = this.shadingType; + var type, p0, p1, r0, r1; + if (shadingType === ShadingType.AXIAL) { + p0 = [coordsArr[0], coordsArr[1]]; + p1 = [coordsArr[2], coordsArr[3]]; + r0 = null; + r1 = null; + type = 'axial'; + } else if (shadingType === ShadingType.RADIAL) { + p0 = [coordsArr[0], coordsArr[1]]; + p1 = [coordsArr[3], coordsArr[4]]; + r0 = coordsArr[2]; + r1 = coordsArr[5]; + type = 'radial'; + } else { + error('getPattern type unknown: ' + shadingType); + } + + var matrix = this.matrix; + if (matrix) { + p0 = Util.applyTransform(p0, matrix); + p1 = Util.applyTransform(p1, matrix); + if (shadingType === ShadingType.RADIAL) { + var scale = Util.singularValueDecompose2dScale(matrix); + r0 *= scale[0]; + r1 *= scale[1]; + } + } + + return ['RadialAxial', type, this.colorStops, p0, p1, r0, r1]; + } + }; + + return RadialAxial; +})(); + +// All mesh shading. For now, they will be presented as set of the triangles +// to be drawn on the canvas and rgb color for each vertex. +Shadings.Mesh = (function MeshClosure() { + function MeshStreamReader(stream, context) { + this.stream = stream; + this.context = context; + this.buffer = 0; + this.bufferLength = 0; + + var numComps = context.numComps; + this.tmpCompsBuf = new Float32Array(numComps); + var csNumComps = context.colorSpace.numComps; + this.tmpCsCompsBuf = context.colorFn ? new Float32Array(csNumComps) : + this.tmpCompsBuf; + } + MeshStreamReader.prototype = { + get hasData() { + if (this.stream.end) { + return this.stream.pos < this.stream.end; + } + if (this.bufferLength > 0) { + return true; + } + var nextByte = this.stream.getByte(); + if (nextByte < 0) { + return false; + } + this.buffer = nextByte; + this.bufferLength = 8; + return true; + }, + readBits: function MeshStreamReader_readBits(n) { + var buffer = this.buffer; + var bufferLength = this.bufferLength; + if (n === 32) { + if (bufferLength === 0) { + return ((this.stream.getByte() << 24) | + (this.stream.getByte() << 16) | (this.stream.getByte() << 8) | + this.stream.getByte()) >>> 0; + } + buffer = (buffer << 24) | (this.stream.getByte() << 16) | + (this.stream.getByte() << 8) | this.stream.getByte(); + var nextByte = this.stream.getByte(); + this.buffer = nextByte & ((1 << bufferLength) - 1); + return ((buffer << (8 - bufferLength)) | + ((nextByte & 0xFF) >> bufferLength)) >>> 0; + } + if (n === 8 && bufferLength === 0) { + return this.stream.getByte(); + } + while (bufferLength < n) { + buffer = (buffer << 8) | this.stream.getByte(); + bufferLength += 8; + } + bufferLength -= n; + this.bufferLength = bufferLength; + this.buffer = buffer & ((1 << bufferLength) - 1); + return buffer >> bufferLength; + }, + align: function MeshStreamReader_align() { + this.buffer = 0; + this.bufferLength = 0; + }, + readFlag: function MeshStreamReader_readFlag() { + return this.readBits(this.context.bitsPerFlag); + }, + readCoordinate: function MeshStreamReader_readCoordinate() { + var bitsPerCoordinate = this.context.bitsPerCoordinate; + var xi = this.readBits(bitsPerCoordinate); + var yi = this.readBits(bitsPerCoordinate); + var decode = this.context.decode; + var scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) : + 2.3283064365386963e-10; // 2 ^ -32 + return [ + xi * scale * (decode[1] - decode[0]) + decode[0], + yi * scale * (decode[3] - decode[2]) + decode[2] + ]; + }, + readComponents: function MeshStreamReader_readComponents() { + var numComps = this.context.numComps; + var bitsPerComponent = this.context.bitsPerComponent; + var scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) : + 2.3283064365386963e-10; // 2 ^ -32 + var decode = this.context.decode; + var components = this.tmpCompsBuf; + for (var i = 0, j = 4; i < numComps; i++, j += 2) { + var ci = this.readBits(bitsPerComponent); + components[i] = ci * scale * (decode[j + 1] - decode[j]) + decode[j]; + } + var color = this.tmpCsCompsBuf; + if (this.context.colorFn) { + this.context.colorFn(components, 0, color, 0); + } + return this.context.colorSpace.getRgb(color, 0); + } + }; + + function decodeType4Shading(mesh, reader) { + var coords = mesh.coords; + var colors = mesh.colors; + var operators = []; + var ps = []; // not maintaining cs since that will match ps + var verticesLeft = 0; // assuming we have all data to start a new triangle + while (reader.hasData) { + var f = reader.readFlag(); + var coord = reader.readCoordinate(); + var color = reader.readComponents(); + if (verticesLeft === 0) { // ignoring flags if we started a triangle + assert(0 <= f && f <= 2, 'Unknown type4 flag'); + switch (f) { + case 0: + verticesLeft = 3; + break; + case 1: + ps.push(ps[ps.length - 2], ps[ps.length - 1]); + verticesLeft = 1; + break; + case 2: + ps.push(ps[ps.length - 3], ps[ps.length - 1]); + verticesLeft = 1; + break; + } + operators.push(f); + } + ps.push(coords.length); + coords.push(coord); + colors.push(color); + verticesLeft--; + + reader.align(); + } + mesh.figures.push({ + type: 'triangles', + coords: new Int32Array(ps), + colors: new Int32Array(ps), + }); + } + + function decodeType5Shading(mesh, reader, verticesPerRow) { + var coords = mesh.coords; + var colors = mesh.colors; + var ps = []; // not maintaining cs since that will match ps + while (reader.hasData) { + var coord = reader.readCoordinate(); + var color = reader.readComponents(); + ps.push(coords.length); + coords.push(coord); + colors.push(color); + } + mesh.figures.push({ + type: 'lattice', + coords: new Int32Array(ps), + colors: new Int32Array(ps), + verticesPerRow: verticesPerRow + }); + } + + var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3; + var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20; + + var TRIANGLE_DENSITY = 20; // count of triangles per entire mesh bounds + + var getB = (function getBClosure() { + function buildB(count) { + var lut = []; + for (var i = 0; i <= count; i++) { + var t = i / count, t_ = 1 - t; + lut.push(new Float32Array([t_ * t_ * t_, 3 * t * t_ * t_, + 3 * t * t * t_, t * t * t])); + } + return lut; + } + var cache = []; + return function getB(count) { + if (!cache[count]) { + cache[count] = buildB(count); + } + return cache[count]; + }; + })(); + + function buildFigureFromPatch(mesh, index) { + var figure = mesh.figures[index]; + assert(figure.type === 'patch', 'Unexpected patch mesh figure'); + + var coords = mesh.coords, colors = mesh.colors; + var pi = figure.coords; + var ci = figure.colors; + + var figureMinX = Math.min(coords[pi[0]][0], coords[pi[3]][0], + coords[pi[12]][0], coords[pi[15]][0]); + var figureMinY = Math.min(coords[pi[0]][1], coords[pi[3]][1], + coords[pi[12]][1], coords[pi[15]][1]); + var figureMaxX = Math.max(coords[pi[0]][0], coords[pi[3]][0], + coords[pi[12]][0], coords[pi[15]][0]); + var figureMaxY = Math.max(coords[pi[0]][1], coords[pi[3]][1], + coords[pi[12]][1], coords[pi[15]][1]); + var splitXBy = Math.ceil((figureMaxX - figureMinX) * TRIANGLE_DENSITY / + (mesh.bounds[2] - mesh.bounds[0])); + splitXBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, + Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy)); + var splitYBy = Math.ceil((figureMaxY - figureMinY) * TRIANGLE_DENSITY / + (mesh.bounds[3] - mesh.bounds[1])); + splitYBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT, + Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy)); + + var verticesPerRow = splitXBy + 1; + var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow); + var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow); + var k = 0; + var cl = new Uint8Array(3), cr = new Uint8Array(3); + var c0 = colors[ci[0]], c1 = colors[ci[1]], + c2 = colors[ci[2]], c3 = colors[ci[3]]; + var bRow = getB(splitYBy), bCol = getB(splitXBy); + for (var row = 0; row <= splitYBy; row++) { + cl[0] = ((c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy) | 0; + cl[1] = ((c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy) | 0; + cl[2] = ((c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy) | 0; + + cr[0] = ((c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy) | 0; + cr[1] = ((c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy) | 0; + cr[2] = ((c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy) | 0; + + for (var col = 0; col <= splitXBy; col++, k++) { + if ((row === 0 || row === splitYBy) && + (col === 0 || col === splitXBy)) { + continue; + } + var x = 0, y = 0; + var q = 0; + for (var i = 0; i <= 3; i++) { + for (var j = 0; j <= 3; j++, q++) { + var m = bRow[row][i] * bCol[col][j]; + x += coords[pi[q]][0] * m; + y += coords[pi[q]][1] * m; + } + } + figureCoords[k] = coords.length; + coords.push([x, y]); + figureColors[k] = colors.length; + var newColor = new Uint8Array(3); + newColor[0] = ((cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy) | 0; + newColor[1] = ((cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy) | 0; + newColor[2] = ((cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy) | 0; + colors.push(newColor); + } + } + figureCoords[0] = pi[0]; + figureColors[0] = ci[0]; + figureCoords[splitXBy] = pi[3]; + figureColors[splitXBy] = ci[1]; + figureCoords[verticesPerRow * splitYBy] = pi[12]; + figureColors[verticesPerRow * splitYBy] = ci[2]; + figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15]; + figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3]; + + mesh.figures[index] = { + type: 'lattice', + coords: figureCoords, + colors: figureColors, + verticesPerRow: verticesPerRow + }; + } + + function decodeType6Shading(mesh, reader) { + // A special case of Type 7. The p11, p12, p21, p22 automatically filled + var coords = mesh.coords; + var colors = mesh.colors; + var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33 + var cs = new Int32Array(4); // c00, c30, c03, c33 + while (reader.hasData) { + var f = reader.readFlag(); + assert(0 <= f && f <= 3, 'Unknown type6 flag'); + var i, ii; + var pi = coords.length; + for (i = 0, ii = (f !== 0 ? 8 : 12); i < ii; i++) { + coords.push(reader.readCoordinate()); + } + var ci = colors.length; + for (i = 0, ii = (f !== 0 ? 2 : 4); i < ii; i++) { + colors.push(reader.readComponents()); + } + var tmp1, tmp2, tmp3, tmp4; + switch (f) { + case 0: + ps[12] = pi + 3; ps[13] = pi + 4; ps[14] = pi + 5; ps[15] = pi + 6; + ps[ 8] = pi + 2; /* values for 5, 6, 9, 10 are */ ps[11] = pi + 7; + ps[ 4] = pi + 1; /* calculated below */ ps[ 7] = pi + 8; + ps[ 0] = pi; ps[ 1] = pi + 11; ps[ 2] = pi + 10; ps[ 3] = pi + 9; + cs[2] = ci + 1; cs[3] = ci + 2; + cs[0] = ci; cs[1] = ci + 3; + break; + case 1: + tmp1 = ps[12]; tmp2 = ps[13]; tmp3 = ps[14]; tmp4 = ps[15]; + ps[12] = tmp4; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = tmp3; /* values for 5, 6, 9, 10 are */ ps[11] = pi + 3; + ps[ 4] = tmp2; /* calculated below */ ps[ 7] = pi + 4; + ps[ 0] = tmp1; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + tmp1 = cs[2]; tmp2 = cs[3]; + cs[2] = tmp2; cs[3] = ci; + cs[0] = tmp1; cs[1] = ci + 1; + break; + case 2: + tmp1 = ps[15]; + tmp2 = ps[11]; + ps[12] = ps[3]; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = ps[7]; /* values for 5, 6, 9, 10 are */ ps[11] = pi + 3; + ps[ 4] = tmp2; /* calculated below */ ps[ 7] = pi + 4; + ps[ 0] = tmp1; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + tmp1 = cs[3]; + cs[2] = cs[1]; cs[3] = ci; + cs[0] = tmp1; cs[1] = ci + 1; + break; + case 3: + ps[12] = ps[0]; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = ps[1]; /* values for 5, 6, 9, 10 are */ ps[11] = pi + 3; + ps[ 4] = ps[2]; /* calculated below */ ps[ 7] = pi + 4; + ps[ 0] = ps[3]; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + cs[2] = cs[0]; cs[3] = ci; + cs[0] = cs[1]; cs[1] = ci + 1; + break; + } + // set p11, p12, p21, p22 + ps[5] = coords.length; + coords.push([ + (-4 * coords[ps[0]][0] - coords[ps[15]][0] + + 6 * (coords[ps[4]][0] + coords[ps[1]][0]) - + 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + + 3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9, + (-4 * coords[ps[0]][1] - coords[ps[15]][1] + + 6 * (coords[ps[4]][1] + coords[ps[1]][1]) - + 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + + 3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9 + ]); + ps[6] = coords.length; + coords.push([ + (-4 * coords[ps[3]][0] - coords[ps[12]][0] + + 6 * (coords[ps[2]][0] + coords[ps[7]][0]) - + 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + + 3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9, + (-4 * coords[ps[3]][1] - coords[ps[12]][1] + + 6 * (coords[ps[2]][1] + coords[ps[7]][1]) - + 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + + 3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9 + ]); + ps[9] = coords.length; + coords.push([ + (-4 * coords[ps[12]][0] - coords[ps[3]][0] + + 6 * (coords[ps[8]][0] + coords[ps[13]][0]) - + 2 * (coords[ps[0]][0] + coords[ps[15]][0]) + + 3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9, + (-4 * coords[ps[12]][1] - coords[ps[3]][1] + + 6 * (coords[ps[8]][1] + coords[ps[13]][1]) - + 2 * (coords[ps[0]][1] + coords[ps[15]][1]) + + 3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9 + ]); + ps[10] = coords.length; + coords.push([ + (-4 * coords[ps[15]][0] - coords[ps[0]][0] + + 6 * (coords[ps[11]][0] + coords[ps[14]][0]) - + 2 * (coords[ps[12]][0] + coords[ps[3]][0]) + + 3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9, + (-4 * coords[ps[15]][1] - coords[ps[0]][1] + + 6 * (coords[ps[11]][1] + coords[ps[14]][1]) - + 2 * (coords[ps[12]][1] + coords[ps[3]][1]) + + 3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9 + ]); + mesh.figures.push({ + type: 'patch', + coords: new Int32Array(ps), // making copies of ps and cs + colors: new Int32Array(cs) + }); + } + } + + function decodeType7Shading(mesh, reader) { + var coords = mesh.coords; + var colors = mesh.colors; + var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33 + var cs = new Int32Array(4); // c00, c30, c03, c33 + while (reader.hasData) { + var f = reader.readFlag(); + assert(0 <= f && f <= 3, 'Unknown type7 flag'); + var i, ii; + var pi = coords.length; + for (i = 0, ii = (f !== 0 ? 12 : 16); i < ii; i++) { + coords.push(reader.readCoordinate()); + } + var ci = colors.length; + for (i = 0, ii = (f !== 0 ? 2 : 4); i < ii; i++) { + colors.push(reader.readComponents()); + } + var tmp1, tmp2, tmp3, tmp4; + switch (f) { + case 0: + ps[12] = pi + 3; ps[13] = pi + 4; ps[14] = pi + 5; ps[15] = pi + 6; + ps[ 8] = pi + 2; ps[ 9] = pi + 13; ps[10] = pi + 14; ps[11] = pi + 7; + ps[ 4] = pi + 1; ps[ 5] = pi + 12; ps[ 6] = pi + 15; ps[ 7] = pi + 8; + ps[ 0] = pi; ps[ 1] = pi + 11; ps[ 2] = pi + 10; ps[ 3] = pi + 9; + cs[2] = ci + 1; cs[3] = ci + 2; + cs[0] = ci; cs[1] = ci + 3; + break; + case 1: + tmp1 = ps[12]; tmp2 = ps[13]; tmp3 = ps[14]; tmp4 = ps[15]; + ps[12] = tmp4; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = tmp3; ps[ 9] = pi + 9; ps[10] = pi + 10; ps[11] = pi + 3; + ps[ 4] = tmp2; ps[ 5] = pi + 8; ps[ 6] = pi + 11; ps[ 7] = pi + 4; + ps[ 0] = tmp1; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + tmp1 = cs[2]; tmp2 = cs[3]; + cs[2] = tmp2; cs[3] = ci; + cs[0] = tmp1; cs[1] = ci + 1; + break; + case 2: + tmp1 = ps[15]; + tmp2 = ps[11]; + ps[12] = ps[3]; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = ps[7]; ps[ 9] = pi + 9; ps[10] = pi + 10; ps[11] = pi + 3; + ps[ 4] = tmp2; ps[ 5] = pi + 8; ps[ 6] = pi + 11; ps[ 7] = pi + 4; + ps[ 0] = tmp1; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + tmp1 = cs[3]; + cs[2] = cs[1]; cs[3] = ci; + cs[0] = tmp1; cs[1] = ci + 1; + break; + case 3: + ps[12] = ps[0]; ps[13] = pi + 0; ps[14] = pi + 1; ps[15] = pi + 2; + ps[ 8] = ps[1]; ps[ 9] = pi + 9; ps[10] = pi + 10; ps[11] = pi + 3; + ps[ 4] = ps[2]; ps[ 5] = pi + 8; ps[ 6] = pi + 11; ps[ 7] = pi + 4; + ps[ 0] = ps[3]; ps[ 1] = pi + 7; ps[ 2] = pi + 6; ps[ 3] = pi + 5; + cs[2] = cs[0]; cs[3] = ci; + cs[0] = cs[1]; cs[1] = ci + 1; + break; + } + mesh.figures.push({ + type: 'patch', + coords: new Int32Array(ps), // making copies of ps and cs + colors: new Int32Array(cs) + }); + } + } + + function updateBounds(mesh) { + var minX = mesh.coords[0][0], minY = mesh.coords[0][1], + maxX = minX, maxY = minY; + for (var i = 1, ii = mesh.coords.length; i < ii; i++) { + var x = mesh.coords[i][0], y = mesh.coords[i][1]; + minX = minX > x ? x : minX; + minY = minY > y ? y : minY; + maxX = maxX < x ? x : maxX; + maxY = maxY < y ? y : maxY; + } + mesh.bounds = [minX, minY, maxX, maxY]; + } + + function packData(mesh) { + var i, ii, j, jj; + + var coords = mesh.coords; + var coordsPacked = new Float32Array(coords.length * 2); + for (i = 0, j = 0, ii = coords.length; i < ii; i++) { + var xy = coords[i]; + coordsPacked[j++] = xy[0]; + coordsPacked[j++] = xy[1]; + } + mesh.coords = coordsPacked; + + var colors = mesh.colors; + var colorsPacked = new Uint8Array(colors.length * 3); + for (i = 0, j = 0, ii = colors.length; i < ii; i++) { + var c = colors[i]; + colorsPacked[j++] = c[0]; + colorsPacked[j++] = c[1]; + colorsPacked[j++] = c[2]; + } + mesh.colors = colorsPacked; + + var figures = mesh.figures; + for (i = 0, ii = figures.length; i < ii; i++) { + var figure = figures[i], ps = figure.coords, cs = figure.colors; + for (j = 0, jj = ps.length; j < jj; j++) { + ps[j] *= 2; + cs[j] *= 3; + } + } + } + + function Mesh(stream, matrix, xref, res) { + assert(isStream(stream), 'Mesh data is not a stream'); + var dict = stream.dict; + this.matrix = matrix; + this.shadingType = dict.get('ShadingType'); + this.type = 'Pattern'; + this.bbox = dict.get('BBox'); + var cs = dict.get('ColorSpace', 'CS'); + cs = ColorSpace.parse(cs, xref, res); + this.cs = cs; + this.background = dict.has('Background') ? + cs.getRgb(dict.get('Background'), 0) : null; + + var fnObj = dict.get('Function'); + var fn = fnObj ? PDFFunction.parseArray(xref, fnObj) : null; + + this.coords = []; + this.colors = []; + this.figures = []; + + var decodeContext = { + bitsPerCoordinate: dict.get('BitsPerCoordinate'), + bitsPerComponent: dict.get('BitsPerComponent'), + bitsPerFlag: dict.get('BitsPerFlag'), + decode: dict.get('Decode'), + colorFn: fn, + colorSpace: cs, + numComps: fn ? 1 : cs.numComps + }; + var reader = new MeshStreamReader(stream, decodeContext); + + var patchMesh = false; + switch (this.shadingType) { + case ShadingType.FREE_FORM_MESH: + decodeType4Shading(this, reader); + break; + case ShadingType.LATTICE_FORM_MESH: + var verticesPerRow = dict.get('VerticesPerRow') | 0; + assert(verticesPerRow >= 2, 'Invalid VerticesPerRow'); + decodeType5Shading(this, reader, verticesPerRow); + break; + case ShadingType.COONS_PATCH_MESH: + decodeType6Shading(this, reader); + patchMesh = true; + break; + case ShadingType.TENSOR_PATCH_MESH: + decodeType7Shading(this, reader); + patchMesh = true; + break; + default: + error('Unsupported mesh type.'); + break; + } + + if (patchMesh) { + // dirty bounds calculation for determining, how dense shall be triangles + updateBounds(this); + for (var i = 0, ii = this.figures.length; i < ii; i++) { + buildFigureFromPatch(this, i); + } + } + // calculate bounds + updateBounds(this); + + packData(this); + } + + Mesh.prototype = { + getIR: function Mesh_getIR() { + return ['Mesh', this.shadingType, this.coords, this.colors, this.figures, + this.bounds, this.matrix, this.bbox, this.background]; + } + }; + + return Mesh; +})(); + +Shadings.Dummy = (function DummyClosure() { + function Dummy() { + this.type = 'Pattern'; + } + + Dummy.prototype = { + getIR: function Dummy_getIR() { + return ['Dummy']; + } + }; + return Dummy; +})(); + +function getTilingPatternIR(operatorList, dict, args) { + var matrix = dict.get('Matrix'); + var bbox = dict.get('BBox'); + var xstep = dict.get('XStep'); + var ystep = dict.get('YStep'); + var paintType = dict.get('PaintType'); + var tilingType = dict.get('TilingType'); + + return [ + 'TilingPattern', args, operatorList, matrix, bbox, xstep, ystep, + paintType, tilingType + ]; +} + +exports.Pattern = Pattern; +exports.getTilingPatternIR = getTilingPatternIR; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreEvaluator = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreParser, + root.pdfjsCoreImage, root.pdfjsCoreColorSpace, root.pdfjsCoreMurmurHash3, + root.pdfjsCoreFonts, root.pdfjsCoreFunction, root.pdfjsCorePattern, + root.pdfjsCoreCMap, root.pdfjsCoreMetrics, root.pdfjsCoreBidi); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream, coreParser, + coreImage, coreColorSpace, coreMurmurHash3, coreFonts, + coreFunction, corePattern, coreCMap, coreMetrics, coreBidi) { + +var FONT_IDENTITY_MATRIX = sharedUtil.FONT_IDENTITY_MATRIX; +var IDENTITY_MATRIX = sharedUtil.IDENTITY_MATRIX; +var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES; +var ImageKind = sharedUtil.ImageKind; +var OPS = sharedUtil.OPS; +var TextRenderingMode = sharedUtil.TextRenderingMode; +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isNum = sharedUtil.isNum; +var isString = sharedUtil.isString; +var warn = sharedUtil.warn; +var Dict = corePrimitives.Dict; +var Name = corePrimitives.Name; +var isCmd = corePrimitives.isCmd; +var isDict = corePrimitives.isDict; +var isName = corePrimitives.isName; +var isRef = corePrimitives.isRef; +var isStream = corePrimitives.isStream; +var DecodeStream = coreStream.DecodeStream; +var JpegStream = coreStream.JpegStream; +var Lexer = coreParser.Lexer; +var Parser = coreParser.Parser; +var isEOF = coreParser.isEOF; +var PDFImage = coreImage.PDFImage; +var ColorSpace = coreColorSpace.ColorSpace; +var MurmurHash3_64 = coreMurmurHash3.MurmurHash3_64; +var Encodings = coreFonts.Encodings; +var ErrorFont = coreFonts.ErrorFont; +var FontFlags = coreFonts.FontFlags; +var Font = coreFonts.Font; +var IdentityToUnicodeMap = coreFonts.IdentityToUnicodeMap; +var NormalizedUnicodes = coreFonts.NormalizedUnicodes; +var ToUnicodeMap = coreFonts.ToUnicodeMap; +var getFontType = coreFonts.getFontType; +var reverseIfRtl = coreFonts.reverseIfRtl; +var serifFonts = coreFonts.serifFonts; +var symbolsFonts = coreFonts.symbolsFonts; +var stdFontMap = coreFonts.stdFontMap; +var isPDFFunction = coreFunction.isPDFFunction; +var PDFFunction = coreFunction.PDFFunction; +var Pattern = corePattern.Pattern; +var getTilingPatternIR = corePattern.getTilingPatternIR; +var CMapFactory = coreCMap.CMapFactory; +var IdentityCMap = coreCMap.IdentityCMap; +var Metrics = coreMetrics.Metrics; +var bidi = coreBidi.bidi; + +var PartialEvaluator = (function PartialEvaluatorClosure() { + function PartialEvaluator(pdfManager, xref, handler, pageIndex, + uniquePrefix, idCounters, fontCache) { + this.pdfManager = pdfManager; + this.xref = xref; + this.handler = handler; + this.pageIndex = pageIndex; + this.uniquePrefix = uniquePrefix; + this.idCounters = idCounters; + this.fontCache = fontCache; + } + + // Trying to minimize Date.now() usage and check every 100 time + var TIME_SLOT_DURATION_MS = 20; + var CHECK_TIME_EVERY = 100; + function TimeSlotManager() { + this.reset(); + } + TimeSlotManager.prototype = { + check: function TimeSlotManager_check() { + if (++this.checked < CHECK_TIME_EVERY) { + return false; + } + this.checked = 0; + return this.endTime <= Date.now(); + }, + reset: function TimeSlotManager_reset() { + this.endTime = Date.now() + TIME_SLOT_DURATION_MS; + this.checked = 0; + } + }; + + var deferred = Promise.resolve(); + + var TILING_PATTERN = 1, SHADING_PATTERN = 2; + + PartialEvaluator.prototype = { + hasBlendModes: function PartialEvaluator_hasBlendModes(resources) { + if (!isDict(resources)) { + return false; + } + + var processed = Object.create(null); + if (resources.objId) { + processed[resources.objId] = true; + } + + var nodes = [resources]; + while (nodes.length) { + var key; + var node = nodes.shift(); + // First check the current resources for blend modes. + var graphicStates = node.get('ExtGState'); + if (isDict(graphicStates)) { + graphicStates = graphicStates.getAll(); + for (key in graphicStates) { + var graphicState = graphicStates[key]; + var bm = graphicState['BM']; + if (isName(bm) && bm.name !== 'Normal') { + return true; + } + } + } + // Descend into the XObjects to look for more resources and blend modes. + var xObjects = node.get('XObject'); + if (!isDict(xObjects)) { + continue; + } + xObjects = xObjects.getAll(); + for (key in xObjects) { + var xObject = xObjects[key]; + if (!isStream(xObject)) { + continue; + } + if (xObject.dict.objId) { + if (processed[xObject.dict.objId]) { + // stream has objId and is processed already + continue; + } + processed[xObject.dict.objId] = true; + } + var xResources = xObject.dict.get('Resources'); + // Checking objId to detect an infinite loop. + if (isDict(xResources) && + (!xResources.objId || !processed[xResources.objId])) { + nodes.push(xResources); + if (xResources.objId) { + processed[xResources.objId] = true; + } + } + } + } + return false; + }, + + buildFormXObject: function PartialEvaluator_buildFormXObject(resources, + xobj, smask, + operatorList, + task, + initialState) { + var matrix = xobj.dict.getArray('Matrix'); + var bbox = xobj.dict.getArray('BBox'); + var group = xobj.dict.get('Group'); + if (group) { + var groupOptions = { + matrix: matrix, + bbox: bbox, + smask: smask, + isolated: false, + knockout: false + }; + + var groupSubtype = group.get('S'); + var colorSpace; + if (isName(groupSubtype) && groupSubtype.name === 'Transparency') { + groupOptions.isolated = (group.get('I') || false); + groupOptions.knockout = (group.get('K') || false); + colorSpace = (group.has('CS') ? + ColorSpace.parse(group.get('CS'), this.xref, resources) : null); + } + + if (smask && smask.backdrop) { + colorSpace = colorSpace || ColorSpace.singletons.rgb; + smask.backdrop = colorSpace.getRgb(smask.backdrop, 0); + } + + operatorList.addOp(OPS.beginGroup, [groupOptions]); + } + + operatorList.addOp(OPS.paintFormXObjectBegin, [matrix, bbox]); + + return this.getOperatorList(xobj, task, + (xobj.dict.get('Resources') || resources), operatorList, initialState). + then(function () { + operatorList.addOp(OPS.paintFormXObjectEnd, []); + + if (group) { + operatorList.addOp(OPS.endGroup, [groupOptions]); + } + }); + }, + + buildPaintImageXObject: + function PartialEvaluator_buildPaintImageXObject(resources, image, + inline, operatorList, + cacheKey, imageCache) { + var self = this; + var dict = image.dict; + var w = dict.get('Width', 'W'); + var h = dict.get('Height', 'H'); + + if (!(w && isNum(w)) || !(h && isNum(h))) { + warn('Image dimensions are missing, or not numbers.'); + return; + } + if (PDFJS.maxImageSize !== -1 && w * h > PDFJS.maxImageSize) { + warn('Image exceeded maximum allowed size and was removed.'); + return; + } + + var imageMask = (dict.get('ImageMask', 'IM') || false); + var imgData, args; + if (imageMask) { + // This depends on a tmpCanvas being filled with the + // current fillStyle, such that processing the pixel + // data can't be done here. Instead of creating a + // complete PDFImage, only read the information needed + // for later. + + var width = dict.get('Width', 'W'); + var height = dict.get('Height', 'H'); + var bitStrideLength = (width + 7) >> 3; + var imgArray = image.getBytes(bitStrideLength * height); + var decode = dict.get('Decode', 'D'); + var inverseDecode = (!!decode && decode[0] > 0); + + imgData = PDFImage.createMask(imgArray, width, height, + image instanceof DecodeStream, + inverseDecode); + imgData.cached = true; + args = [imgData]; + operatorList.addOp(OPS.paintImageMaskXObject, args); + if (cacheKey) { + imageCache[cacheKey] = { + fn: OPS.paintImageMaskXObject, + args: args + }; + } + return; + } + + var softMask = (dict.get('SMask', 'SM') || false); + var mask = (dict.get('Mask') || false); + + var SMALL_IMAGE_DIMENSIONS = 200; + // Inlining small images into the queue as RGB data + if (inline && !softMask && !mask && !(image instanceof JpegStream) && + (w + h) < SMALL_IMAGE_DIMENSIONS) { + var imageObj = new PDFImage(this.xref, resources, image, + inline, null, null); + // We force the use of RGBA_32BPP images here, because we can't handle + // any other kind. + imgData = imageObj.createImageData(/* forceRGBA = */ true); + operatorList.addOp(OPS.paintInlineImageXObject, [imgData]); + return; + } + + // If there is no imageMask, create the PDFImage and a lot + // of image processing can be done here. + var uniquePrefix = (this.uniquePrefix || ''); + var objId = 'img_' + uniquePrefix + (++this.idCounters.obj); + operatorList.addDependency(objId); + args = [objId, w, h]; + + if (!softMask && !mask && image instanceof JpegStream && + image.isNativelySupported(this.xref, resources)) { + // These JPEGs don't need any more processing so we can just send it. + operatorList.addOp(OPS.paintJpegXObject, args); + this.handler.send('obj', + [objId, this.pageIndex, 'JpegStream', image.getIR()]); + return; + } + + PDFImage.buildImage(self.handler, self.xref, resources, image, inline). + then(function(imageObj) { + var imgData = imageObj.createImageData(/* forceRGBA = */ false); + self.handler.send('obj', [objId, self.pageIndex, 'Image', imgData], + [imgData.data.buffer]); + }).then(undefined, function (reason) { + warn('Unable to decode image: ' + reason); + self.handler.send('obj', [objId, self.pageIndex, 'Image', null]); + }); + + operatorList.addOp(OPS.paintImageXObject, args); + if (cacheKey) { + imageCache[cacheKey] = { + fn: OPS.paintImageXObject, + args: args + }; + } + }, + + handleSMask: function PartialEvaluator_handleSmask(smask, resources, + operatorList, task, + stateManager) { + var smaskContent = smask.get('G'); + var smaskOptions = { + subtype: smask.get('S').name, + backdrop: smask.get('BC') + }; + + // The SMask might have a alpha/luminosity value transfer function -- + // we will build a map of integer values in range 0..255 to be fast. + var transferObj = smask.get('TR'); + if (isPDFFunction(transferObj)) { + var transferFn = PDFFunction.parse(this.xref, transferObj); + var transferMap = new Uint8Array(256); + var tmp = new Float32Array(1); + for (var i = 0; i < 255; i++) { + tmp[0] = i / 255; + transferFn(tmp, 0, tmp, 0); + transferMap[i] = (tmp[0] * 255) | 0; + } + smaskOptions.transferMap = transferMap; + } + + return this.buildFormXObject(resources, smaskContent, smaskOptions, + operatorList, task, stateManager.state.clone()); + }, + + handleTilingType: + function PartialEvaluator_handleTilingType(fn, args, resources, + pattern, patternDict, + operatorList, task) { + // Create an IR of the pattern code. + var tilingOpList = new OperatorList(); + // Merge the available resources, to prevent issues when the patternDict + // is missing some /Resources entries (fixes issue6541.pdf). + var resourcesArray = [patternDict.get('Resources'), resources]; + var patternResources = Dict.merge(this.xref, resourcesArray); + + return this.getOperatorList(pattern, task, patternResources, + tilingOpList).then(function () { + // Add the dependencies to the parent operator list so they are + // resolved before sub operator list is executed synchronously. + operatorList.addDependencies(tilingOpList.dependencies); + operatorList.addOp(fn, getTilingPatternIR({ + fnArray: tilingOpList.fnArray, + argsArray: tilingOpList.argsArray + }, patternDict, args)); + }); + }, + + handleSetFont: + function PartialEvaluator_handleSetFont(resources, fontArgs, fontRef, + operatorList, task, state) { + // TODO(mack): Not needed? + var fontName; + if (fontArgs) { + fontArgs = fontArgs.slice(); + fontName = fontArgs[0].name; + } + + var self = this; + return this.loadFont(fontName, fontRef, this.xref, resources).then( + function (translated) { + if (!translated.font.isType3Font) { + return translated; + } + return translated.loadType3Data(self, resources, operatorList, task). + then(function () { + return translated; + }, function (reason) { + // Error in the font data -- sending unsupported feature notification. + self.handler.send('UnsupportedFeature', + {featureId: UNSUPPORTED_FEATURES.font}); + return new TranslatedFont('g_font_error', + new ErrorFont('Type3 font load error: ' + reason), translated.font); + }); + }).then(function (translated) { + state.font = translated.font; + translated.send(self.handler); + return translated.loadedName; + }); + }, + + handleText: function PartialEvaluator_handleText(chars, state) { + var font = state.font; + var glyphs = font.charsToGlyphs(chars); + var isAddToPathSet = !!(state.textRenderingMode & + TextRenderingMode.ADD_TO_PATH_FLAG); + if (font.data && (isAddToPathSet || PDFJS.disableFontFace)) { + var buildPath = function (fontChar) { + if (!font.renderer.hasBuiltPath(fontChar)) { + var path = font.renderer.getPathJs(fontChar); + this.handler.send('commonobj', [ + font.loadedName + '_path_' + fontChar, + 'FontPath', + path + ]); + } + }.bind(this); + + for (var i = 0, ii = glyphs.length; i < ii; i++) { + var glyph = glyphs[i]; + buildPath(glyph.fontChar); + + // If the glyph has an accent we need to build a path for its + // fontChar too, otherwise CanvasGraphics_paintChar will fail. + var accent = glyph.accent; + if (accent && accent.fontChar) { + buildPath(accent.fontChar); + } + } + } + + return glyphs; + }, + + setGState: function PartialEvaluator_setGState(resources, gState, + operatorList, task, + xref, stateManager) { + // This array holds the converted/processed state data. + var gStateObj = []; + var gStateMap = gState.map; + var self = this; + var promise = Promise.resolve(); + for (var key in gStateMap) { + var value = gStateMap[key]; + switch (key) { + case 'Type': + break; + case 'LW': + case 'LC': + case 'LJ': + case 'ML': + case 'D': + case 'RI': + case 'FL': + case 'CA': + case 'ca': + gStateObj.push([key, value]); + break; + case 'Font': + promise = promise.then(function () { + return self.handleSetFont(resources, null, value[0], operatorList, + task, stateManager.state). + then(function (loadedName) { + operatorList.addDependency(loadedName); + gStateObj.push([key, [loadedName, value[1]]]); + }); + }); + break; + case 'BM': + gStateObj.push([key, value]); + break; + case 'SMask': + if (isName(value) && value.name === 'None') { + gStateObj.push([key, false]); + break; + } + var dict = xref.fetchIfRef(value); + if (isDict(dict)) { + promise = promise.then(function () { + return self.handleSMask(dict, resources, operatorList, + task, stateManager); + }); + gStateObj.push([key, true]); + } else { + warn('Unsupported SMask type'); + } + + break; + // Only generate info log messages for the following since + // they are unlikely to have a big impact on the rendering. + case 'OP': + case 'op': + case 'OPM': + case 'BG': + case 'BG2': + case 'UCR': + case 'UCR2': + case 'TR': + case 'TR2': + case 'HT': + case 'SM': + case 'SA': + case 'AIS': + case 'TK': + // TODO implement these operators. + info('graphic state operator ' + key); + break; + default: + info('Unknown graphic state operator ' + key); + break; + } + } + return promise.then(function () { + if (gStateObj.length >= 0) { + operatorList.addOp(OPS.setGState, [gStateObj]); + } + }); + }, + + loadFont: function PartialEvaluator_loadFont(fontName, font, xref, + resources) { + + function errorFont() { + return Promise.resolve(new TranslatedFont('g_font_error', + new ErrorFont('Font ' + fontName + ' is not available'), font)); + } + var fontRef; + if (font) { // Loading by ref. + assert(isRef(font)); + fontRef = font; + } else { // Loading by name. + var fontRes = resources.get('Font'); + if (fontRes) { + fontRef = fontRes.getRaw(fontName); + } else { + warn('fontRes not available'); + return errorFont(); + } + } + if (!fontRef) { + warn('fontRef not available'); + return errorFont(); + } + + if (this.fontCache.has(fontRef)) { + return this.fontCache.get(fontRef); + } + + font = xref.fetchIfRef(fontRef); + if (!isDict(font)) { + return errorFont(); + } + + // We are holding font.translated references just for fontRef that are not + // dictionaries (Dict). See explanation below. + if (font.translated) { + return font.translated; + } + + var fontCapability = createPromiseCapability(); + + var preEvaluatedFont = this.preEvaluateFont(font, xref); + var descriptor = preEvaluatedFont.descriptor; + var fontID = fontRef.num + '_' + fontRef.gen; + if (isDict(descriptor)) { + if (!descriptor.fontAliases) { + descriptor.fontAliases = Object.create(null); + } + + var fontAliases = descriptor.fontAliases; + var hash = preEvaluatedFont.hash; + if (fontAliases[hash]) { + var aliasFontRef = fontAliases[hash].aliasRef; + if (aliasFontRef && this.fontCache.has(aliasFontRef)) { + this.fontCache.putAlias(fontRef, aliasFontRef); + return this.fontCache.get(fontRef); + } + } + + if (!fontAliases[hash]) { + fontAliases[hash] = { + fontID: Font.getFontID() + }; + } + + fontAliases[hash].aliasRef = fontRef; + fontID = fontAliases[hash].fontID; + } + + // Workaround for bad PDF generators that don't reference fonts + // properly, i.e. by not using an object identifier. + // Check if the fontRef is a Dict (as opposed to a standard object), + // in which case we don't cache the font and instead reference it by + // fontName in font.loadedName below. + var fontRefIsDict = isDict(fontRef); + if (!fontRefIsDict) { + this.fontCache.put(fontRef, fontCapability.promise); + } + + // Keep track of each font we translated so the caller can + // load them asynchronously before calling display on a page. + font.loadedName = 'g_' + this.pdfManager.docId + '_f' + (fontRefIsDict ? + fontName.replace(/\W/g, '') : fontID); + + font.translated = fontCapability.promise; + + // TODO move promises into translate font + var translatedPromise; + try { + translatedPromise = Promise.resolve( + this.translateFont(preEvaluatedFont, xref)); + } catch (e) { + translatedPromise = Promise.reject(e); + } + + var self = this; + translatedPromise.then(function (translatedFont) { + if (translatedFont.fontType !== undefined) { + var xrefFontStats = xref.stats.fontTypes; + xrefFontStats[translatedFont.fontType] = true; + } + + fontCapability.resolve(new TranslatedFont(font.loadedName, + translatedFont, font)); + }, function (reason) { + // TODO fontCapability.reject? + // Error in the font data -- sending unsupported feature notification. + self.handler.send('UnsupportedFeature', + {featureId: UNSUPPORTED_FEATURES.font}); + + try { + // error, but it's still nice to have font type reported + var descriptor = preEvaluatedFont.descriptor; + var fontFile3 = descriptor && descriptor.get('FontFile3'); + var subtype = fontFile3 && fontFile3.get('Subtype'); + var fontType = getFontType(preEvaluatedFont.type, + subtype && subtype.name); + var xrefFontStats = xref.stats.fontTypes; + xrefFontStats[fontType] = true; + } catch (ex) { } + + fontCapability.resolve(new TranslatedFont(font.loadedName, + new ErrorFont(reason instanceof Error ? reason.message : reason), + font)); + }); + return fontCapability.promise; + }, + + buildPath: function PartialEvaluator_buildPath(operatorList, fn, args) { + var lastIndex = operatorList.length - 1; + if (!args) { + args = []; + } + if (lastIndex < 0 || + operatorList.fnArray[lastIndex] !== OPS.constructPath) { + operatorList.addOp(OPS.constructPath, [[fn], args]); + } else { + var opArgs = operatorList.argsArray[lastIndex]; + opArgs[0].push(fn); + Array.prototype.push.apply(opArgs[1], args); + } + }, + + handleColorN: function PartialEvaluator_handleColorN(operatorList, fn, args, + cs, patterns, resources, task, xref) { + // compile tiling patterns + var patternName = args[args.length - 1]; + // SCN/scn applies patterns along with normal colors + var pattern; + if (isName(patternName) && + (pattern = patterns.get(patternName.name))) { + var dict = (isStream(pattern) ? pattern.dict : pattern); + var typeNum = dict.get('PatternType'); + + if (typeNum === TILING_PATTERN) { + var color = cs.base ? cs.base.getRgb(args, 0) : null; + return this.handleTilingType(fn, color, resources, pattern, + dict, operatorList, task); + } else if (typeNum === SHADING_PATTERN) { + var shading = dict.get('Shading'); + var matrix = dict.get('Matrix'); + pattern = Pattern.parseShading(shading, matrix, xref, resources, + this.handler); + operatorList.addOp(fn, pattern.getIR()); + return Promise.resolve(); + } else { + return Promise.reject('Unknown PatternType: ' + typeNum); + } + } + // TODO shall we fail here? + operatorList.addOp(fn, args); + return Promise.resolve(); + }, + + getOperatorList: function PartialEvaluator_getOperatorList(stream, + task, + resources, + operatorList, + initialState) { + + var self = this; + var xref = this.xref; + var imageCache = {}; + + assert(operatorList); + + resources = (resources || Dict.empty); + var xobjs = (resources.get('XObject') || Dict.empty); + var patterns = (resources.get('Pattern') || Dict.empty); + var stateManager = new StateManager(initialState || new EvalState()); + var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager); + var timeSlotManager = new TimeSlotManager(); + + return new Promise(function next(resolve, reject) { + task.ensureNotTerminated(); + timeSlotManager.reset(); + var stop, operation = {}, i, ii, cs; + while (!(stop = timeSlotManager.check())) { + // The arguments parsed by read() are used beyond this loop, so we + // cannot reuse the same array on each iteration. Therefore we pass + // in |null| as the initial value (see the comment on + // EvaluatorPreprocessor_read() for why). + operation.args = null; + if (!(preprocessor.read(operation))) { + break; + } + var args = operation.args; + var fn = operation.fn; + + switch (fn | 0) { + case OPS.paintXObject: + if (args[0].code) { + break; + } + // eagerly compile XForm objects + var name = args[0].name; + if (!name) { + warn('XObject must be referred to by name.'); + continue; + } + if (imageCache[name] !== undefined) { + operatorList.addOp(imageCache[name].fn, imageCache[name].args); + args = null; + continue; + } + + var xobj = xobjs.get(name); + if (xobj) { + assert(isStream(xobj), 'XObject should be a stream'); + + var type = xobj.dict.get('Subtype'); + assert(isName(type), + 'XObject should have a Name subtype'); + + if (type.name === 'Form') { + stateManager.save(); + return self.buildFormXObject(resources, xobj, null, + operatorList, task, + stateManager.state.clone()). + then(function () { + stateManager.restore(); + next(resolve, reject); + }, reject); + } else if (type.name === 'Image') { + self.buildPaintImageXObject(resources, xobj, false, + operatorList, name, imageCache); + args = null; + continue; + } else if (type.name === 'PS') { + // PostScript XObjects are unused when viewing documents. + // See section 4.7.1 of Adobe's PDF reference. + info('Ignored XObject subtype PS'); + continue; + } else { + error('Unhandled XObject subtype ' + type.name); + } + } + break; + case OPS.setFont: + var fontSize = args[1]; + // eagerly collect all fonts + return self.handleSetFont(resources, args, null, operatorList, + task, stateManager.state). + then(function (loadedName) { + operatorList.addDependency(loadedName); + operatorList.addOp(OPS.setFont, [loadedName, fontSize]); + next(resolve, reject); + }, reject); + case OPS.endInlineImage: + var cacheKey = args[0].cacheKey; + if (cacheKey) { + var cacheEntry = imageCache[cacheKey]; + if (cacheEntry !== undefined) { + operatorList.addOp(cacheEntry.fn, cacheEntry.args); + args = null; + continue; + } + } + self.buildPaintImageXObject(resources, args[0], true, + operatorList, cacheKey, imageCache); + args = null; + continue; + case OPS.showText: + args[0] = self.handleText(args[0], stateManager.state); + break; + case OPS.showSpacedText: + var arr = args[0]; + var combinedGlyphs = []; + var arrLength = arr.length; + var state = stateManager.state; + for (i = 0; i < arrLength; ++i) { + var arrItem = arr[i]; + if (isString(arrItem)) { + Array.prototype.push.apply(combinedGlyphs, + self.handleText(arrItem, state)); + } else if (isNum(arrItem)) { + combinedGlyphs.push(arrItem); + } + } + args[0] = combinedGlyphs; + fn = OPS.showText; + break; + case OPS.nextLineShowText: + operatorList.addOp(OPS.nextLine); + args[0] = self.handleText(args[0], stateManager.state); + fn = OPS.showText; + break; + case OPS.nextLineSetSpacingShowText: + operatorList.addOp(OPS.nextLine); + operatorList.addOp(OPS.setWordSpacing, [args.shift()]); + operatorList.addOp(OPS.setCharSpacing, [args.shift()]); + args[0] = self.handleText(args[0], stateManager.state); + fn = OPS.showText; + break; + case OPS.setTextRenderingMode: + stateManager.state.textRenderingMode = args[0]; + break; + + case OPS.setFillColorSpace: + stateManager.state.fillColorSpace = + ColorSpace.parse(args[0], xref, resources); + continue; + case OPS.setStrokeColorSpace: + stateManager.state.strokeColorSpace = + ColorSpace.parse(args[0], xref, resources); + continue; + case OPS.setFillColor: + cs = stateManager.state.fillColorSpace; + args = cs.getRgb(args, 0); + fn = OPS.setFillRGBColor; + break; + case OPS.setStrokeColor: + cs = stateManager.state.strokeColorSpace; + args = cs.getRgb(args, 0); + fn = OPS.setStrokeRGBColor; + break; + case OPS.setFillGray: + stateManager.state.fillColorSpace = ColorSpace.singletons.gray; + args = ColorSpace.singletons.gray.getRgb(args, 0); + fn = OPS.setFillRGBColor; + break; + case OPS.setStrokeGray: + stateManager.state.strokeColorSpace = ColorSpace.singletons.gray; + args = ColorSpace.singletons.gray.getRgb(args, 0); + fn = OPS.setStrokeRGBColor; + break; + case OPS.setFillCMYKColor: + stateManager.state.fillColorSpace = ColorSpace.singletons.cmyk; + args = ColorSpace.singletons.cmyk.getRgb(args, 0); + fn = OPS.setFillRGBColor; + break; + case OPS.setStrokeCMYKColor: + stateManager.state.strokeColorSpace = ColorSpace.singletons.cmyk; + args = ColorSpace.singletons.cmyk.getRgb(args, 0); + fn = OPS.setStrokeRGBColor; + break; + case OPS.setFillRGBColor: + stateManager.state.fillColorSpace = ColorSpace.singletons.rgb; + args = ColorSpace.singletons.rgb.getRgb(args, 0); + break; + case OPS.setStrokeRGBColor: + stateManager.state.strokeColorSpace = ColorSpace.singletons.rgb; + args = ColorSpace.singletons.rgb.getRgb(args, 0); + break; + case OPS.setFillColorN: + cs = stateManager.state.fillColorSpace; + if (cs.name === 'Pattern') { + return self.handleColorN(operatorList, OPS.setFillColorN, + args, cs, patterns, resources, task, xref).then(function() { + next(resolve, reject); + }, reject); + } + args = cs.getRgb(args, 0); + fn = OPS.setFillRGBColor; + break; + case OPS.setStrokeColorN: + cs = stateManager.state.strokeColorSpace; + if (cs.name === 'Pattern') { + return self.handleColorN(operatorList, OPS.setStrokeColorN, + args, cs, patterns, resources, task, xref).then(function() { + next(resolve, reject); + }, reject); + } + args = cs.getRgb(args, 0); + fn = OPS.setStrokeRGBColor; + break; + + case OPS.shadingFill: + var shadingRes = resources.get('Shading'); + if (!shadingRes) { + error('No shading resource found'); + } + + var shading = shadingRes.get(args[0].name); + if (!shading) { + error('No shading object found'); + } + + var shadingFill = Pattern.parseShading(shading, null, xref, + resources, self.handler); + var patternIR = shadingFill.getIR(); + args = [patternIR]; + fn = OPS.shadingFill; + break; + case OPS.setGState: + var dictName = args[0]; + var extGState = resources.get('ExtGState'); + + if (!isDict(extGState) || !extGState.has(dictName.name)) { + break; + } + + var gState = extGState.get(dictName.name); + return self.setGState(resources, gState, operatorList, task, + xref, stateManager).then(function() { + next(resolve, reject); + }, reject); + case OPS.moveTo: + case OPS.lineTo: + case OPS.curveTo: + case OPS.curveTo2: + case OPS.curveTo3: + case OPS.closePath: + self.buildPath(operatorList, fn, args); + continue; + case OPS.rectangle: + self.buildPath(operatorList, fn, args); + continue; + case OPS.markPoint: + case OPS.markPointProps: + case OPS.beginMarkedContent: + case OPS.beginMarkedContentProps: + case OPS.endMarkedContent: + case OPS.beginCompat: + case OPS.endCompat: + // Ignore operators where the corresponding handlers are known to + // be no-op in CanvasGraphics (display/canvas.js). This prevents + // serialization errors and is also a bit more efficient. + // We could also try to serialize all objects in a general way, + // e.g. as done in https://github.com/mozilla/pdf.js/pull/6266, + // but doing so is meaningless without knowing the semantics. + continue; + default: + // Note: Let's hope that the ignored operator does not have any + // non-serializable arguments, otherwise postMessage will throw + // "An object could not be cloned.". + } + operatorList.addOp(fn, args); + } + if (stop) { + deferred.then(function () { + next(resolve, reject); + }, reject); + return; + } + // Some PDFs don't close all restores inside object/form. + // Closing those for them. + for (i = 0, ii = preprocessor.savedStatesDepth; i < ii; i++) { + operatorList.addOp(OPS.restore, []); + } + resolve(); + }); + }, + + getTextContent: + function PartialEvaluator_getTextContent(stream, task, resources, + stateManager, + normalizeWhitespace) { + + stateManager = (stateManager || new StateManager(new TextState())); + + var WhitespaceRegexp = /\s/g; + + var textContent = { + items: [], + styles: Object.create(null) + }; + var textContentItem = { + initialized: false, + str: [], + width: 0, + height: 0, + vertical: false, + lastAdvanceWidth: 0, + lastAdvanceHeight: 0, + textAdvanceScale: 0, + spaceWidth: 0, + fakeSpaceMin: Infinity, + fakeMultiSpaceMin: Infinity, + fakeMultiSpaceMax: -0, + textRunBreakAllowed: false, + transform: null, + fontName: null + }; + var SPACE_FACTOR = 0.3; + var MULTI_SPACE_FACTOR = 1.5; + var MULTI_SPACE_FACTOR_MAX = 4; + + var self = this; + var xref = this.xref; + + resources = (xref.fetchIfRef(resources) || Dict.empty); + + // The xobj is parsed iff it's needed, e.g. if there is a `DO` cmd. + var xobjs = null; + var xobjsCache = {}; + + var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager); + + var textState; + + function ensureTextContentItem() { + if (textContentItem.initialized) { + return textContentItem; + } + var font = textState.font; + if (!(font.loadedName in textContent.styles)) { + textContent.styles[font.loadedName] = { + fontFamily: font.fallbackName, + ascent: font.ascent, + descent: font.descent, + vertical: font.vertical + }; + } + textContentItem.fontName = font.loadedName; + + // 9.4.4 Text Space Details + var tsm = [textState.fontSize * textState.textHScale, 0, + 0, textState.fontSize, + 0, textState.textRise]; + + if (font.isType3Font && + textState.fontMatrix !== FONT_IDENTITY_MATRIX && + textState.fontSize === 1) { + var glyphHeight = font.bbox[3] - font.bbox[1]; + if (glyphHeight > 0) { + glyphHeight = glyphHeight * textState.fontMatrix[3]; + tsm[3] *= glyphHeight; + } + } + + var trm = Util.transform(textState.ctm, + Util.transform(textState.textMatrix, tsm)); + textContentItem.transform = trm; + if (!font.vertical) { + textContentItem.width = 0; + textContentItem.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]); + textContentItem.vertical = false; + } else { + textContentItem.width = Math.sqrt(trm[0] * trm[0] + trm[1] * trm[1]); + textContentItem.height = 0; + textContentItem.vertical = true; + } + + var a = textState.textLineMatrix[0]; + var b = textState.textLineMatrix[1]; + var scaleLineX = Math.sqrt(a * a + b * b); + a = textState.ctm[0]; + b = textState.ctm[1]; + var scaleCtmX = Math.sqrt(a * a + b * b); + textContentItem.textAdvanceScale = scaleCtmX * scaleLineX; + textContentItem.lastAdvanceWidth = 0; + textContentItem.lastAdvanceHeight = 0; + + var spaceWidth = font.spaceWidth / 1000 * textState.fontSize; + if (spaceWidth) { + textContentItem.spaceWidth = spaceWidth; + textContentItem.fakeSpaceMin = spaceWidth * SPACE_FACTOR; + textContentItem.fakeMultiSpaceMin = spaceWidth * MULTI_SPACE_FACTOR; + textContentItem.fakeMultiSpaceMax = + spaceWidth * MULTI_SPACE_FACTOR_MAX; + // It's okay for monospace fonts to fake as much space as needed. + textContentItem.textRunBreakAllowed = !font.isMonospace; + } else { + textContentItem.spaceWidth = 0; + textContentItem.fakeSpaceMin = Infinity; + textContentItem.fakeMultiSpaceMin = Infinity; + textContentItem.fakeMultiSpaceMax = 0; + textContentItem.textRunBreakAllowed = false; + } + + + textContentItem.initialized = true; + return textContentItem; + } + + function replaceWhitespace(str) { + // Replaces all whitespaces with standard spaces (0x20), to avoid + // alignment issues between the textLayer and the canvas if the text + // contains e.g. tabs (fixes issue6612.pdf). + var i = 0, ii = str.length, code; + while (i < ii && (code = str.charCodeAt(i)) >= 0x20 && code <= 0x7F) { + i++; + } + return (i < ii ? str.replace(WhitespaceRegexp, ' ') : str); + } + + function runBidiTransform(textChunk) { + var str = textChunk.str.join(''); + var bidiResult = PDFJS.bidi(str, -1, textChunk.vertical); + return { + str: (normalizeWhitespace ? replaceWhitespace(bidiResult.str) : + bidiResult.str), + dir: bidiResult.dir, + width: textChunk.width, + height: textChunk.height, + transform: textChunk.transform, + fontName: textChunk.fontName + }; + } + + function handleSetFont(fontName, fontRef) { + return self.loadFont(fontName, fontRef, xref, resources). + then(function (translated) { + textState.font = translated.font; + textState.fontMatrix = translated.font.fontMatrix || + FONT_IDENTITY_MATRIX; + }); + } + + function buildTextContentItem(chars) { + var font = textState.font; + var textChunk = ensureTextContentItem(); + var width = 0; + var height = 0; + var glyphs = font.charsToGlyphs(chars); + var defaultVMetrics = font.defaultVMetrics; + for (var i = 0; i < glyphs.length; i++) { + var glyph = glyphs[i]; + var vMetricX = null; + var vMetricY = null; + var glyphWidth = null; + if (font.vertical) { + if (glyph.vmetric) { + glyphWidth = glyph.vmetric[0]; + vMetricX = glyph.vmetric[1]; + vMetricY = glyph.vmetric[2]; + } else { + glyphWidth = glyph.width; + vMetricX = glyph.width * 0.5; + vMetricY = defaultVMetrics[2]; + } + } else { + glyphWidth = glyph.width; + } + + var glyphUnicode = glyph.unicode; + if (NormalizedUnicodes[glyphUnicode] !== undefined) { + glyphUnicode = NormalizedUnicodes[glyphUnicode]; + } + glyphUnicode = reverseIfRtl(glyphUnicode); + + // The following will calculate the x and y of the individual glyphs. + // if (font.vertical) { + // tsm[4] -= vMetricX * Math.abs(textState.fontSize) * + // textState.fontMatrix[0]; + // tsm[5] -= vMetricY * textState.fontSize * + // textState.fontMatrix[0]; + // } + // var trm = Util.transform(textState.textMatrix, tsm); + // var pt = Util.applyTransform([trm[4], trm[5]], textState.ctm); + // var x = pt[0]; + // var y = pt[1]; + + var charSpacing = textState.charSpacing; + if (glyph.isSpace) { + var wordSpacing = textState.wordSpacing; + charSpacing += wordSpacing; + if (wordSpacing > 0) { + addFakeSpaces(wordSpacing, textChunk.str); + } + } + + var tx = 0; + var ty = 0; + if (!font.vertical) { + var w0 = glyphWidth * textState.fontMatrix[0]; + tx = (w0 * textState.fontSize + charSpacing) * + textState.textHScale; + width += tx; + } else { + var w1 = glyphWidth * textState.fontMatrix[0]; + ty = w1 * textState.fontSize + charSpacing; + height += ty; + } + textState.translateTextMatrix(tx, ty); + + textChunk.str.push(glyphUnicode); + } + + if (!font.vertical) { + textChunk.lastAdvanceWidth = width; + textChunk.width += width * textChunk.textAdvanceScale; + } else { + textChunk.lastAdvanceHeight = height; + textChunk.height += Math.abs(height * textChunk.textAdvanceScale); + } + + return textChunk; + } + + function addFakeSpaces(width, strBuf) { + if (width < textContentItem.fakeSpaceMin) { + return; + } + if (width < textContentItem.fakeMultiSpaceMin) { + strBuf.push(' '); + return; + } + var fakeSpaces = Math.round(width / textContentItem.spaceWidth); + while (fakeSpaces-- > 0) { + strBuf.push(' '); + } + } + + function flushTextContentItem() { + if (!textContentItem.initialized) { + return; + } + textContent.items.push(runBidiTransform(textContentItem)); + + textContentItem.initialized = false; + textContentItem.str.length = 0; + } + + var timeSlotManager = new TimeSlotManager(); + + return new Promise(function next(resolve, reject) { + task.ensureNotTerminated(); + timeSlotManager.reset(); + var stop, operation = {}, args = []; + while (!(stop = timeSlotManager.check())) { + // The arguments parsed by read() are not used beyond this loop, so + // we can reuse the same array on every iteration, thus avoiding + // unnecessary allocations. + args.length = 0; + operation.args = args; + if (!(preprocessor.read(operation))) { + break; + } + textState = stateManager.state; + var fn = operation.fn; + args = operation.args; + var advance; + + switch (fn | 0) { + case OPS.setFont: + flushTextContentItem(); + textState.fontSize = args[1]; + return handleSetFont(args[0].name).then(function() { + next(resolve, reject); + }, reject); + case OPS.setTextRise: + flushTextContentItem(); + textState.textRise = args[0]; + break; + case OPS.setHScale: + flushTextContentItem(); + textState.textHScale = args[0] / 100; + break; + case OPS.setLeading: + flushTextContentItem(); + textState.leading = args[0]; + break; + case OPS.moveText: + // Optimization to treat same line movement as advance + var isSameTextLine = !textState.font ? false : + ((textState.font.vertical ? args[0] : args[1]) === 0); + advance = args[0] - args[1]; + if (isSameTextLine && textContentItem.initialized && + advance > 0 && + advance <= textContentItem.fakeMultiSpaceMax) { + textState.translateTextLineMatrix(args[0], args[1]); + textContentItem.width += + (args[0] - textContentItem.lastAdvanceWidth); + textContentItem.height += + (args[1] - textContentItem.lastAdvanceHeight); + var diff = (args[0] - textContentItem.lastAdvanceWidth) - + (args[1] - textContentItem.lastAdvanceHeight); + addFakeSpaces(diff, textContentItem.str); + break; + } + + flushTextContentItem(); + textState.translateTextLineMatrix(args[0], args[1]); + textState.textMatrix = textState.textLineMatrix.slice(); + break; + case OPS.setLeadingMoveText: + flushTextContentItem(); + textState.leading = -args[1]; + textState.translateTextLineMatrix(args[0], args[1]); + textState.textMatrix = textState.textLineMatrix.slice(); + break; + case OPS.nextLine: + flushTextContentItem(); + textState.carriageReturn(); + break; + case OPS.setTextMatrix: + flushTextContentItem(); + textState.setTextMatrix(args[0], args[1], args[2], args[3], + args[4], args[5]); + textState.setTextLineMatrix(args[0], args[1], args[2], args[3], + args[4], args[5]); + break; + case OPS.setCharSpacing: + textState.charSpacing = args[0]; + break; + case OPS.setWordSpacing: + textState.wordSpacing = args[0]; + break; + case OPS.beginText: + flushTextContentItem(); + textState.textMatrix = IDENTITY_MATRIX.slice(); + textState.textLineMatrix = IDENTITY_MATRIX.slice(); + break; + case OPS.showSpacedText: + var items = args[0]; + var offset; + for (var j = 0, jj = items.length; j < jj; j++) { + if (typeof items[j] === 'string') { + buildTextContentItem(items[j]); + } else { + ensureTextContentItem(); + + // PDF Specification 5.3.2 states: + // The number is expressed in thousandths of a unit of text + // space. + // This amount is subtracted from the current horizontal or + // vertical coordinate, depending on the writing mode. + // In the default coordinate system, a positive adjustment + // has the effect of moving the next glyph painted either to + // the left or down by the given amount. + advance = items[j] * textState.fontSize / 1000; + var breakTextRun = false; + if (textState.font.vertical) { + offset = advance * + (textState.textHScale * textState.textMatrix[2] + + textState.textMatrix[3]); + textState.translateTextMatrix(0, advance); + breakTextRun = textContentItem.textRunBreakAllowed && + advance > textContentItem.fakeMultiSpaceMax; + if (!breakTextRun) { + // Value needs to be added to height to paint down. + textContentItem.height += offset; + } + } else { + advance = -advance; + offset = advance * ( + textState.textHScale * textState.textMatrix[0] + + textState.textMatrix[1]); + textState.translateTextMatrix(advance, 0); + breakTextRun = textContentItem.textRunBreakAllowed && + advance > textContentItem.fakeMultiSpaceMax; + if (!breakTextRun) { + // Value needs to be subtracted from width to paint left. + textContentItem.width += offset; + } + } + if (breakTextRun) { + flushTextContentItem(); + } else if (advance > 0) { + addFakeSpaces(advance, textContentItem.str); + } + } + } + break; + case OPS.showText: + buildTextContentItem(args[0]); + break; + case OPS.nextLineShowText: + flushTextContentItem(); + textState.carriageReturn(); + buildTextContentItem(args[0]); + break; + case OPS.nextLineSetSpacingShowText: + flushTextContentItem(); + textState.wordSpacing = args[0]; + textState.charSpacing = args[1]; + textState.carriageReturn(); + buildTextContentItem(args[2]); + break; + case OPS.paintXObject: + flushTextContentItem(); + if (args[0].code) { + break; + } + + if (!xobjs) { + xobjs = (resources.get('XObject') || Dict.empty); + } + + var name = args[0].name; + if (xobjsCache.key === name) { + if (xobjsCache.texts) { + Util.appendToArray(textContent.items, xobjsCache.texts.items); + Util.extendObj(textContent.styles, xobjsCache.texts.styles); + } + break; + } + + var xobj = xobjs.get(name); + if (!xobj) { + break; + } + assert(isStream(xobj), 'XObject should be a stream'); + + var type = xobj.dict.get('Subtype'); + assert(isName(type), + 'XObject should have a Name subtype'); + + if ('Form' !== type.name) { + xobjsCache.key = name; + xobjsCache.texts = null; + break; + } + + stateManager.save(); + var matrix = xobj.dict.get('Matrix'); + if (isArray(matrix) && matrix.length === 6) { + stateManager.transform(matrix); + } + + return self.getTextContent(xobj, task, + xobj.dict.get('Resources') || resources, stateManager, + normalizeWhitespace).then(function (formTextContent) { + Util.appendToArray(textContent.items, formTextContent.items); + Util.extendObj(textContent.styles, formTextContent.styles); + stateManager.restore(); + + xobjsCache.key = name; + xobjsCache.texts = formTextContent; + + next(resolve, reject); + }, reject); + case OPS.setGState: + flushTextContentItem(); + var dictName = args[0]; + var extGState = resources.get('ExtGState'); + + if (!isDict(extGState) || !extGState.has(dictName.name)) { + break; + } + + var gsStateMap = extGState.get(dictName.name); + var gsStateFont = null; + for (var key in gsStateMap) { + if (key === 'Font') { + assert(!gsStateFont); + gsStateFont = gsStateMap[key]; + } + } + if (gsStateFont) { + textState.fontSize = gsStateFont[1]; + return handleSetFont(gsStateFont[0]).then(function() { + next(resolve, reject); + }, reject); + } + break; + } // switch + } // while + if (stop) { + deferred.then(function () { + next(resolve, reject); + }, reject); + return; + } + flushTextContentItem(); + resolve(textContent); + }); + }, + + extractDataStructures: function + partialEvaluatorExtractDataStructures(dict, baseDict, + xref, properties) { + // 9.10.2 + var toUnicode = (dict.get('ToUnicode') || baseDict.get('ToUnicode')); + if (toUnicode) { + properties.toUnicode = this.readToUnicode(toUnicode); + } + if (properties.composite) { + // CIDSystemInfo helps to match CID to glyphs + var cidSystemInfo = dict.get('CIDSystemInfo'); + if (isDict(cidSystemInfo)) { + properties.cidSystemInfo = { + registry: cidSystemInfo.get('Registry'), + ordering: cidSystemInfo.get('Ordering'), + supplement: cidSystemInfo.get('Supplement') + }; + } + + var cidToGidMap = dict.get('CIDToGIDMap'); + if (isStream(cidToGidMap)) { + properties.cidToGidMap = this.readCidToGidMap(cidToGidMap); + } + } + + // Based on 9.6.6 of the spec the encoding can come from multiple places + // and depends on the font type. The base encoding and differences are + // read here, but the encoding that is actually used is chosen during + // glyph mapping in the font. + // TODO: Loading the built in encoding in the font would allow the + // differences to be merged in here not require us to hold on to it. + var differences = []; + var baseEncodingName = null; + var encoding; + if (dict.has('Encoding')) { + encoding = dict.get('Encoding'); + if (isDict(encoding)) { + baseEncodingName = encoding.get('BaseEncoding'); + baseEncodingName = (isName(baseEncodingName) ? + baseEncodingName.name : null); + // Load the differences between the base and original + if (encoding.has('Differences')) { + var diffEncoding = encoding.get('Differences'); + var index = 0; + for (var j = 0, jj = diffEncoding.length; j < jj; j++) { + var data = diffEncoding[j]; + if (isNum(data)) { + index = data; + } else if (isName(data)) { + differences[index++] = data.name; + } else if (isRef(data)) { + diffEncoding[j--] = xref.fetch(data); + continue; + } else { + error('Invalid entry in \'Differences\' array: ' + data); + } + } + } + } else if (isName(encoding)) { + baseEncodingName = encoding.name; + } else { + error('Encoding is not a Name nor a Dict'); + } + // According to table 114 if the encoding is a named encoding it must be + // one of these predefined encodings. + if ((baseEncodingName !== 'MacRomanEncoding' && + baseEncodingName !== 'MacExpertEncoding' && + baseEncodingName !== 'WinAnsiEncoding')) { + baseEncodingName = null; + } + } + + if (baseEncodingName) { + properties.defaultEncoding = Encodings[baseEncodingName].slice(); + } else { + encoding = (properties.type === 'TrueType' ? + Encodings.WinAnsiEncoding : Encodings.StandardEncoding); + // The Symbolic attribute can be misused for regular fonts + // Heuristic: we have to check if the font is a standard one also + if (!!(properties.flags & FontFlags.Symbolic)) { + encoding = Encodings.MacRomanEncoding; + if (!properties.file) { + if (/Symbol/i.test(properties.name)) { + encoding = Encodings.SymbolSetEncoding; + } else if (/Dingbats/i.test(properties.name)) { + encoding = Encodings.ZapfDingbatsEncoding; + } + } + } + properties.defaultEncoding = encoding; + } + + properties.differences = differences; + properties.baseEncodingName = baseEncodingName; + properties.dict = dict; + }, + + readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) { + var cmap, cmapObj = toUnicode; + if (isName(cmapObj)) { + cmap = CMapFactory.create(cmapObj, + { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null); + if (cmap instanceof IdentityCMap) { + return new IdentityToUnicodeMap(0, 0xFFFF); + } + return new ToUnicodeMap(cmap.getMap()); + } else if (isStream(cmapObj)) { + cmap = CMapFactory.create(cmapObj, + { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null); + if (cmap instanceof IdentityCMap) { + return new IdentityToUnicodeMap(0, 0xFFFF); + } + var map = new Array(cmap.length); + // Convert UTF-16BE + // NOTE: cmap can be a sparse array, so use forEach instead of for(;;) + // to iterate over all keys. + cmap.forEach(function(charCode, token) { + var str = []; + for (var k = 0; k < token.length; k += 2) { + var w1 = (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1); + if ((w1 & 0xF800) !== 0xD800) { // w1 < 0xD800 || w1 > 0xDFFF + str.push(w1); + continue; + } + k += 2; + var w2 = (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1); + str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000); + } + map[charCode] = String.fromCharCode.apply(String, str); + }); + return new ToUnicodeMap(map); + } + return null; + }, + + readCidToGidMap: function PartialEvaluator_readCidToGidMap(cidToGidStream) { + // Extract the encoding from the CIDToGIDMap + var glyphsData = cidToGidStream.getBytes(); + + // Set encoding 0 to later verify the font has an encoding + var result = []; + for (var j = 0, jj = glyphsData.length; j < jj; j++) { + var glyphID = (glyphsData[j++] << 8) | glyphsData[j]; + if (glyphID === 0) { + continue; + } + var code = j >> 1; + result[code] = glyphID; + } + return result; + }, + + extractWidths: function PartialEvaluator_extractWidths(dict, xref, + descriptor, + properties) { + var glyphsWidths = []; + var defaultWidth = 0; + var glyphsVMetrics = []; + var defaultVMetrics; + var i, ii, j, jj, start, code, widths; + if (properties.composite) { + defaultWidth = dict.get('DW') || 1000; + + widths = dict.get('W'); + if (widths) { + for (i = 0, ii = widths.length; i < ii; i++) { + start = widths[i++]; + code = xref.fetchIfRef(widths[i]); + if (isArray(code)) { + for (j = 0, jj = code.length; j < jj; j++) { + glyphsWidths[start++] = code[j]; + } + } else { + var width = widths[++i]; + for (j = start; j <= code; j++) { + glyphsWidths[j] = width; + } + } + } + } + + if (properties.vertical) { + var vmetrics = (dict.get('DW2') || [880, -1000]); + defaultVMetrics = [vmetrics[1], defaultWidth * 0.5, vmetrics[0]]; + vmetrics = dict.get('W2'); + if (vmetrics) { + for (i = 0, ii = vmetrics.length; i < ii; i++) { + start = vmetrics[i++]; + code = xref.fetchIfRef(vmetrics[i]); + if (isArray(code)) { + for (j = 0, jj = code.length; j < jj; j++) { + glyphsVMetrics[start++] = [code[j++], code[j++], code[j]]; + } + } else { + var vmetric = [vmetrics[++i], vmetrics[++i], vmetrics[++i]]; + for (j = start; j <= code; j++) { + glyphsVMetrics[j] = vmetric; + } + } + } + } + } + } else { + var firstChar = properties.firstChar; + widths = dict.get('Widths'); + if (widths) { + j = firstChar; + for (i = 0, ii = widths.length; i < ii; i++) { + glyphsWidths[j++] = widths[i]; + } + defaultWidth = (parseFloat(descriptor.get('MissingWidth')) || 0); + } else { + // Trying get the BaseFont metrics (see comment above). + var baseFontName = dict.get('BaseFont'); + if (isName(baseFontName)) { + var metrics = this.getBaseFontMetrics(baseFontName.name); + + glyphsWidths = this.buildCharCodeToWidth(metrics.widths, + properties); + defaultWidth = metrics.defaultWidth; + } + } + } + + // Heuristic: detection of monospace font by checking all non-zero widths + var isMonospace = true; + var firstWidth = defaultWidth; + for (var glyph in glyphsWidths) { + var glyphWidth = glyphsWidths[glyph]; + if (!glyphWidth) { + continue; + } + if (!firstWidth) { + firstWidth = glyphWidth; + continue; + } + if (firstWidth !== glyphWidth) { + isMonospace = false; + break; + } + } + if (isMonospace) { + properties.flags |= FontFlags.FixedPitch; + } + + properties.defaultWidth = defaultWidth; + properties.widths = glyphsWidths; + properties.defaultVMetrics = defaultVMetrics; + properties.vmetrics = glyphsVMetrics; + }, + + isSerifFont: function PartialEvaluator_isSerifFont(baseFontName) { + // Simulating descriptor flags attribute + var fontNameWoStyle = baseFontName.split('-')[0]; + return (fontNameWoStyle in serifFonts) || + (fontNameWoStyle.search(/serif/gi) !== -1); + }, + + getBaseFontMetrics: function PartialEvaluator_getBaseFontMetrics(name) { + var defaultWidth = 0; + var widths = []; + var monospace = false; + var lookupName = (stdFontMap[name] || name); + + if (!(lookupName in Metrics)) { + // Use default fonts for looking up font metrics if the passed + // font is not a base font + if (this.isSerifFont(name)) { + lookupName = 'Times-Roman'; + } else { + lookupName = 'Helvetica'; + } + } + var glyphWidths = Metrics[lookupName]; + + if (isNum(glyphWidths)) { + defaultWidth = glyphWidths; + monospace = true; + } else { + widths = glyphWidths; + } + + return { + defaultWidth: defaultWidth, + monospace: monospace, + widths: widths + }; + }, + + buildCharCodeToWidth: + function PartialEvaluator_bulildCharCodeToWidth(widthsByGlyphName, + properties) { + var widths = Object.create(null); + var differences = properties.differences; + var encoding = properties.defaultEncoding; + for (var charCode = 0; charCode < 256; charCode++) { + if (charCode in differences && + widthsByGlyphName[differences[charCode]]) { + widths[charCode] = widthsByGlyphName[differences[charCode]]; + continue; + } + if (charCode in encoding && widthsByGlyphName[encoding[charCode]]) { + widths[charCode] = widthsByGlyphName[encoding[charCode]]; + continue; + } + } + return widths; + }, + + preEvaluateFont: function PartialEvaluator_preEvaluateFont(dict, xref) { + var baseDict = dict; + var type = dict.get('Subtype'); + assert(isName(type), 'invalid font Subtype'); + + var composite = false; + var uint8array; + if (type.name === 'Type0') { + // If font is a composite + // - get the descendant font + // - set the type according to the descendant font + // - get the FontDescriptor from the descendant font + var df = dict.get('DescendantFonts'); + if (!df) { + error('Descendant fonts are not specified'); + } + dict = (isArray(df) ? xref.fetchIfRef(df[0]) : df); + + type = dict.get('Subtype'); + assert(isName(type), 'invalid font Subtype'); + composite = true; + } + + var descriptor = dict.get('FontDescriptor'); + if (descriptor) { + var hash = new MurmurHash3_64(); + var encoding = baseDict.getRaw('Encoding'); + if (isName(encoding)) { + hash.update(encoding.name); + } else if (isRef(encoding)) { + hash.update(encoding.num + '_' + encoding.gen); + } else if (isDict(encoding)) { + var keys = encoding.getKeys(); + for (var i = 0, ii = keys.length; i < ii; i++) { + var entry = encoding.getRaw(keys[i]); + if (isName(entry)) { + hash.update(entry.name); + } else if (isRef(entry)) { + hash.update(entry.num + '_' + entry.gen); + } else if (isArray(entry)) { // 'Differences' entry. + // Ideally we should check the contents of the array, but to avoid + // parsing it here and then again in |extractDataStructures|, + // we only use the array length for now (fixes bug1157493.pdf). + hash.update(entry.length.toString()); + } + } + } + + var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode'); + if (isStream(toUnicode)) { + var stream = toUnicode.str || toUnicode; + uint8array = stream.buffer ? + new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) : + new Uint8Array(stream.bytes.buffer, + stream.start, stream.end - stream.start); + hash.update(uint8array); + + } else if (isName(toUnicode)) { + hash.update(toUnicode.name); + } + + var widths = dict.get('Widths') || baseDict.get('Widths'); + if (widths) { + uint8array = new Uint8Array(new Uint32Array(widths).buffer); + hash.update(uint8array); + } + } + + return { + descriptor: descriptor, + dict: dict, + baseDict: baseDict, + composite: composite, + type: type.name, + hash: hash ? hash.hexdigest() : '' + }; + }, + + translateFont: function PartialEvaluator_translateFont(preEvaluatedFont, + xref) { + var baseDict = preEvaluatedFont.baseDict; + var dict = preEvaluatedFont.dict; + var composite = preEvaluatedFont.composite; + var descriptor = preEvaluatedFont.descriptor; + var type = preEvaluatedFont.type; + var maxCharIndex = (composite ? 0xFFFF : 0xFF); + var properties; + + if (!descriptor) { + if (type === 'Type3') { + // FontDescriptor is only required for Type3 fonts when the document + // is a tagged pdf. Create a barbebones one to get by. + descriptor = new Dict(null); + descriptor.set('FontName', Name.get(type)); + descriptor.set('FontBBox', dict.get('FontBBox')); + } else { + // Before PDF 1.5 if the font was one of the base 14 fonts, having a + // FontDescriptor was not required. + // This case is here for compatibility. + var baseFontName = dict.get('BaseFont'); + if (!isName(baseFontName)) { + error('Base font is not specified'); + } + + // Using base font name as a font name. + baseFontName = baseFontName.name.replace(/[,_]/g, '-'); + var metrics = this.getBaseFontMetrics(baseFontName); + + // Simulating descriptor flags attribute + var fontNameWoStyle = baseFontName.split('-')[0]; + var flags = + (this.isSerifFont(fontNameWoStyle) ? FontFlags.Serif : 0) | + (metrics.monospace ? FontFlags.FixedPitch : 0) | + (symbolsFonts[fontNameWoStyle] ? FontFlags.Symbolic : + FontFlags.Nonsymbolic); + + properties = { + type: type, + name: baseFontName, + widths: metrics.widths, + defaultWidth: metrics.defaultWidth, + flags: flags, + firstChar: 0, + lastChar: maxCharIndex + }; + this.extractDataStructures(dict, dict, xref, properties); + properties.widths = this.buildCharCodeToWidth(metrics.widths, + properties); + return new Font(baseFontName, null, properties); + } + } + + // According to the spec if 'FontDescriptor' is declared, 'FirstChar', + // 'LastChar' and 'Widths' should exist too, but some PDF encoders seem + // to ignore this rule when a variant of a standart font is used. + // TODO Fill the width array depending on which of the base font this is + // a variant. + var firstChar = (dict.get('FirstChar') || 0); + var lastChar = (dict.get('LastChar') || maxCharIndex); + + var fontName = descriptor.get('FontName'); + var baseFont = dict.get('BaseFont'); + // Some bad PDFs have a string as the font name. + if (isString(fontName)) { + fontName = Name.get(fontName); + } + if (isString(baseFont)) { + baseFont = Name.get(baseFont); + } + + if (type !== 'Type3') { + var fontNameStr = fontName && fontName.name; + var baseFontStr = baseFont && baseFont.name; + if (fontNameStr !== baseFontStr) { + info('The FontDescriptor\'s FontName is "' + fontNameStr + + '" but should be the same as the Font\'s BaseFont "' + + baseFontStr + '"'); + // Workaround for cases where e.g. fontNameStr = 'Arial' and + // baseFontStr = 'Arial,Bold' (needed when no font file is embedded). + if (fontNameStr && baseFontStr && + baseFontStr.indexOf(fontNameStr) === 0) { + fontName = baseFont; + } + } + } + fontName = (fontName || baseFont); + + assert(isName(fontName), 'invalid font name'); + + var fontFile = descriptor.get('FontFile', 'FontFile2', 'FontFile3'); + if (fontFile) { + if (fontFile.dict) { + var subtype = fontFile.dict.get('Subtype'); + if (subtype) { + subtype = subtype.name; + } + var length1 = fontFile.dict.get('Length1'); + var length2 = fontFile.dict.get('Length2'); + } + } + + properties = { + type: type, + name: fontName.name, + subtype: subtype, + file: fontFile, + length1: length1, + length2: length2, + loadedName: baseDict.loadedName, + composite: composite, + wideChars: composite, + fixedPitch: false, + fontMatrix: (dict.get('FontMatrix') || FONT_IDENTITY_MATRIX), + firstChar: firstChar || 0, + lastChar: (lastChar || maxCharIndex), + bbox: descriptor.get('FontBBox'), + ascent: descriptor.get('Ascent'), + descent: descriptor.get('Descent'), + xHeight: descriptor.get('XHeight'), + capHeight: descriptor.get('CapHeight'), + flags: descriptor.get('Flags'), + italicAngle: descriptor.get('ItalicAngle'), + coded: false + }; + + if (composite) { + var cidEncoding = baseDict.get('Encoding'); + if (isName(cidEncoding)) { + properties.cidEncoding = cidEncoding.name; + } + properties.cMap = CMapFactory.create(cidEncoding, + { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null); + properties.vertical = properties.cMap.vertical; + } + this.extractDataStructures(dict, baseDict, xref, properties); + this.extractWidths(dict, xref, descriptor, properties); + + if (type === 'Type3') { + properties.isType3Font = true; + } + + return new Font(fontName.name, fontFile, properties); + } + }; + + return PartialEvaluator; +})(); + +var TranslatedFont = (function TranslatedFontClosure() { + function TranslatedFont(loadedName, font, dict) { + this.loadedName = loadedName; + this.font = font; + this.dict = dict; + this.type3Loaded = null; + this.sent = false; + } + TranslatedFont.prototype = { + send: function (handler) { + if (this.sent) { + return; + } + var fontData = this.font.exportData(); + handler.send('commonobj', [ + this.loadedName, + 'Font', + fontData + ]); + this.sent = true; + }, + loadType3Data: function (evaluator, resources, parentOperatorList, task) { + assert(this.font.isType3Font); + + if (this.type3Loaded) { + return this.type3Loaded; + } + + var translatedFont = this.font; + var loadCharProcsPromise = Promise.resolve(); + var charProcs = this.dict.get('CharProcs').getAll(); + var fontResources = this.dict.get('Resources') || resources; + var charProcKeys = Object.keys(charProcs); + var charProcOperatorList = {}; + for (var i = 0, n = charProcKeys.length; i < n; ++i) { + loadCharProcsPromise = loadCharProcsPromise.then(function (key) { + var glyphStream = charProcs[key]; + var operatorList = new OperatorList(); + return evaluator.getOperatorList(glyphStream, task, fontResources, + operatorList).then(function () { + charProcOperatorList[key] = operatorList.getIR(); + + // Add the dependencies to the parent operator list so they are + // resolved before sub operator list is executed synchronously. + parentOperatorList.addDependencies(operatorList.dependencies); + }, function (reason) { + warn('Type3 font resource \"' + key + '\" is not available'); + var operatorList = new OperatorList(); + charProcOperatorList[key] = operatorList.getIR(); + }); + }.bind(this, charProcKeys[i])); + } + this.type3Loaded = loadCharProcsPromise.then(function () { + translatedFont.charProcOperatorList = charProcOperatorList; + }); + return this.type3Loaded; + } + }; + return TranslatedFont; +})(); + +var OperatorList = (function OperatorListClosure() { + var CHUNK_SIZE = 1000; + var CHUNK_SIZE_ABOUT = CHUNK_SIZE - 5; // close to chunk size + + function getTransfers(queue) { + var transfers = []; + var fnArray = queue.fnArray, argsArray = queue.argsArray; + for (var i = 0, ii = queue.length; i < ii; i++) { + switch (fnArray[i]) { + case OPS.paintInlineImageXObject: + case OPS.paintInlineImageXObjectGroup: + case OPS.paintImageMaskXObject: + var arg = argsArray[i][0]; // first param in imgData + if (!arg.cached) { + transfers.push(arg.data.buffer); + } + break; + } + } + return transfers; + } + + function OperatorList(intent, messageHandler, pageIndex) { + this.messageHandler = messageHandler; + this.fnArray = []; + this.argsArray = []; + this.dependencies = {}; + this._totalLength = 0; + this.pageIndex = pageIndex; + this.intent = intent; + } + + OperatorList.prototype = { + get length() { + return this.argsArray.length; + }, + + /** + * @returns {number} The total length of the entire operator list, + * since `this.length === 0` after flushing. + */ + get totalLength() { + return (this._totalLength + this.length); + }, + + addOp: function(fn, args) { + this.fnArray.push(fn); + this.argsArray.push(args); + if (this.messageHandler) { + if (this.fnArray.length >= CHUNK_SIZE) { + this.flush(); + } else if (this.fnArray.length >= CHUNK_SIZE_ABOUT && + (fn === OPS.restore || fn === OPS.endText)) { + // heuristic to flush on boundary of restore or endText + this.flush(); + } + } + }, + + addDependency: function(dependency) { + if (dependency in this.dependencies) { + return; + } + this.dependencies[dependency] = true; + this.addOp(OPS.dependency, [dependency]); + }, + + addDependencies: function(dependencies) { + for (var key in dependencies) { + this.addDependency(key); + } + }, + + addOpList: function(opList) { + Util.extendObj(this.dependencies, opList.dependencies); + for (var i = 0, ii = opList.length; i < ii; i++) { + this.addOp(opList.fnArray[i], opList.argsArray[i]); + } + }, + + getIR: function() { + return { + fnArray: this.fnArray, + argsArray: this.argsArray, + length: this.length + }; + }, + + flush: function(lastChunk) { + if (this.intent !== 'oplist') { + new QueueOptimizer().optimize(this); + } + var transfers = getTransfers(this); + var length = this.length; + this._totalLength += length; + + this.messageHandler.send('RenderPageChunk', { + operatorList: { + fnArray: this.fnArray, + argsArray: this.argsArray, + lastChunk: lastChunk, + length: length + }, + pageIndex: this.pageIndex, + intent: this.intent + }, transfers); + this.dependencies = {}; + this.fnArray.length = 0; + this.argsArray.length = 0; + } + }; + + return OperatorList; +})(); + +var StateManager = (function StateManagerClosure() { + function StateManager(initialState) { + this.state = initialState; + this.stateStack = []; + } + StateManager.prototype = { + save: function () { + var old = this.state; + this.stateStack.push(this.state); + this.state = old.clone(); + }, + restore: function () { + var prev = this.stateStack.pop(); + if (prev) { + this.state = prev; + } + }, + transform: function (args) { + this.state.ctm = Util.transform(this.state.ctm, args); + } + }; + return StateManager; +})(); + +var TextState = (function TextStateClosure() { + function TextState() { + this.ctm = new Float32Array(IDENTITY_MATRIX); + this.fontSize = 0; + this.font = null; + this.fontMatrix = FONT_IDENTITY_MATRIX; + this.textMatrix = IDENTITY_MATRIX.slice(); + this.textLineMatrix = IDENTITY_MATRIX.slice(); + this.charSpacing = 0; + this.wordSpacing = 0; + this.leading = 0; + this.textHScale = 1; + this.textRise = 0; + } + + TextState.prototype = { + setTextMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) { + var m = this.textMatrix; + m[0] = a; m[1] = b; m[2] = c; m[3] = d; m[4] = e; m[5] = f; + }, + setTextLineMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) { + var m = this.textLineMatrix; + m[0] = a; m[1] = b; m[2] = c; m[3] = d; m[4] = e; m[5] = f; + }, + translateTextMatrix: function TextState_translateTextMatrix(x, y) { + var m = this.textMatrix; + m[4] = m[0] * x + m[2] * y + m[4]; + m[5] = m[1] * x + m[3] * y + m[5]; + }, + translateTextLineMatrix: function TextState_translateTextMatrix(x, y) { + var m = this.textLineMatrix; + m[4] = m[0] * x + m[2] * y + m[4]; + m[5] = m[1] * x + m[3] * y + m[5]; + }, + calcRenderMatrix: function TextState_calcRendeMatrix(ctm) { + // 9.4.4 Text Space Details + var tsm = [this.fontSize * this.textHScale, 0, + 0, this.fontSize, + 0, this.textRise]; + return Util.transform(ctm, Util.transform(this.textMatrix, tsm)); + }, + carriageReturn: function TextState_carriageReturn() { + this.translateTextLineMatrix(0, -this.leading); + this.textMatrix = this.textLineMatrix.slice(); + }, + clone: function TextState_clone() { + var clone = Object.create(this); + clone.textMatrix = this.textMatrix.slice(); + clone.textLineMatrix = this.textLineMatrix.slice(); + clone.fontMatrix = this.fontMatrix.slice(); + return clone; + } + }; + return TextState; +})(); + +var EvalState = (function EvalStateClosure() { + function EvalState() { + this.ctm = new Float32Array(IDENTITY_MATRIX); + this.font = null; + this.textRenderingMode = TextRenderingMode.FILL; + this.fillColorSpace = ColorSpace.singletons.gray; + this.strokeColorSpace = ColorSpace.singletons.gray; + } + EvalState.prototype = { + clone: function CanvasExtraState_clone() { + return Object.create(this); + }, + }; + return EvalState; +})(); + +var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { + // Specifies properties for each command + // + // If variableArgs === true: [0, `numArgs`] expected + // If variableArgs === false: exactly `numArgs` expected + var OP_MAP = { + // Graphic state + w: { id: OPS.setLineWidth, numArgs: 1, variableArgs: false }, + J: { id: OPS.setLineCap, numArgs: 1, variableArgs: false }, + j: { id: OPS.setLineJoin, numArgs: 1, variableArgs: false }, + M: { id: OPS.setMiterLimit, numArgs: 1, variableArgs: false }, + d: { id: OPS.setDash, numArgs: 2, variableArgs: false }, + ri: { id: OPS.setRenderingIntent, numArgs: 1, variableArgs: false }, + i: { id: OPS.setFlatness, numArgs: 1, variableArgs: false }, + gs: { id: OPS.setGState, numArgs: 1, variableArgs: false }, + q: { id: OPS.save, numArgs: 0, variableArgs: false }, + Q: { id: OPS.restore, numArgs: 0, variableArgs: false }, + cm: { id: OPS.transform, numArgs: 6, variableArgs: false }, + + // Path + m: { id: OPS.moveTo, numArgs: 2, variableArgs: false }, + l: { id: OPS.lineTo, numArgs: 2, variableArgs: false }, + c: { id: OPS.curveTo, numArgs: 6, variableArgs: false }, + v: { id: OPS.curveTo2, numArgs: 4, variableArgs: false }, + y: { id: OPS.curveTo3, numArgs: 4, variableArgs: false }, + h: { id: OPS.closePath, numArgs: 0, variableArgs: false }, + re: { id: OPS.rectangle, numArgs: 4, variableArgs: false }, + S: { id: OPS.stroke, numArgs: 0, variableArgs: false }, + s: { id: OPS.closeStroke, numArgs: 0, variableArgs: false }, + f: { id: OPS.fill, numArgs: 0, variableArgs: false }, + F: { id: OPS.fill, numArgs: 0, variableArgs: false }, + 'f*': { id: OPS.eoFill, numArgs: 0, variableArgs: false }, + B: { id: OPS.fillStroke, numArgs: 0, variableArgs: false }, + 'B*': { id: OPS.eoFillStroke, numArgs: 0, variableArgs: false }, + b: { id: OPS.closeFillStroke, numArgs: 0, variableArgs: false }, + 'b*': { id: OPS.closeEOFillStroke, numArgs: 0, variableArgs: false }, + n: { id: OPS.endPath, numArgs: 0, variableArgs: false }, + + // Clipping + W: { id: OPS.clip, numArgs: 0, variableArgs: false }, + 'W*': { id: OPS.eoClip, numArgs: 0, variableArgs: false }, + + // Text + BT: { id: OPS.beginText, numArgs: 0, variableArgs: false }, + ET: { id: OPS.endText, numArgs: 0, variableArgs: false }, + Tc: { id: OPS.setCharSpacing, numArgs: 1, variableArgs: false }, + Tw: { id: OPS.setWordSpacing, numArgs: 1, variableArgs: false }, + Tz: { id: OPS.setHScale, numArgs: 1, variableArgs: false }, + TL: { id: OPS.setLeading, numArgs: 1, variableArgs: false }, + Tf: { id: OPS.setFont, numArgs: 2, variableArgs: false }, + Tr: { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false }, + Ts: { id: OPS.setTextRise, numArgs: 1, variableArgs: false }, + Td: { id: OPS.moveText, numArgs: 2, variableArgs: false }, + TD: { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false }, + Tm: { id: OPS.setTextMatrix, numArgs: 6, variableArgs: false }, + 'T*': { id: OPS.nextLine, numArgs: 0, variableArgs: false }, + Tj: { id: OPS.showText, numArgs: 1, variableArgs: false }, + TJ: { id: OPS.showSpacedText, numArgs: 1, variableArgs: false }, + '\'': { id: OPS.nextLineShowText, numArgs: 1, variableArgs: false }, + '"': { id: OPS.nextLineSetSpacingShowText, numArgs: 3, + variableArgs: false }, + + // Type3 fonts + d0: { id: OPS.setCharWidth, numArgs: 2, variableArgs: false }, + d1: { id: OPS.setCharWidthAndBounds, numArgs: 6, variableArgs: false }, + + // Color + CS: { id: OPS.setStrokeColorSpace, numArgs: 1, variableArgs: false }, + cs: { id: OPS.setFillColorSpace, numArgs: 1, variableArgs: false }, + SC: { id: OPS.setStrokeColor, numArgs: 4, variableArgs: true }, + SCN: { id: OPS.setStrokeColorN, numArgs: 33, variableArgs: true }, + sc: { id: OPS.setFillColor, numArgs: 4, variableArgs: true }, + scn: { id: OPS.setFillColorN, numArgs: 33, variableArgs: true }, + G: { id: OPS.setStrokeGray, numArgs: 1, variableArgs: false }, + g: { id: OPS.setFillGray, numArgs: 1, variableArgs: false }, + RG: { id: OPS.setStrokeRGBColor, numArgs: 3, variableArgs: false }, + rg: { id: OPS.setFillRGBColor, numArgs: 3, variableArgs: false }, + K: { id: OPS.setStrokeCMYKColor, numArgs: 4, variableArgs: false }, + k: { id: OPS.setFillCMYKColor, numArgs: 4, variableArgs: false }, + + // Shading + sh: { id: OPS.shadingFill, numArgs: 1, variableArgs: false }, + + // Images + BI: { id: OPS.beginInlineImage, numArgs: 0, variableArgs: false }, + ID: { id: OPS.beginImageData, numArgs: 0, variableArgs: false }, + EI: { id: OPS.endInlineImage, numArgs: 1, variableArgs: false }, + + // XObjects + Do: { id: OPS.paintXObject, numArgs: 1, variableArgs: false }, + MP: { id: OPS.markPoint, numArgs: 1, variableArgs: false }, + DP: { id: OPS.markPointProps, numArgs: 2, variableArgs: false }, + BMC: { id: OPS.beginMarkedContent, numArgs: 1, variableArgs: false }, + BDC: { id: OPS.beginMarkedContentProps, numArgs: 2, + variableArgs: false }, + EMC: { id: OPS.endMarkedContent, numArgs: 0, variableArgs: false }, + + // Compatibility + BX: { id: OPS.beginCompat, numArgs: 0, variableArgs: false }, + EX: { id: OPS.endCompat, numArgs: 0, variableArgs: false }, + + // (reserved partial commands for the lexer) + BM: null, + BD: null, + 'true': null, + fa: null, + fal: null, + fals: null, + 'false': null, + nu: null, + nul: null, + 'null': null + }; + + function EvaluatorPreprocessor(stream, xref, stateManager) { + // TODO(mduan): pass array of knownCommands rather than OP_MAP + // dictionary + this.parser = new Parser(new Lexer(stream, OP_MAP), false, xref); + this.stateManager = stateManager; + this.nonProcessedArgs = []; + } + + EvaluatorPreprocessor.prototype = { + get savedStatesDepth() { + return this.stateManager.stateStack.length; + }, + + // |operation| is an object with two fields: + // + // - |fn| is an out param. + // + // - |args| is an inout param. On entry, it should have one of two values. + // + // - An empty array. This indicates that the caller is providing the + // array in which the args will be stored in. The caller should use + // this value if it can reuse a single array for each call to read(). + // + // - |null|. This indicates that the caller needs this function to create + // the array in which any args are stored in. If there are zero args, + // this function will leave |operation.args| as |null| (thus avoiding + // allocations that would occur if we used an empty array to represent + // zero arguments). Otherwise, it will replace |null| with a new array + // containing the arguments. The caller should use this value if it + // cannot reuse an array for each call to read(). + // + // These two modes are present because this function is very hot and so + // avoiding allocations where possible is worthwhile. + // + read: function EvaluatorPreprocessor_read(operation) { + var args = operation.args; + while (true) { + var obj = this.parser.getObj(); + if (isCmd(obj)) { + var cmd = obj.cmd; + // Check that the command is valid + var opSpec = OP_MAP[cmd]; + if (!opSpec) { + warn('Unknown command "' + cmd + '"'); + continue; + } + + var fn = opSpec.id; + var numArgs = opSpec.numArgs; + var argsLength = args !== null ? args.length : 0; + + if (!opSpec.variableArgs) { + // Postscript commands can be nested, e.g. /F2 /GS2 gs 5.711 Tf + if (argsLength !== numArgs) { + var nonProcessedArgs = this.nonProcessedArgs; + while (argsLength > numArgs) { + nonProcessedArgs.push(args.shift()); + argsLength--; + } + while (argsLength < numArgs && nonProcessedArgs.length !== 0) { + if (!args) { + args = []; + } + args.unshift(nonProcessedArgs.pop()); + argsLength++; + } + } + + if (argsLength < numArgs) { + // If we receive too few args, it's not possible to possible + // to execute the command, so skip the command + info('Command ' + fn + ': because expected ' + + numArgs + ' args, but received ' + argsLength + + ' args; skipping'); + args = null; + continue; + } + } else if (argsLength > numArgs) { + info('Command ' + fn + ': expected [0,' + numArgs + + '] args, but received ' + argsLength + ' args'); + } + + // TODO figure out how to type-check vararg functions + this.preprocessCommand(fn, args); + + operation.fn = fn; + operation.args = args; + return true; + } else { + if (isEOF(obj)) { + return false; // no more commands + } + // argument + if (obj !== null) { + if (!args) { + args = []; + } + args.push((obj instanceof Dict ? obj.getAll() : obj)); + assert(args.length <= 33, 'Too many arguments'); + } + } + } + }, + + preprocessCommand: + function EvaluatorPreprocessor_preprocessCommand(fn, args) { + switch (fn | 0) { + case OPS.save: + this.stateManager.save(); + break; + case OPS.restore: + this.stateManager.restore(); + break; + case OPS.transform: + this.stateManager.transform(args); + break; + } + } + }; + return EvaluatorPreprocessor; +})(); + +var QueueOptimizer = (function QueueOptimizerClosure() { + function addState(parentState, pattern, fn) { + var state = parentState; + for (var i = 0, ii = pattern.length - 1; i < ii; i++) { + var item = pattern[i]; + state = (state[item] || (state[item] = [])); + } + state[pattern[pattern.length - 1]] = fn; + } + + function handlePaintSolidColorImageMask(iFirstSave, count, fnArray, + argsArray) { + // Handles special case of mainly LaTeX documents which use image masks to + // draw lines with the current fill style. + // 'count' groups of (save, transform, paintImageMaskXObject, restore)+ + // have been found at iFirstSave. + var iFirstPIMXO = iFirstSave + 2; + for (var i = 0; i < count; i++) { + var arg = argsArray[iFirstPIMXO + 4 * i]; + var imageMask = arg.length === 1 && arg[0]; + if (imageMask && imageMask.width === 1 && imageMask.height === 1 && + (!imageMask.data.length || + (imageMask.data.length === 1 && imageMask.data[0] === 0))) { + fnArray[iFirstPIMXO + 4 * i] = OPS.paintSolidColorImageMask; + continue; + } + break; + } + return count - i; + } + + var InitialState = []; + + // This replaces (save, transform, paintInlineImageXObject, restore)+ + // sequences with one |paintInlineImageXObjectGroup| operation. + addState(InitialState, + [OPS.save, OPS.transform, OPS.paintInlineImageXObject, OPS.restore], + function foundInlineImageGroup(context) { + var MIN_IMAGES_IN_INLINE_IMAGES_BLOCK = 10; + var MAX_IMAGES_IN_INLINE_IMAGES_BLOCK = 200; + var MAX_WIDTH = 1000; + var IMAGE_PADDING = 1; + + var fnArray = context.fnArray, argsArray = context.argsArray; + var curr = context.iCurr; + var iFirstSave = curr - 3; + var iFirstTransform = curr - 2; + var iFirstPIIXO = curr - 1; + + // Look for the quartets. + var i = iFirstSave + 4; + var ii = fnArray.length; + while (i + 3 < ii) { + if (fnArray[i] !== OPS.save || + fnArray[i + 1] !== OPS.transform || + fnArray[i + 2] !== OPS.paintInlineImageXObject || + fnArray[i + 3] !== OPS.restore) { + break; // ops don't match + } + i += 4; + } + + // At this point, i is the index of the first op past the last valid + // quartet. + var count = Math.min((i - iFirstSave) / 4, + MAX_IMAGES_IN_INLINE_IMAGES_BLOCK); + if (count < MIN_IMAGES_IN_INLINE_IMAGES_BLOCK) { + return i; + } + + // assuming that heights of those image is too small (~1 pixel) + // packing as much as possible by lines + var maxX = 0; + var map = [], maxLineHeight = 0; + var currentX = IMAGE_PADDING, currentY = IMAGE_PADDING; + var q; + for (q = 0; q < count; q++) { + var transform = argsArray[iFirstTransform + (q << 2)]; + var img = argsArray[iFirstPIIXO + (q << 2)][0]; + if (currentX + img.width > MAX_WIDTH) { + // starting new line + maxX = Math.max(maxX, currentX); + currentY += maxLineHeight + 2 * IMAGE_PADDING; + currentX = 0; + maxLineHeight = 0; + } + map.push({ + transform: transform, + x: currentX, y: currentY, + w: img.width, h: img.height + }); + currentX += img.width + 2 * IMAGE_PADDING; + maxLineHeight = Math.max(maxLineHeight, img.height); + } + var imgWidth = Math.max(maxX, currentX) + IMAGE_PADDING; + var imgHeight = currentY + maxLineHeight + IMAGE_PADDING; + var imgData = new Uint8Array(imgWidth * imgHeight * 4); + var imgRowSize = imgWidth << 2; + for (q = 0; q < count; q++) { + var data = argsArray[iFirstPIIXO + (q << 2)][0].data; + // Copy image by lines and extends pixels into padding. + var rowSize = map[q].w << 2; + var dataOffset = 0; + var offset = (map[q].x + map[q].y * imgWidth) << 2; + imgData.set(data.subarray(0, rowSize), offset - imgRowSize); + for (var k = 0, kk = map[q].h; k < kk; k++) { + imgData.set(data.subarray(dataOffset, dataOffset + rowSize), offset); + dataOffset += rowSize; + offset += imgRowSize; + } + imgData.set(data.subarray(dataOffset - rowSize, dataOffset), offset); + while (offset >= 0) { + data[offset - 4] = data[offset]; + data[offset - 3] = data[offset + 1]; + data[offset - 2] = data[offset + 2]; + data[offset - 1] = data[offset + 3]; + data[offset + rowSize] = data[offset + rowSize - 4]; + data[offset + rowSize + 1] = data[offset + rowSize - 3]; + data[offset + rowSize + 2] = data[offset + rowSize - 2]; + data[offset + rowSize + 3] = data[offset + rowSize - 1]; + offset -= imgRowSize; + } + } + + // Replace queue items. + fnArray.splice(iFirstSave, count * 4, OPS.paintInlineImageXObjectGroup); + argsArray.splice(iFirstSave, count * 4, + [{ width: imgWidth, height: imgHeight, kind: ImageKind.RGBA_32BPP, + data: imgData }, map]); + + return iFirstSave + 1; + }); + + // This replaces (save, transform, paintImageMaskXObject, restore)+ + // sequences with one |paintImageMaskXObjectGroup| or one + // |paintImageMaskXObjectRepeat| operation. + addState(InitialState, + [OPS.save, OPS.transform, OPS.paintImageMaskXObject, OPS.restore], + function foundImageMaskGroup(context) { + var MIN_IMAGES_IN_MASKS_BLOCK = 10; + var MAX_IMAGES_IN_MASKS_BLOCK = 100; + var MAX_SAME_IMAGES_IN_MASKS_BLOCK = 1000; + + var fnArray = context.fnArray, argsArray = context.argsArray; + var curr = context.iCurr; + var iFirstSave = curr - 3; + var iFirstTransform = curr - 2; + var iFirstPIMXO = curr - 1; + + // Look for the quartets. + var i = iFirstSave + 4; + var ii = fnArray.length; + while (i + 3 < ii) { + if (fnArray[i] !== OPS.save || + fnArray[i + 1] !== OPS.transform || + fnArray[i + 2] !== OPS.paintImageMaskXObject || + fnArray[i + 3] !== OPS.restore) { + break; // ops don't match + } + i += 4; + } + + // At this point, i is the index of the first op past the last valid + // quartet. + var count = (i - iFirstSave) / 4; + count = handlePaintSolidColorImageMask(iFirstSave, count, fnArray, + argsArray); + if (count < MIN_IMAGES_IN_MASKS_BLOCK) { + return i; + } + + var q; + var isSameImage = false; + var iTransform, transformArgs; + var firstPIMXOArg0 = argsArray[iFirstPIMXO][0]; + if (argsArray[iFirstTransform][1] === 0 && + argsArray[iFirstTransform][2] === 0) { + isSameImage = true; + var firstTransformArg0 = argsArray[iFirstTransform][0]; + var firstTransformArg3 = argsArray[iFirstTransform][3]; + iTransform = iFirstTransform + 4; + var iPIMXO = iFirstPIMXO + 4; + for (q = 1; q < count; q++, iTransform += 4, iPIMXO += 4) { + transformArgs = argsArray[iTransform]; + if (argsArray[iPIMXO][0] !== firstPIMXOArg0 || + transformArgs[0] !== firstTransformArg0 || + transformArgs[1] !== 0 || + transformArgs[2] !== 0 || + transformArgs[3] !== firstTransformArg3) { + if (q < MIN_IMAGES_IN_MASKS_BLOCK) { + isSameImage = false; + } else { + count = q; + } + break; // different image or transform + } + } + } + + if (isSameImage) { + count = Math.min(count, MAX_SAME_IMAGES_IN_MASKS_BLOCK); + var positions = new Float32Array(count * 2); + iTransform = iFirstTransform; + for (q = 0; q < count; q++, iTransform += 4) { + transformArgs = argsArray[iTransform]; + positions[(q << 1)] = transformArgs[4]; + positions[(q << 1) + 1] = transformArgs[5]; + } + + // Replace queue items. + fnArray.splice(iFirstSave, count * 4, OPS.paintImageMaskXObjectRepeat); + argsArray.splice(iFirstSave, count * 4, + [firstPIMXOArg0, firstTransformArg0, firstTransformArg3, positions]); + } else { + count = Math.min(count, MAX_IMAGES_IN_MASKS_BLOCK); + var images = []; + for (q = 0; q < count; q++) { + transformArgs = argsArray[iFirstTransform + (q << 2)]; + var maskParams = argsArray[iFirstPIMXO + (q << 2)][0]; + images.push({ data: maskParams.data, width: maskParams.width, + height: maskParams.height, + transform: transformArgs }); + } + + // Replace queue items. + fnArray.splice(iFirstSave, count * 4, OPS.paintImageMaskXObjectGroup); + argsArray.splice(iFirstSave, count * 4, [images]); + } + + return iFirstSave + 1; + }); + + // This replaces (save, transform, paintImageXObject, restore)+ sequences + // with one paintImageXObjectRepeat operation, if the |transform| and + // |paintImageXObjectRepeat| ops are appropriate. + addState(InitialState, + [OPS.save, OPS.transform, OPS.paintImageXObject, OPS.restore], + function (context) { + var MIN_IMAGES_IN_BLOCK = 3; + var MAX_IMAGES_IN_BLOCK = 1000; + + var fnArray = context.fnArray, argsArray = context.argsArray; + var curr = context.iCurr; + var iFirstSave = curr - 3; + var iFirstTransform = curr - 2; + var iFirstPIXO = curr - 1; + var iFirstRestore = curr; + + if (argsArray[iFirstTransform][1] !== 0 || + argsArray[iFirstTransform][2] !== 0) { + return iFirstRestore + 1; // transform has the wrong form + } + + // Look for the quartets. + var firstPIXOArg0 = argsArray[iFirstPIXO][0]; + var firstTransformArg0 = argsArray[iFirstTransform][0]; + var firstTransformArg3 = argsArray[iFirstTransform][3]; + var i = iFirstSave + 4; + var ii = fnArray.length; + while (i + 3 < ii) { + if (fnArray[i] !== OPS.save || + fnArray[i + 1] !== OPS.transform || + fnArray[i + 2] !== OPS.paintImageXObject || + fnArray[i + 3] !== OPS.restore) { + break; // ops don't match + } + if (argsArray[i + 1][0] !== firstTransformArg0 || + argsArray[i + 1][1] !== 0 || + argsArray[i + 1][2] !== 0 || + argsArray[i + 1][3] !== firstTransformArg3) { + break; // transforms don't match + } + if (argsArray[i + 2][0] !== firstPIXOArg0) { + break; // images don't match + } + i += 4; + } + + // At this point, i is the index of the first op past the last valid + // quartet. + var count = Math.min((i - iFirstSave) / 4, MAX_IMAGES_IN_BLOCK); + if (count < MIN_IMAGES_IN_BLOCK) { + return i; + } + + // Extract the (x,y) positions from all of the matching transforms. + var positions = new Float32Array(count * 2); + var iTransform = iFirstTransform; + for (var q = 0; q < count; q++, iTransform += 4) { + var transformArgs = argsArray[iTransform]; + positions[(q << 1)] = transformArgs[4]; + positions[(q << 1) + 1] = transformArgs[5]; + } + + // Replace queue items. + var args = [firstPIXOArg0, firstTransformArg0, firstTransformArg3, + positions]; + fnArray.splice(iFirstSave, count * 4, OPS.paintImageXObjectRepeat); + argsArray.splice(iFirstSave, count * 4, args); + + return iFirstSave + 1; + }); + + // This replaces (beginText, setFont, setTextMatrix, showText, endText)+ + // sequences with (beginText, setFont, (setTextMatrix, showText)+, endText)+ + // sequences, if the font for each one is the same. + addState(InitialState, + [OPS.beginText, OPS.setFont, OPS.setTextMatrix, OPS.showText, OPS.endText], + function (context) { + var MIN_CHARS_IN_BLOCK = 3; + var MAX_CHARS_IN_BLOCK = 1000; + + var fnArray = context.fnArray, argsArray = context.argsArray; + var curr = context.iCurr; + var iFirstBeginText = curr - 4; + var iFirstSetFont = curr - 3; + var iFirstSetTextMatrix = curr - 2; + var iFirstShowText = curr - 1; + var iFirstEndText = curr; + + // Look for the quintets. + var firstSetFontArg0 = argsArray[iFirstSetFont][0]; + var firstSetFontArg1 = argsArray[iFirstSetFont][1]; + var i = iFirstBeginText + 5; + var ii = fnArray.length; + while (i + 4 < ii) { + if (fnArray[i] !== OPS.beginText || + fnArray[i + 1] !== OPS.setFont || + fnArray[i + 2] !== OPS.setTextMatrix || + fnArray[i + 3] !== OPS.showText || + fnArray[i + 4] !== OPS.endText) { + break; // ops don't match + } + if (argsArray[i + 1][0] !== firstSetFontArg0 || + argsArray[i + 1][1] !== firstSetFontArg1) { + break; // fonts don't match + } + i += 5; + } + + // At this point, i is the index of the first op past the last valid + // quintet. + var count = Math.min(((i - iFirstBeginText) / 5), MAX_CHARS_IN_BLOCK); + if (count < MIN_CHARS_IN_BLOCK) { + return i; + } + + // If the preceding quintet is (, setFont, setTextMatrix, + // showText, endText), include that as well. (E.g. might be + // |dependency|.) + var iFirst = iFirstBeginText; + if (iFirstBeginText >= 4 && + fnArray[iFirstBeginText - 4] === fnArray[iFirstSetFont] && + fnArray[iFirstBeginText - 3] === fnArray[iFirstSetTextMatrix] && + fnArray[iFirstBeginText - 2] === fnArray[iFirstShowText] && + fnArray[iFirstBeginText - 1] === fnArray[iFirstEndText] && + argsArray[iFirstBeginText - 4][0] === firstSetFontArg0 && + argsArray[iFirstBeginText - 4][1] === firstSetFontArg1) { + count++; + iFirst -= 5; + } + + // Remove (endText, beginText, setFont) trios. + var iEndText = iFirst + 4; + for (var q = 1; q < count; q++) { + fnArray.splice(iEndText, 3); + argsArray.splice(iEndText, 3); + iEndText += 2; + } + + return iEndText + 1; + }); + + function QueueOptimizer() {} + + QueueOptimizer.prototype = { + optimize: function QueueOptimizer_optimize(queue) { + var fnArray = queue.fnArray, argsArray = queue.argsArray; + var context = { + iCurr: 0, + fnArray: fnArray, + argsArray: argsArray + }; + var state; + var i = 0, ii = fnArray.length; + while (i < ii) { + state = (state || InitialState)[fnArray[i]]; + if (typeof state === 'function') { // we found some handler + context.iCurr = i; + // state() returns the index of the first non-matching op (if we + // didn't match) or the first op past the modified ops (if we did + // match and replace). + i = state(context); + state = undefined; // reset the state machine + ii = context.fnArray.length; + } else { + i++; + } + } + } + }; + return QueueOptimizer; +})(); + +exports.OperatorList = OperatorList; +exports.PartialEvaluator = PartialEvaluator; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreAnnotation = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream, root.pdfjsCoreColorSpace, + root.pdfjsCoreObj, root.pdfjsCoreEvaluator); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream, + coreColorSpace, coreObj, coreEvaluator) { + +var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType; +var AnnotationFlag = sharedUtil.AnnotationFlag; +var AnnotationType = sharedUtil.AnnotationType; +var OPS = sharedUtil.OPS; +var Util = sharedUtil.Util; +var isArray = sharedUtil.isArray; +var isInt = sharedUtil.isInt; +var isValidUrl = sharedUtil.isValidUrl; +var stringToBytes = sharedUtil.stringToBytes; +var stringToPDFString = sharedUtil.stringToPDFString; +var stringToUTF8String = sharedUtil.stringToUTF8String; +var warn = sharedUtil.warn; +var Dict = corePrimitives.Dict; +var isDict = corePrimitives.isDict; +var isName = corePrimitives.isName; +var Stream = coreStream.Stream; +var ColorSpace = coreColorSpace.ColorSpace; +var ObjectLoader = coreObj.ObjectLoader; +var OperatorList = coreEvaluator.OperatorList; + +/** + * @class + * @alias AnnotationFactory + */ +function AnnotationFactory() {} +AnnotationFactory.prototype = /** @lends AnnotationFactory.prototype */ { + /** + * @param {XRef} xref + * @param {Object} ref + * @returns {Annotation} + */ + create: function AnnotationFactory_create(xref, ref) { + var dict = xref.fetchIfRef(ref); + if (!isDict(dict)) { + return; + } + + // Determine the annotation's subtype. + var subtype = dict.get('Subtype'); + subtype = isName(subtype) ? subtype.name : ''; + + // Return the right annotation object based on the subtype and field type. + var parameters = { + dict: dict, + ref: ref + }; + + switch (subtype) { + case 'Link': + return new LinkAnnotation(parameters); + + case 'Text': + return new TextAnnotation(parameters); + + case 'Widget': + var fieldType = Util.getInheritableProperty(dict, 'FT'); + if (isName(fieldType) && fieldType.name === 'Tx') { + return new TextWidgetAnnotation(parameters); + } + return new WidgetAnnotation(parameters); + + case 'Popup': + return new PopupAnnotation(parameters); + + case 'Highlight': + return new HighlightAnnotation(parameters); + + case 'Underline': + return new UnderlineAnnotation(parameters); + + case 'Squiggly': + return new SquigglyAnnotation(parameters); + + case 'StrikeOut': + return new StrikeOutAnnotation(parameters); + + default: + warn('Unimplemented annotation type "' + subtype + '", ' + + 'falling back to base annotation'); + return new Annotation(parameters); + } + } +}; + +var Annotation = (function AnnotationClosure() { + // 12.5.5: Algorithm: Appearance streams + function getTransformMatrix(rect, bbox, matrix) { + var bounds = Util.getAxialAlignedBoundingBox(bbox, matrix); + var minX = bounds[0]; + var minY = bounds[1]; + var maxX = bounds[2]; + var maxY = bounds[3]; + + if (minX === maxX || minY === maxY) { + // From real-life file, bbox was [0, 0, 0, 0]. In this case, + // just apply the transform for rect + return [1, 0, 0, 1, rect[0], rect[1]]; + } + + var xRatio = (rect[2] - rect[0]) / (maxX - minX); + var yRatio = (rect[3] - rect[1]) / (maxY - minY); + return [ + xRatio, + 0, + 0, + yRatio, + rect[0] - minX * xRatio, + rect[1] - minY * yRatio + ]; + } + + function getDefaultAppearance(dict) { + var appearanceState = dict.get('AP'); + if (!isDict(appearanceState)) { + return; + } + + var appearance; + var appearances = appearanceState.get('N'); + if (isDict(appearances)) { + var as = dict.get('AS'); + if (as && appearances.has(as.name)) { + appearance = appearances.get(as.name); + } + } else { + appearance = appearances; + } + return appearance; + } + + function Annotation(params) { + var dict = params.dict; + + this.setFlags(dict.get('F')); + this.setRectangle(dict.get('Rect')); + this.setColor(dict.get('C')); + this.setBorderStyle(dict); + this.appearance = getDefaultAppearance(dict); + + // Expose public properties using a data object. + this.data = {}; + this.data.id = params.ref.toString(); + this.data.subtype = dict.get('Subtype').name; + this.data.annotationFlags = this.flags; + this.data.rect = this.rectangle; + this.data.color = this.color; + this.data.borderStyle = this.borderStyle; + this.data.hasAppearance = !!this.appearance; + } + + Annotation.prototype = { + /** + * @return {boolean} + */ + get viewable() { + if (this.flags) { + return !this.hasFlag(AnnotationFlag.INVISIBLE) && + !this.hasFlag(AnnotationFlag.HIDDEN) && + !this.hasFlag(AnnotationFlag.NOVIEW); + } + return true; + }, + + /** + * @return {boolean} + */ + get printable() { + if (this.flags) { + return this.hasFlag(AnnotationFlag.PRINT) && + !this.hasFlag(AnnotationFlag.INVISIBLE) && + !this.hasFlag(AnnotationFlag.HIDDEN); + } + return false; + }, + + /** + * Set the flags. + * + * @public + * @memberof Annotation + * @param {number} flags - Unsigned 32-bit integer specifying annotation + * characteristics + * @see {@link shared/util.js} + */ + setFlags: function Annotation_setFlags(flags) { + if (isInt(flags)) { + this.flags = flags; + } else { + this.flags = 0; + } + }, + + /** + * Check if a provided flag is set. + * + * @public + * @memberof Annotation + * @param {number} flag - Hexadecimal representation for an annotation + * characteristic + * @return {boolean} + * @see {@link shared/util.js} + */ + hasFlag: function Annotation_hasFlag(flag) { + if (this.flags) { + return (this.flags & flag) > 0; + } + return false; + }, + + /** + * Set the rectangle. + * + * @public + * @memberof Annotation + * @param {Array} rectangle - The rectangle array with exactly four entries + */ + setRectangle: function Annotation_setRectangle(rectangle) { + if (isArray(rectangle) && rectangle.length === 4) { + this.rectangle = Util.normalizeRect(rectangle); + } else { + this.rectangle = [0, 0, 0, 0]; + } + }, + + /** + * Set the color and take care of color space conversion. + * + * @public + * @memberof Annotation + * @param {Array} color - The color array containing either 0 + * (transparent), 1 (grayscale), 3 (RGB) or + * 4 (CMYK) elements + */ + setColor: function Annotation_setColor(color) { + var rgbColor = new Uint8Array(3); // Black in RGB color space (default) + if (!isArray(color)) { + this.color = rgbColor; + return; + } + + switch (color.length) { + case 0: // Transparent, which we indicate with a null value + this.color = null; + break; + + case 1: // Convert grayscale to RGB + ColorSpace.singletons.gray.getRgbItem(color, 0, rgbColor, 0); + this.color = rgbColor; + break; + + case 3: // Convert RGB percentages to RGB + ColorSpace.singletons.rgb.getRgbItem(color, 0, rgbColor, 0); + this.color = rgbColor; + break; + + case 4: // Convert CMYK to RGB + ColorSpace.singletons.cmyk.getRgbItem(color, 0, rgbColor, 0); + this.color = rgbColor; + break; + + default: + this.color = rgbColor; + break; + } + }, + + /** + * Set the border style (as AnnotationBorderStyle object). + * + * @public + * @memberof Annotation + * @param {Dict} borderStyle - The border style dictionary + */ + setBorderStyle: function Annotation_setBorderStyle(borderStyle) { + this.borderStyle = new AnnotationBorderStyle(); + if (!isDict(borderStyle)) { + return; + } + if (borderStyle.has('BS')) { + var dict = borderStyle.get('BS'); + var dictType; + + if (!dict.has('Type') || (isName(dictType = dict.get('Type')) && + dictType.name === 'Border')) { + this.borderStyle.setWidth(dict.get('W')); + this.borderStyle.setStyle(dict.get('S')); + this.borderStyle.setDashArray(dict.get('D')); + } + } else if (borderStyle.has('Border')) { + var array = borderStyle.get('Border'); + if (isArray(array) && array.length >= 3) { + this.borderStyle.setHorizontalCornerRadius(array[0]); + this.borderStyle.setVerticalCornerRadius(array[1]); + this.borderStyle.setWidth(array[2]); + + if (array.length === 4) { // Dash array available + this.borderStyle.setDashArray(array[3]); + } + } + } else { + // There are no border entries in the dictionary. According to the + // specification, we should draw a solid border of width 1 in that + // case, but Adobe Reader did not implement that part of the + // specification and instead draws no border at all, so we do the same. + // See also https://github.com/mozilla/pdf.js/issues/6179. + this.borderStyle.setWidth(0); + } + }, + + loadResources: function Annotation_loadResources(keys) { + return new Promise(function (resolve, reject) { + this.appearance.dict.getAsync('Resources').then(function (resources) { + if (!resources) { + resolve(); + return; + } + var objectLoader = new ObjectLoader(resources.map, + keys, + resources.xref); + objectLoader.load().then(function() { + resolve(resources); + }, reject); + }, reject); + }.bind(this)); + }, + + getOperatorList: function Annotation_getOperatorList(evaluator, task) { + if (!this.appearance) { + return Promise.resolve(new OperatorList()); + } + + var data = this.data; + var appearanceDict = this.appearance.dict; + var resourcesPromise = this.loadResources([ + 'ExtGState', + 'ColorSpace', + 'Pattern', + 'Shading', + 'XObject', + 'Font' + // ProcSet + // Properties + ]); + var bbox = appearanceDict.get('BBox') || [0, 0, 1, 1]; + var matrix = appearanceDict.get('Matrix') || [1, 0, 0, 1, 0 ,0]; + var transform = getTransformMatrix(data.rect, bbox, matrix); + var self = this; + + return resourcesPromise.then(function(resources) { + var opList = new OperatorList(); + opList.addOp(OPS.beginAnnotation, [data.rect, transform, matrix]); + return evaluator.getOperatorList(self.appearance, task, + resources, opList). + then(function () { + opList.addOp(OPS.endAnnotation, []); + self.appearance.reset(); + return opList; + }); + }); + } + }; + + Annotation.appendToOperatorList = function Annotation_appendToOperatorList( + annotations, opList, partialEvaluator, task, intent) { + var annotationPromises = []; + for (var i = 0, n = annotations.length; i < n; ++i) { + if ((intent === 'display' && annotations[i].viewable) || + (intent === 'print' && annotations[i].printable)) { + annotationPromises.push( + annotations[i].getOperatorList(partialEvaluator, task)); + } + } + return Promise.all(annotationPromises).then(function(operatorLists) { + opList.addOp(OPS.beginAnnotations, []); + for (var i = 0, n = operatorLists.length; i < n; ++i) { + opList.addOpList(operatorLists[i]); + } + opList.addOp(OPS.endAnnotations, []); + }); + }; + + return Annotation; +})(); + +/** + * Contains all data regarding an annotation's border style. + * + * @class + */ +var AnnotationBorderStyle = (function AnnotationBorderStyleClosure() { + /** + * @constructor + * @private + */ + function AnnotationBorderStyle() { + this.width = 1; + this.style = AnnotationBorderStyleType.SOLID; + this.dashArray = [3]; + this.horizontalCornerRadius = 0; + this.verticalCornerRadius = 0; + } + + AnnotationBorderStyle.prototype = { + /** + * Set the width. + * + * @public + * @memberof AnnotationBorderStyle + * @param {integer} width - The width + */ + setWidth: function AnnotationBorderStyle_setWidth(width) { + if (width === (width | 0)) { + this.width = width; + } + }, + + /** + * Set the style. + * + * @public + * @memberof AnnotationBorderStyle + * @param {Object} style - The style object + * @see {@link shared/util.js} + */ + setStyle: function AnnotationBorderStyle_setStyle(style) { + if (!style) { + return; + } + switch (style.name) { + case 'S': + this.style = AnnotationBorderStyleType.SOLID; + break; + + case 'D': + this.style = AnnotationBorderStyleType.DASHED; + break; + + case 'B': + this.style = AnnotationBorderStyleType.BEVELED; + break; + + case 'I': + this.style = AnnotationBorderStyleType.INSET; + break; + + case 'U': + this.style = AnnotationBorderStyleType.UNDERLINE; + break; + + default: + break; + } + }, + + /** + * Set the dash array. + * + * @public + * @memberof AnnotationBorderStyle + * @param {Array} dashArray - The dash array with at least one element + */ + setDashArray: function AnnotationBorderStyle_setDashArray(dashArray) { + // We validate the dash array, but we do not use it because CSS does not + // allow us to change spacing of dashes. For more information, visit + // http://www.w3.org/TR/css3-background/#the-border-style. + if (isArray(dashArray) && dashArray.length > 0) { + // According to the PDF specification: the elements in a dashArray + // shall be numbers that are nonnegative and not all equal to zero. + var isValid = true; + var allZeros = true; + for (var i = 0, len = dashArray.length; i < len; i++) { + var element = dashArray[i]; + var validNumber = (+element >= 0); + if (!validNumber) { + isValid = false; + break; + } else if (element > 0) { + allZeros = false; + } + } + if (isValid && !allZeros) { + this.dashArray = dashArray; + } else { + this.width = 0; // Adobe behavior when the array is invalid. + } + } else if (dashArray) { + this.width = 0; // Adobe behavior when the array is invalid. + } + }, + + /** + * Set the horizontal corner radius (from a Border dictionary). + * + * @public + * @memberof AnnotationBorderStyle + * @param {integer} radius - The horizontal corner radius + */ + setHorizontalCornerRadius: + function AnnotationBorderStyle_setHorizontalCornerRadius(radius) { + if (radius === (radius | 0)) { + this.horizontalCornerRadius = radius; + } + }, + + /** + * Set the vertical corner radius (from a Border dictionary). + * + * @public + * @memberof AnnotationBorderStyle + * @param {integer} radius - The vertical corner radius + */ + setVerticalCornerRadius: + function AnnotationBorderStyle_setVerticalCornerRadius(radius) { + if (radius === (radius | 0)) { + this.verticalCornerRadius = radius; + } + } + }; + + return AnnotationBorderStyle; +})(); + +var WidgetAnnotation = (function WidgetAnnotationClosure() { + function WidgetAnnotation(params) { + Annotation.call(this, params); + + var dict = params.dict; + var data = this.data; + + data.annotationType = AnnotationType.WIDGET; + data.fieldValue = stringToPDFString( + Util.getInheritableProperty(dict, 'V') || ''); + data.alternativeText = stringToPDFString(dict.get('TU') || ''); + data.defaultAppearance = Util.getInheritableProperty(dict, 'DA') || ''; + var fieldType = Util.getInheritableProperty(dict, 'FT'); + data.fieldType = isName(fieldType) ? fieldType.name : ''; + data.fieldFlags = Util.getInheritableProperty(dict, 'Ff') || 0; + this.fieldResources = Util.getInheritableProperty(dict, 'DR') || Dict.empty; + + // Hide unsupported Widget signatures. + if (data.fieldType === 'Sig') { + warn('unimplemented annotation type: Widget signature'); + this.setFlags(AnnotationFlag.HIDDEN); + } + + // Building the full field name by collecting the field and + // its ancestors 'T' data and joining them using '.'. + var fieldName = []; + var namedItem = dict; + var ref = params.ref; + while (namedItem) { + var parent = namedItem.get('Parent'); + var parentRef = namedItem.getRaw('Parent'); + var name = namedItem.get('T'); + if (name) { + fieldName.unshift(stringToPDFString(name)); + } else if (parent && ref) { + // The field name is absent, that means more than one field + // with the same name may exist. Replacing the empty name + // with the '`' plus index in the parent's 'Kids' array. + // This is not in the PDF spec but necessary to id the + // the input controls. + var kids = parent.get('Kids'); + var j, jj; + for (j = 0, jj = kids.length; j < jj; j++) { + var kidRef = kids[j]; + if (kidRef.num === ref.num && kidRef.gen === ref.gen) { + break; + } + } + fieldName.unshift('`' + j); + } + namedItem = parent; + ref = parentRef; + } + data.fullName = fieldName.join('.'); + } + + Util.inherit(WidgetAnnotation, Annotation, {}); + + return WidgetAnnotation; +})(); + +var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() { + function TextWidgetAnnotation(params) { + WidgetAnnotation.call(this, params); + + this.data.textAlignment = Util.getInheritableProperty(params.dict, 'Q'); + this.data.hasHtml = !this.data.hasAppearance && !!this.data.fieldValue; + } + + Util.inherit(TextWidgetAnnotation, WidgetAnnotation, { + getOperatorList: function TextWidgetAnnotation_getOperatorList(evaluator, + task) { + if (this.appearance) { + return Annotation.prototype.getOperatorList.call(this, evaluator, task); + } + + var opList = new OperatorList(); + var data = this.data; + + // Even if there is an appearance stream, ignore it. This is the + // behaviour used by Adobe Reader. + if (!data.defaultAppearance) { + return Promise.resolve(opList); + } + + var stream = new Stream(stringToBytes(data.defaultAppearance)); + return evaluator.getOperatorList(stream, task, + this.fieldResources, opList). + then(function () { + return opList; + }); + } + }); + + return TextWidgetAnnotation; +})(); + +var TextAnnotation = (function TextAnnotationClosure() { + var DEFAULT_ICON_SIZE = 22; // px + + function TextAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.TEXT; + this.data.hasHtml = true; + + var dict = parameters.dict; + if (this.data.hasAppearance) { + this.data.name = 'NoIcon'; + } else { + this.data.rect[1] = this.data.rect[3] - DEFAULT_ICON_SIZE; + this.data.rect[2] = this.data.rect[0] + DEFAULT_ICON_SIZE; + this.data.name = dict.has('Name') ? dict.get('Name').name : 'Note'; + } + + if (!dict.has('C')) { + // Fall back to the default background color. + this.data.color = null; + } + + this.data.hasPopup = dict.has('Popup'); + if (!this.data.hasPopup) { + // There is no associated Popup annotation, so the Text annotation + // must create its own popup. + this.data.title = stringToPDFString(dict.get('T') || ''); + this.data.contents = stringToPDFString(dict.get('Contents') || ''); + this.data.hasHtml = (this.data.title || this.data.contents); + } + } + + Util.inherit(TextAnnotation, Annotation, {}); + + return TextAnnotation; +})(); + +var LinkAnnotation = (function LinkAnnotationClosure() { + function LinkAnnotation(params) { + Annotation.call(this, params); + + var dict = params.dict; + var data = this.data; + data.annotationType = AnnotationType.LINK; + data.hasHtml = true; + + var action = dict.get('A'); + if (action && isDict(action)) { + var linkType = action.get('S').name; + if (linkType === 'URI') { + var url = action.get('URI'); + if (isName(url)) { + // Some bad PDFs do not put parentheses around relative URLs. + url = '/' + url.name; + } else if (url) { + url = addDefaultProtocolToUrl(url); + } + // TODO: pdf spec mentions urls can be relative to a Base + // entry in the dictionary. + if (!isValidUrl(url, false)) { + url = ''; + } + // According to ISO 32000-1:2008, section 12.6.4.7, + // URI should to be encoded in 7-bit ASCII. + // Some bad PDFs may have URIs in UTF-8 encoding, see Bugzilla 1122280. + try { + data.url = stringToUTF8String(url); + } catch (e) { + // Fall back to a simple copy. + data.url = url; + } + } else if (linkType === 'GoTo') { + data.dest = action.get('D'); + } else if (linkType === 'GoToR') { + var urlDict = action.get('F'); + if (isDict(urlDict)) { + // We assume that the 'url' is a Filspec dictionary + // and fetch the url without checking any further + url = urlDict.get('F') || ''; + } + + // TODO: pdf reference says that GoToR + // can also have 'NewWindow' attribute + if (!isValidUrl(url, false)) { + url = ''; + } + data.url = url; + data.dest = action.get('D'); + } else if (linkType === 'Named') { + data.action = action.get('N').name; + } else { + warn('unrecognized link type: ' + linkType); + } + } else if (dict.has('Dest')) { + // simple destination link + var dest = dict.get('Dest'); + data.dest = isName(dest) ? dest.name : dest; + } + } + + // Lets URLs beginning with 'www.' default to using the 'http://' protocol. + function addDefaultProtocolToUrl(url) { + if (url && url.indexOf('www.') === 0) { + return ('http://' + url); + } + return url; + } + + Util.inherit(LinkAnnotation, Annotation, {}); + + return LinkAnnotation; +})(); + +var PopupAnnotation = (function PopupAnnotationClosure() { + function PopupAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.POPUP; + + var dict = parameters.dict; + var parentItem = dict.get('Parent'); + if (!parentItem) { + warn('Popup annotation has a missing or invalid parent annotation.'); + return; + } + + this.data.parentId = dict.getRaw('Parent').toString(); + this.data.title = stringToPDFString(parentItem.get('T') || ''); + this.data.contents = stringToPDFString(parentItem.get('Contents') || ''); + + if (!parentItem.has('C')) { + // Fall back to the default background color. + this.data.color = null; + } else { + this.setColor(parentItem.get('C')); + this.data.color = this.color; + } + + this.data.hasHtml = (this.data.title || this.data.contents); + } + + Util.inherit(PopupAnnotation, Annotation, {}); + + return PopupAnnotation; +})(); + +var HighlightAnnotation = (function HighlightAnnotationClosure() { + function HighlightAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.HIGHLIGHT; + this.data.hasHtml = true; + + // PDF viewers completely ignore any border styles. + this.data.borderStyle.setWidth(0); + } + + Util.inherit(HighlightAnnotation, Annotation, {}); + + return HighlightAnnotation; +})(); + +var UnderlineAnnotation = (function UnderlineAnnotationClosure() { + function UnderlineAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.UNDERLINE; + this.data.hasHtml = true; + + // PDF viewers completely ignore any border styles. + this.data.borderStyle.setWidth(0); + } + + Util.inherit(UnderlineAnnotation, Annotation, {}); + + return UnderlineAnnotation; +})(); + +var SquigglyAnnotation = (function SquigglyAnnotationClosure() { + function SquigglyAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.SQUIGGLY; + this.data.hasHtml = true; + + // PDF viewers completely ignore any border styles. + this.data.borderStyle.setWidth(0); + } + + Util.inherit(SquigglyAnnotation, Annotation, {}); + + return SquigglyAnnotation; +})(); + +var StrikeOutAnnotation = (function StrikeOutAnnotationClosure() { + function StrikeOutAnnotation(parameters) { + Annotation.call(this, parameters); + + this.data.annotationType = AnnotationType.STRIKEOUT; + this.data.hasHtml = true; + + // PDF viewers completely ignore any border styles. + this.data.borderStyle.setWidth(0); + } + + Util.inherit(StrikeOutAnnotation, Annotation, {}); + + return StrikeOutAnnotation; +})(); + +exports.Annotation = Annotation; +exports.AnnotationBorderStyle = AnnotationBorderStyle; +exports.AnnotationFactory = AnnotationFactory; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreDocument = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCoreStream, + root.pdfjsCoreObj, root.pdfjsCoreParser, root.pdfjsCoreCrypto, + root.pdfjsCoreEvaluator, root.pdfjsCoreAnnotation); + } +}(this, function (exports, sharedUtil, corePrimitives, coreStream, coreObj, + coreParser, coreCrypto, coreEvaluator, coreAnnotation) { + +var MissingDataException = sharedUtil.MissingDataException; +var Util = sharedUtil.Util; +var assert = sharedUtil.assert; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isArray = sharedUtil.isArray; +var isArrayBuffer = sharedUtil.isArrayBuffer; +var isString = sharedUtil.isString; +var shadow = sharedUtil.shadow; +var stringToBytes = sharedUtil.stringToBytes; +var stringToPDFString = sharedUtil.stringToPDFString; +var warn = sharedUtil.warn; +var Dict = corePrimitives.Dict; +var isDict = corePrimitives.isDict; +var isName = corePrimitives.isName; +var isStream = corePrimitives.isStream; +var NullStream = coreStream.NullStream; +var Stream = coreStream.Stream; +var StreamsSequenceStream = coreStream.StreamsSequenceStream; +var Catalog = coreObj.Catalog; +var ObjectLoader = coreObj.ObjectLoader; +var XRef = coreObj.XRef; +var Lexer = coreParser.Lexer; +var Linearization = coreParser.Linearization; +var calculateMD5 = coreCrypto.calculateMD5; +var OperatorList = coreEvaluator.OperatorList; +var PartialEvaluator = coreEvaluator.PartialEvaluator; +var Annotation = coreAnnotation.Annotation; +var AnnotationFactory = coreAnnotation.AnnotationFactory; + +var Page = (function PageClosure() { + + var LETTER_SIZE_MEDIABOX = [0, 0, 612, 792]; + + function Page(pdfManager, xref, pageIndex, pageDict, ref, fontCache) { + this.pdfManager = pdfManager; + this.pageIndex = pageIndex; + this.pageDict = pageDict; + this.xref = xref; + this.ref = ref; + this.fontCache = fontCache; + this.idCounters = { + obj: 0 + }; + this.resourcesPromise = null; + } + + Page.prototype = { + getPageProp: function Page_getPageProp(key) { + return this.pageDict.get(key); + }, + + getInheritedPageProp: function Page_getInheritedPageProp(key) { + var dict = this.pageDict, valueArray = null, loopCount = 0; + var MAX_LOOP_COUNT = 100; + // Always walk up the entire parent chain, to be able to find + // e.g. \Resources placed on multiple levels of the tree. + while (dict) { + var value = dict.get(key); + if (value) { + if (!valueArray) { + valueArray = []; + } + valueArray.push(value); + } + if (++loopCount > MAX_LOOP_COUNT) { + warn('Page_getInheritedPageProp: maximum loop count exceeded.'); + break; + } + dict = dict.get('Parent'); + } + if (!valueArray) { + return Dict.empty; + } + if (valueArray.length === 1 || !isDict(valueArray[0]) || + loopCount > MAX_LOOP_COUNT) { + return valueArray[0]; + } + return Dict.merge(this.xref, valueArray); + }, + + get content() { + return this.getPageProp('Contents'); + }, + + get resources() { + // For robustness: The spec states that a \Resources entry has to be + // present, but can be empty. Some document omit it still, in this case + // we return an empty dictionary. + return shadow(this, 'resources', this.getInheritedPageProp('Resources')); + }, + + get mediaBox() { + var obj = this.getInheritedPageProp('MediaBox'); + // Reset invalid media box to letter size. + if (!isArray(obj) || obj.length !== 4) { + obj = LETTER_SIZE_MEDIABOX; + } + return shadow(this, 'mediaBox', obj); + }, + + get view() { + var mediaBox = this.mediaBox; + var cropBox = this.getInheritedPageProp('CropBox'); + if (!isArray(cropBox) || cropBox.length !== 4) { + return shadow(this, 'view', mediaBox); + } + + // From the spec, 6th ed., p.963: + // "The crop, bleed, trim, and art boxes should not ordinarily + // extend beyond the boundaries of the media box. If they do, they are + // effectively reduced to their intersection with the media box." + cropBox = Util.intersect(cropBox, mediaBox); + if (!cropBox) { + return shadow(this, 'view', mediaBox); + } + return shadow(this, 'view', cropBox); + }, + + get rotate() { + var rotate = this.getInheritedPageProp('Rotate') || 0; + // Normalize rotation so it's a multiple of 90 and between 0 and 270 + if (rotate % 90 !== 0) { + rotate = 0; + } else if (rotate >= 360) { + rotate = rotate % 360; + } else if (rotate < 0) { + // The spec doesn't cover negatives, assume its counterclockwise + // rotation. The following is the other implementation of modulo. + rotate = ((rotate % 360) + 360) % 360; + } + return shadow(this, 'rotate', rotate); + }, + + getContentStream: function Page_getContentStream() { + var content = this.content; + var stream; + if (isArray(content)) { + // fetching items + var xref = this.xref; + var i, n = content.length; + var streams = []; + for (i = 0; i < n; ++i) { + streams.push(xref.fetchIfRef(content[i])); + } + stream = new StreamsSequenceStream(streams); + } else if (isStream(content)) { + stream = content; + } else { + // replacing non-existent page content with empty one + stream = new NullStream(); + } + return stream; + }, + + loadResources: function Page_loadResources(keys) { + if (!this.resourcesPromise) { + // TODO: add async getInheritedPageProp and remove this. + this.resourcesPromise = this.pdfManager.ensure(this, 'resources'); + } + return this.resourcesPromise.then(function resourceSuccess() { + var objectLoader = new ObjectLoader(this.resources.map, + keys, + this.xref); + return objectLoader.load(); + }.bind(this)); + }, + + getOperatorList: function Page_getOperatorList(handler, task, intent) { + var self = this; + + var pdfManager = this.pdfManager; + var contentStreamPromise = pdfManager.ensure(this, 'getContentStream', + []); + var resourcesPromise = this.loadResources([ + 'ExtGState', + 'ColorSpace', + 'Pattern', + 'Shading', + 'XObject', + 'Font' + // ProcSet + // Properties + ]); + + var partialEvaluator = new PartialEvaluator(pdfManager, this.xref, + handler, this.pageIndex, + 'p' + this.pageIndex + '_', + this.idCounters, + this.fontCache); + + var dataPromises = Promise.all([contentStreamPromise, resourcesPromise]); + var pageListPromise = dataPromises.then(function(data) { + var contentStream = data[0]; + var opList = new OperatorList(intent, handler, self.pageIndex); + + handler.send('StartRenderPage', { + transparency: partialEvaluator.hasBlendModes(self.resources), + pageIndex: self.pageIndex, + intent: intent + }); + return partialEvaluator.getOperatorList(contentStream, task, + self.resources, opList).then(function () { + return opList; + }); + }); + + var annotationsPromise = pdfManager.ensure(this, 'annotations'); + return Promise.all([pageListPromise, annotationsPromise]).then( + function(datas) { + var pageOpList = datas[0]; + var annotations = datas[1]; + + if (annotations.length === 0) { + pageOpList.flush(true); + return pageOpList; + } + + var annotationsReadyPromise = Annotation.appendToOperatorList( + annotations, pageOpList, partialEvaluator, task, intent); + return annotationsReadyPromise.then(function () { + pageOpList.flush(true); + return pageOpList; + }); + }); + }, + + extractTextContent: function Page_extractTextContent(task, + normalizeWhitespace) { + var handler = { + on: function nullHandlerOn() {}, + send: function nullHandlerSend() {} + }; + + var self = this; + + var pdfManager = this.pdfManager; + var contentStreamPromise = pdfManager.ensure(this, 'getContentStream', + []); + + var resourcesPromise = this.loadResources([ + 'ExtGState', + 'XObject', + 'Font' + ]); + + var dataPromises = Promise.all([contentStreamPromise, + resourcesPromise]); + return dataPromises.then(function(data) { + var contentStream = data[0]; + var partialEvaluator = new PartialEvaluator(pdfManager, self.xref, + handler, self.pageIndex, + 'p' + self.pageIndex + '_', + self.idCounters, + self.fontCache); + + return partialEvaluator.getTextContent(contentStream, + task, + self.resources, + /* stateManager = */ null, + normalizeWhitespace); + }); + }, + + getAnnotationsData: function Page_getAnnotationsData(intent) { + var annotations = this.annotations; + var annotationsData = []; + for (var i = 0, n = annotations.length; i < n; ++i) { + if (intent) { + if (!(intent === 'display' && annotations[i].viewable) && + !(intent === 'print' && annotations[i].printable)) { + continue; + } + } + annotationsData.push(annotations[i].data); + } + return annotationsData; + }, + + get annotations() { + var annotations = []; + var annotationRefs = this.getInheritedPageProp('Annots') || []; + var annotationFactory = new AnnotationFactory(); + for (var i = 0, n = annotationRefs.length; i < n; ++i) { + var annotationRef = annotationRefs[i]; + var annotation = annotationFactory.create(this.xref, annotationRef); + if (annotation) { + annotations.push(annotation); + } + } + return shadow(this, 'annotations', annotations); + } + }; + + return Page; +})(); + +/** + * The `PDFDocument` holds all the data of the PDF file. Compared to the + * `PDFDoc`, this one doesn't have any job management code. + * Right now there exists one PDFDocument on the main thread + one object + * for each worker. If there is no worker support enabled, there are two + * `PDFDocument` objects on the main thread created. + */ +var PDFDocument = (function PDFDocumentClosure() { + var FINGERPRINT_FIRST_BYTES = 1024; + var EMPTY_FINGERPRINT = '\x00\x00\x00\x00\x00\x00\x00' + + '\x00\x00\x00\x00\x00\x00\x00\x00\x00'; + + function PDFDocument(pdfManager, arg, password) { + if (isStream(arg)) { + init.call(this, pdfManager, arg, password); + } else if (isArrayBuffer(arg)) { + init.call(this, pdfManager, new Stream(arg), password); + } else { + error('PDFDocument: Unknown argument type'); + } + } + + function init(pdfManager, stream, password) { + assert(stream.length > 0, 'stream must have data'); + this.pdfManager = pdfManager; + this.stream = stream; + var xref = new XRef(this.stream, password, pdfManager); + this.xref = xref; + } + + function find(stream, needle, limit, backwards) { + var pos = stream.pos; + var end = stream.end; + var strBuf = []; + if (pos + limit > end) { + limit = end - pos; + } + for (var n = 0; n < limit; ++n) { + strBuf.push(String.fromCharCode(stream.getByte())); + } + var str = strBuf.join(''); + stream.pos = pos; + var index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle); + if (index === -1) { + return false; /* not found */ + } + stream.pos += index; + return true; /* found */ + } + + var DocumentInfoValidators = { + get entries() { + // Lazily build this since all the validation functions below are not + // defined until after this file loads. + return shadow(this, 'entries', { + Title: isString, + Author: isString, + Subject: isString, + Keywords: isString, + Creator: isString, + Producer: isString, + CreationDate: isString, + ModDate: isString, + Trapped: isName + }); + } + }; + + PDFDocument.prototype = { + parse: function PDFDocument_parse(recoveryMode) { + this.setup(recoveryMode); + var version = this.catalog.catDict.get('Version'); + if (isName(version)) { + this.pdfFormatVersion = version.name; + } + try { + // checking if AcroForm is present + this.acroForm = this.catalog.catDict.get('AcroForm'); + if (this.acroForm) { + this.xfa = this.acroForm.get('XFA'); + var fields = this.acroForm.get('Fields'); + if ((!fields || !isArray(fields) || fields.length === 0) && + !this.xfa) { + // no fields and no XFA -- not a form (?) + this.acroForm = null; + } + } + } catch (ex) { + info('Something wrong with AcroForm entry'); + this.acroForm = null; + } + }, + + get linearization() { + var linearization = null; + if (this.stream.length) { + try { + linearization = Linearization.create(this.stream); + } catch (err) { + if (err instanceof MissingDataException) { + throw err; + } + info(err); + } + } + // shadow the prototype getter with a data property + return shadow(this, 'linearization', linearization); + }, + get startXRef() { + var stream = this.stream; + var startXRef = 0; + var linearization = this.linearization; + if (linearization) { + // Find end of first obj. + stream.reset(); + if (find(stream, 'endobj', 1024)) { + startXRef = stream.pos + 6; + } + } else { + // Find startxref by jumping backward from the end of the file. + var step = 1024; + var found = false, pos = stream.end; + while (!found && pos > 0) { + pos -= step - 'startxref'.length; + if (pos < 0) { + pos = 0; + } + stream.pos = pos; + found = find(stream, 'startxref', step, true); + } + if (found) { + stream.skip(9); + var ch; + do { + ch = stream.getByte(); + } while (Lexer.isSpace(ch)); + var str = ''; + while (ch >= 0x20 && ch <= 0x39) { // < '9' + str += String.fromCharCode(ch); + ch = stream.getByte(); + } + startXRef = parseInt(str, 10); + if (isNaN(startXRef)) { + startXRef = 0; + } + } + } + // shadow the prototype getter with a data property + return shadow(this, 'startXRef', startXRef); + }, + get mainXRefEntriesOffset() { + var mainXRefEntriesOffset = 0; + var linearization = this.linearization; + if (linearization) { + mainXRefEntriesOffset = linearization.mainXRefEntriesOffset; + } + // shadow the prototype getter with a data property + return shadow(this, 'mainXRefEntriesOffset', mainXRefEntriesOffset); + }, + // Find the header, remove leading garbage and setup the stream + // starting from the header. + checkHeader: function PDFDocument_checkHeader() { + var stream = this.stream; + stream.reset(); + if (find(stream, '%PDF-', 1024)) { + // Found the header, trim off any garbage before it. + stream.moveStart(); + // Reading file format version + var MAX_VERSION_LENGTH = 12; + var version = '', ch; + while ((ch = stream.getByte()) > 0x20) { // SPACE + if (version.length >= MAX_VERSION_LENGTH) { + break; + } + version += String.fromCharCode(ch); + } + if (!this.pdfFormatVersion) { + // removing "%PDF-"-prefix + this.pdfFormatVersion = version.substring(5); + } + return; + } + // May not be a PDF file, continue anyway. + }, + parseStartXRef: function PDFDocument_parseStartXRef() { + var startXRef = this.startXRef; + this.xref.setStartXRef(startXRef); + }, + setup: function PDFDocument_setup(recoveryMode) { + this.xref.parse(recoveryMode); + var self = this; + var pageFactory = { + createPage: function (pageIndex, dict, ref, fontCache) { + return new Page(self.pdfManager, self.xref, pageIndex, dict, ref, + fontCache); + } + }; + this.catalog = new Catalog(this.pdfManager, this.xref, pageFactory); + }, + get numPages() { + var linearization = this.linearization; + var num = linearization ? linearization.numPages : this.catalog.numPages; + // shadow the prototype getter + return shadow(this, 'numPages', num); + }, + get documentInfo() { + var docInfo = { + PDFFormatVersion: this.pdfFormatVersion, + IsAcroFormPresent: !!this.acroForm, + IsXFAPresent: !!this.xfa + }; + var infoDict; + try { + infoDict = this.xref.trailer.get('Info'); + } catch (err) { + info('The document information dictionary is invalid.'); + } + if (infoDict) { + var validEntries = DocumentInfoValidators.entries; + // Only fill the document info with valid entries from the spec. + for (var key in validEntries) { + if (infoDict.has(key)) { + var value = infoDict.get(key); + // Make sure the value conforms to the spec. + if (validEntries[key](value)) { + docInfo[key] = (typeof value !== 'string' ? + value : stringToPDFString(value)); + } else { + info('Bad value in document info for "' + key + '"'); + } + } + } + } + return shadow(this, 'documentInfo', docInfo); + }, + get fingerprint() { + var xref = this.xref, hash, fileID = ''; + var idArray = xref.trailer.get('ID'); + + if (idArray && isArray(idArray) && idArray[0] && isString(idArray[0]) && + idArray[0] !== EMPTY_FINGERPRINT) { + hash = stringToBytes(idArray[0]); + } else { + if (this.stream.ensureRange) { + this.stream.ensureRange(0, + Math.min(FINGERPRINT_FIRST_BYTES, this.stream.end)); + } + hash = calculateMD5(this.stream.bytes.subarray(0, + FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES); + } + + for (var i = 0, n = hash.length; i < n; i++) { + var hex = hash[i].toString(16); + fileID += hex.length === 1 ? '0' + hex : hex; + } + + return shadow(this, 'fingerprint', fileID); + }, + + getPage: function PDFDocument_getPage(pageIndex) { + return this.catalog.getPage(pageIndex); + }, + + cleanup: function PDFDocument_cleanup() { + return this.catalog.cleanup(); + } + }; + + return PDFDocument; +})(); + +exports.Page = Page; +exports.PDFDocument = PDFDocument; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCorePdfManager = {}), root.pdfjsSharedUtil, + root.pdfjsCoreStream, root.pdfjsCoreChunkedStream, + root.pdfjsCoreDocument); + } +}(this, function (exports, sharedUtil, coreStream, coreChunkedStream, + coreDocument) { + +var NotImplementedException = sharedUtil.NotImplementedException; +var MissingDataException = sharedUtil.MissingDataException; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var Util = sharedUtil.Util; +var Stream = coreStream.Stream; +var ChunkedStreamManager = coreChunkedStream.ChunkedStreamManager; +var PDFDocument = coreDocument.PDFDocument; + +var BasePdfManager = (function BasePdfManagerClosure() { + function BasePdfManager() { + throw new Error('Cannot initialize BaseManagerManager'); + } + + BasePdfManager.prototype = { + get docId() { + return this._docId; + }, + + onLoadedStream: function BasePdfManager_onLoadedStream() { + throw new NotImplementedException(); + }, + + ensureDoc: function BasePdfManager_ensureDoc(prop, args) { + return this.ensure(this.pdfDocument, prop, args); + }, + + ensureXRef: function BasePdfManager_ensureXRef(prop, args) { + return this.ensure(this.pdfDocument.xref, prop, args); + }, + + ensureCatalog: function BasePdfManager_ensureCatalog(prop, args) { + return this.ensure(this.pdfDocument.catalog, prop, args); + }, + + getPage: function BasePdfManager_getPage(pageIndex) { + return this.pdfDocument.getPage(pageIndex); + }, + + cleanup: function BasePdfManager_cleanup() { + return this.pdfDocument.cleanup(); + }, + + ensure: function BasePdfManager_ensure(obj, prop, args) { + return new NotImplementedException(); + }, + + requestRange: function BasePdfManager_requestRange(begin, end) { + return new NotImplementedException(); + }, + + requestLoadedStream: function BasePdfManager_requestLoadedStream() { + return new NotImplementedException(); + }, + + sendProgressiveData: function BasePdfManager_sendProgressiveData(chunk) { + return new NotImplementedException(); + }, + + updatePassword: function BasePdfManager_updatePassword(password) { + this.pdfDocument.xref.password = this.password = password; + if (this._passwordChangedCapability) { + this._passwordChangedCapability.resolve(); + } + }, + + passwordChanged: function BasePdfManager_passwordChanged() { + this._passwordChangedCapability = createPromiseCapability(); + return this._passwordChangedCapability.promise; + }, + + terminate: function BasePdfManager_terminate() { + return new NotImplementedException(); + } + }; + + return BasePdfManager; +})(); + +var LocalPdfManager = (function LocalPdfManagerClosure() { + function LocalPdfManager(docId, data, password) { + this._docId = docId; + var stream = new Stream(data); + this.pdfDocument = new PDFDocument(this, stream, password); + this._loadedStreamCapability = createPromiseCapability(); + this._loadedStreamCapability.resolve(stream); + } + + Util.inherit(LocalPdfManager, BasePdfManager, { + ensure: function LocalPdfManager_ensure(obj, prop, args) { + return new Promise(function (resolve, reject) { + try { + var value = obj[prop]; + var result; + if (typeof value === 'function') { + result = value.apply(obj, args); + } else { + result = value; + } + resolve(result); + } catch (e) { + reject(e); + } + }); + }, + + requestRange: function LocalPdfManager_requestRange(begin, end) { + return Promise.resolve(); + }, + + requestLoadedStream: function LocalPdfManager_requestLoadedStream() { + return; + }, + + onLoadedStream: function LocalPdfManager_onLoadedStream() { + return this._loadedStreamCapability.promise; + }, + + terminate: function LocalPdfManager_terminate() { + return; + } + }); + + return LocalPdfManager; +})(); + +var NetworkPdfManager = (function NetworkPdfManagerClosure() { + function NetworkPdfManager(docId, args, msgHandler) { + this._docId = docId; + this.msgHandler = msgHandler; + + var params = { + msgHandler: msgHandler, + httpHeaders: args.httpHeaders, + withCredentials: args.withCredentials, + chunkedViewerLoading: args.chunkedViewerLoading, + disableAutoFetch: args.disableAutoFetch, + initialData: args.initialData + }; + this.streamManager = new ChunkedStreamManager(args.length, + args.rangeChunkSize, + args.url, params); + this.pdfDocument = new PDFDocument(this, this.streamManager.getStream(), + args.password); + } + + Util.inherit(NetworkPdfManager, BasePdfManager, { + ensure: function NetworkPdfManager_ensure(obj, prop, args) { + var pdfManager = this; + + return new Promise(function (resolve, reject) { + function ensureHelper() { + try { + var result; + var value = obj[prop]; + if (typeof value === 'function') { + result = value.apply(obj, args); + } else { + result = value; + } + resolve(result); + } catch(e) { + if (!(e instanceof MissingDataException)) { + reject(e); + return; + } + pdfManager.streamManager.requestRange(e.begin, e.end). + then(ensureHelper, reject); + } + } + + ensureHelper(); + }); + }, + + requestRange: function NetworkPdfManager_requestRange(begin, end) { + return this.streamManager.requestRange(begin, end); + }, + + requestLoadedStream: function NetworkPdfManager_requestLoadedStream() { + this.streamManager.requestAllChunks(); + }, + + sendProgressiveData: + function NetworkPdfManager_sendProgressiveData(chunk) { + this.streamManager.onReceiveData({ chunk: chunk }); + }, + + onLoadedStream: function NetworkPdfManager_onLoadedStream() { + return this.streamManager.onLoadedStream(); + }, + + terminate: function NetworkPdfManager_terminate() { + this.streamManager.abort(); + } + }); + + return NetworkPdfManager; +})(); + +exports.LocalPdfManager = LocalPdfManager; +exports.NetworkPdfManager = NetworkPdfManager; +})); + + +(function (root, factory) { + { + factory((root.pdfjsCoreWorker = {}), root.pdfjsSharedUtil, + root.pdfjsCorePrimitives, root.pdfjsCorePdfManager, + root.pdfjsSharedGlobal); + } +}(this, function (exports, sharedUtil, corePrimitives, corePdfManager, + sharedGlobal) { + +var UNSUPPORTED_FEATURES = sharedUtil.UNSUPPORTED_FEATURES; +var InvalidPDFException = sharedUtil.InvalidPDFException; +var MessageHandler = sharedUtil.MessageHandler; +var MissingPDFException = sharedUtil.MissingPDFException; +var UnexpectedResponseException = sharedUtil.UnexpectedResponseException; +var PasswordException = sharedUtil.PasswordException; +var PasswordResponses = sharedUtil.PasswordResponses; +var UnknownErrorException = sharedUtil.UnknownErrorException; +var XRefParseException = sharedUtil.XRefParseException; +var createPromiseCapability = sharedUtil.createPromiseCapability; +var error = sharedUtil.error; +var info = sharedUtil.info; +var isInt = sharedUtil.isInt; +var warn = sharedUtil.warn; +var Ref = corePrimitives.Ref; +var LocalPdfManager = corePdfManager.LocalPdfManager; +var NetworkPdfManager = corePdfManager.NetworkPdfManager; +var globalScope = sharedGlobal.globalScope; +var PDFJS = sharedGlobal.PDFJS; + +var WorkerTask = (function WorkerTaskClosure() { + function WorkerTask(name) { + this.name = name; + this.terminated = false; + this._capability = createPromiseCapability(); + } + + WorkerTask.prototype = { + get finished() { + return this._capability.promise; + }, + + finish: function () { + this._capability.resolve(); + }, + + terminate: function () { + this.terminated = true; + }, + + ensureNotTerminated: function () { + if (this.terminated) { + throw new Error('Worker task was terminated'); + } + } + }; + + return WorkerTask; +})(); + +var WorkerMessageHandler = PDFJS.WorkerMessageHandler = { + setup: function wphSetup(handler, port) { + var testMessageProcessed = false; + handler.on('test', function wphSetupTest(data) { + if (testMessageProcessed) { + return; // we already processed 'test' message once + } + testMessageProcessed = true; + + // check if Uint8Array can be sent to worker + if (!(data instanceof Uint8Array)) { + handler.send('test', 'main', false); + return; + } + // making sure postMessage transfers are working + var supportTransfers = data[0] === 255; + handler.postMessageTransfers = supportTransfers; + // check if the response property is supported by xhr + var xhr = new XMLHttpRequest(); + var responseExists = 'response' in xhr; + // check if the property is actually implemented + try { + var dummy = xhr.responseType; + } catch (e) { + responseExists = false; + } + if (!responseExists) { + handler.send('test', false); + return; + } + handler.send('test', { + supportTypedArray: true, + supportTransfers: supportTransfers + }); + }); + + handler.on('GetDocRequest', function wphSetupDoc(data) { + return WorkerMessageHandler.createDocumentHandler(data, port); + }); + }, + createDocumentHandler: function wphCreateDocumentHandler(docParams, port) { + // This context is actually holds references on pdfManager and handler, + // until the latter is destroyed. + var pdfManager; + var terminated = false; + var cancelXHRs = null; + var WorkerTasks = []; + + var docId = docParams.docId; + var workerHandlerName = docParams.docId + '_worker'; + var handler = new MessageHandler(workerHandlerName, docId, port); + + function ensureNotTerminated() { + if (terminated) { + throw new Error('Worker was terminated'); + } + } + + function startWorkerTask(task) { + WorkerTasks.push(task); + } + + function finishWorkerTask(task) { + task.finish(); + var i = WorkerTasks.indexOf(task); + WorkerTasks.splice(i, 1); + } + + function loadDocument(recoveryMode) { + var loadDocumentCapability = createPromiseCapability(); + + var parseSuccess = function parseSuccess() { + var numPagesPromise = pdfManager.ensureDoc('numPages'); + var fingerprintPromise = pdfManager.ensureDoc('fingerprint'); + var encryptedPromise = pdfManager.ensureXRef('encrypt'); + Promise.all([numPagesPromise, fingerprintPromise, + encryptedPromise]).then(function onDocReady(results) { + var doc = { + numPages: results[0], + fingerprint: results[1], + encrypted: !!results[2], + }; + loadDocumentCapability.resolve(doc); + }, + parseFailure); + }; + + var parseFailure = function parseFailure(e) { + loadDocumentCapability.reject(e); + }; + + pdfManager.ensureDoc('checkHeader', []).then(function() { + pdfManager.ensureDoc('parseStartXRef', []).then(function() { + pdfManager.ensureDoc('parse', [recoveryMode]).then( + parseSuccess, parseFailure); + }, parseFailure); + }, parseFailure); + + return loadDocumentCapability.promise; + } + + function getPdfManager(data) { + var pdfManagerCapability = createPromiseCapability(); + var pdfManager; + + var source = data.source; + var disableRange = data.disableRange; + if (source.data) { + try { + pdfManager = new LocalPdfManager(docId, source.data, source.password); + pdfManagerCapability.resolve(pdfManager); + } catch (ex) { + pdfManagerCapability.reject(ex); + } + return pdfManagerCapability.promise; + } else if (source.chunkedViewerLoading) { + try { + pdfManager = new NetworkPdfManager(docId, source, handler); + pdfManagerCapability.resolve(pdfManager); + } catch (ex) { + pdfManagerCapability.reject(ex); + } + return pdfManagerCapability.promise; + } + + var networkManager = new NetworkManager(source.url, { + httpHeaders: source.httpHeaders, + withCredentials: source.withCredentials + }); + var cachedChunks = []; + var fullRequestXhrId = networkManager.requestFull({ + onHeadersReceived: function onHeadersReceived() { + if (disableRange) { + return; + } + + var fullRequestXhr = networkManager.getRequestXhr(fullRequestXhrId); + if (fullRequestXhr.getResponseHeader('Accept-Ranges') !== 'bytes') { + return; + } + + var contentEncoding = + fullRequestXhr.getResponseHeader('Content-Encoding') || 'identity'; + if (contentEncoding !== 'identity') { + return; + } + + var length = fullRequestXhr.getResponseHeader('Content-Length'); + length = parseInt(length, 10); + if (!isInt(length)) { + return; + } + source.length = length; + if (length <= 2 * source.rangeChunkSize) { + // The file size is smaller than the size of two chunks, so it does + // not make any sense to abort the request and retry with a range + // request. + return; + } + + if (networkManager.isStreamingRequest(fullRequestXhrId)) { + // We can continue fetching when progressive loading is enabled, + // and we don't need the autoFetch feature. + source.disableAutoFetch = true; + } else { + // NOTE: by cancelling the full request, and then issuing range + // requests, there will be an issue for sites where you can only + // request the pdf once. However, if this is the case, then the + // server should not be returning that it can support range + // requests. + networkManager.abortRequest(fullRequestXhrId); + } + + try { + pdfManager = new NetworkPdfManager(docId, source, handler); + pdfManagerCapability.resolve(pdfManager); + } catch (ex) { + pdfManagerCapability.reject(ex); + } + cancelXHRs = null; + }, + + onProgressiveData: source.disableStream ? null : + function onProgressiveData(chunk) { + if (!pdfManager) { + cachedChunks.push(chunk); + return; + } + pdfManager.sendProgressiveData(chunk); + }, + + onDone: function onDone(args) { + if (pdfManager) { + return; // already processed + } + + var pdfFile; + if (args === null) { + // TODO add some streaming manager, e.g. for unknown length files. + // The data was returned in the onProgressiveData, combining... + var pdfFileLength = 0, pos = 0; + cachedChunks.forEach(function (chunk) { + pdfFileLength += chunk.byteLength; + }); + if (source.length && pdfFileLength !== source.length) { + warn('reported HTTP length is different from actual'); + } + var pdfFileArray = new Uint8Array(pdfFileLength); + cachedChunks.forEach(function (chunk) { + pdfFileArray.set(new Uint8Array(chunk), pos); + pos += chunk.byteLength; + }); + pdfFile = pdfFileArray.buffer; + } else { + pdfFile = args.chunk; + } + + // the data is array, instantiating directly from it + try { + pdfManager = new LocalPdfManager(docId, pdfFile, source.password); + pdfManagerCapability.resolve(pdfManager); + } catch (ex) { + pdfManagerCapability.reject(ex); + } + cancelXHRs = null; + }, + + onError: function onError(status) { + var exception; + if (status === 404 || status === 0 && /^file:/.test(source.url)) { + exception = new MissingPDFException('Missing PDF "' + + source.url + '".'); + handler.send('MissingPDF', exception); + } else { + exception = new UnexpectedResponseException( + 'Unexpected server response (' + status + + ') while retrieving PDF "' + source.url + '".', status); + handler.send('UnexpectedResponse', exception); + } + cancelXHRs = null; + }, + + onProgress: function onProgress(evt) { + handler.send('DocProgress', { + loaded: evt.loaded, + total: evt.lengthComputable ? evt.total : source.length + }); + } + }); + + cancelXHRs = function () { + networkManager.abortRequest(fullRequestXhrId); + }; + + return pdfManagerCapability.promise; + } + + var setupDoc = function(data) { + var onSuccess = function(doc) { + ensureNotTerminated(); + handler.send('GetDoc', { pdfInfo: doc }); + }; + + var onFailure = function(e) { + if (e instanceof PasswordException) { + if (e.code === PasswordResponses.NEED_PASSWORD) { + handler.send('NeedPassword', e); + } else if (e.code === PasswordResponses.INCORRECT_PASSWORD) { + handler.send('IncorrectPassword', e); + } + } else if (e instanceof InvalidPDFException) { + handler.send('InvalidPDF', e); + } else if (e instanceof MissingPDFException) { + handler.send('MissingPDF', e); + } else if (e instanceof UnexpectedResponseException) { + handler.send('UnexpectedResponse', e); + } else { + handler.send('UnknownError', + new UnknownErrorException(e.message, e.toString())); + } + }; + + ensureNotTerminated(); + + PDFJS.maxImageSize = data.maxImageSize === undefined ? + -1 : data.maxImageSize; + PDFJS.disableFontFace = data.disableFontFace; + PDFJS.disableCreateObjectURL = data.disableCreateObjectURL; + PDFJS.verbosity = data.verbosity; + PDFJS.cMapUrl = data.cMapUrl === undefined ? + null : data.cMapUrl; + PDFJS.cMapPacked = data.cMapPacked === true; + + getPdfManager(data).then(function (newPdfManager) { + if (terminated) { + // We were in a process of setting up the manager, but it got + // terminated in the middle. + newPdfManager.terminate(); + throw new Error('Worker was terminated'); + } + + pdfManager = newPdfManager; + handler.send('PDFManagerReady', null); + pdfManager.onLoadedStream().then(function(stream) { + handler.send('DataLoaded', { length: stream.bytes.byteLength }); + }); + }).then(function pdfManagerReady() { + ensureNotTerminated(); + + loadDocument(false).then(onSuccess, function loadFailure(ex) { + ensureNotTerminated(); + + // Try again with recoveryMode == true + if (!(ex instanceof XRefParseException)) { + if (ex instanceof PasswordException) { + // after password exception prepare to receive a new password + // to repeat loading + pdfManager.passwordChanged().then(pdfManagerReady); + } + + onFailure(ex); + return; + } + + pdfManager.requestLoadedStream(); + pdfManager.onLoadedStream().then(function() { + ensureNotTerminated(); + + loadDocument(true).then(onSuccess, onFailure); + }); + }, onFailure); + }, onFailure); + }; + + handler.on('GetPage', function wphSetupGetPage(data) { + return pdfManager.getPage(data.pageIndex).then(function(page) { + var rotatePromise = pdfManager.ensure(page, 'rotate'); + var refPromise = pdfManager.ensure(page, 'ref'); + var viewPromise = pdfManager.ensure(page, 'view'); + + return Promise.all([rotatePromise, refPromise, viewPromise]).then( + function(results) { + return { + rotate: results[0], + ref: results[1], + view: results[2] + }; + }); + }); + }); + + handler.on('GetPageIndex', function wphSetupGetPageIndex(data) { + var ref = new Ref(data.ref.num, data.ref.gen); + var catalog = pdfManager.pdfDocument.catalog; + return catalog.getPageIndex(ref); + }); + + handler.on('GetDestinations', + function wphSetupGetDestinations(data) { + return pdfManager.ensureCatalog('destinations'); + } + ); + + handler.on('GetDestination', + function wphSetupGetDestination(data) { + return pdfManager.ensureCatalog('getDestination', [data.id]); + } + ); + + handler.on('GetPageLabels', + function wphSetupGetPageLabels(data) { + return pdfManager.ensureCatalog('pageLabels'); + } + ); + + handler.on('GetAttachments', + function wphSetupGetAttachments(data) { + return pdfManager.ensureCatalog('attachments'); + } + ); + + handler.on('GetJavaScript', + function wphSetupGetJavaScript(data) { + return pdfManager.ensureCatalog('javaScript'); + } + ); + + handler.on('GetOutline', + function wphSetupGetOutline(data) { + return pdfManager.ensureCatalog('documentOutline'); + } + ); + + handler.on('GetMetadata', + function wphSetupGetMetadata(data) { + return Promise.all([pdfManager.ensureDoc('documentInfo'), + pdfManager.ensureCatalog('metadata')]); + } + ); + + handler.on('GetData', function wphSetupGetData(data) { + pdfManager.requestLoadedStream(); + return pdfManager.onLoadedStream().then(function(stream) { + return stream.bytes; + }); + }); + + handler.on('GetStats', + function wphSetupGetStats(data) { + return pdfManager.pdfDocument.xref.stats; + } + ); + + handler.on('UpdatePassword', function wphSetupUpdatePassword(data) { + pdfManager.updatePassword(data); + }); + + handler.on('GetAnnotations', function wphSetupGetAnnotations(data) { + return pdfManager.getPage(data.pageIndex).then(function(page) { + return pdfManager.ensure(page, 'getAnnotationsData', [data.intent]); + }); + }); + + handler.on('RenderPageRequest', function wphSetupRenderPage(data) { + var pageIndex = data.pageIndex; + pdfManager.getPage(pageIndex).then(function(page) { + var task = new WorkerTask('RenderPageRequest: page ' + pageIndex); + startWorkerTask(task); + + var pageNum = pageIndex + 1; + var start = Date.now(); + // Pre compile the pdf page and fetch the fonts/images. + page.getOperatorList(handler, task, data.intent).then( + function(operatorList) { + finishWorkerTask(task); + + info('page=' + pageNum + ' - getOperatorList: time=' + + (Date.now() - start) + 'ms, len=' + operatorList.totalLength); + }, function(e) { + finishWorkerTask(task); + if (task.terminated) { + return; // ignoring errors from the terminated thread + } + + // For compatibility with older behavior, generating unknown + // unsupported feature notification on errors. + handler.send('UnsupportedFeature', + {featureId: UNSUPPORTED_FEATURES.unknown}); + + var minimumStackMessage = + 'worker.js: while trying to getPage() and getOperatorList()'; + + var wrappedException; + + // Turn the error into an obj that can be serialized + if (typeof e === 'string') { + wrappedException = { + message: e, + stack: minimumStackMessage + }; + } else if (typeof e === 'object') { + wrappedException = { + message: e.message || e.toString(), + stack: e.stack || minimumStackMessage + }; + } else { + wrappedException = { + message: 'Unknown exception type: ' + (typeof e), + stack: minimumStackMessage + }; + } + + handler.send('PageError', { + pageNum: pageNum, + error: wrappedException, + intent: data.intent + }); + }); + }); + }, this); + + handler.on('GetTextContent', function wphExtractText(data) { + var pageIndex = data.pageIndex; + var normalizeWhitespace = data.normalizeWhitespace; + return pdfManager.getPage(pageIndex).then(function(page) { + var task = new WorkerTask('GetTextContent: page ' + pageIndex); + startWorkerTask(task); + var pageNum = pageIndex + 1; + var start = Date.now(); + return page.extractTextContent(task, normalizeWhitespace).then( + function(textContent) { + finishWorkerTask(task); + info('text indexing: page=' + pageNum + ' - time=' + + (Date.now() - start) + 'ms'); + return textContent; + }, function (reason) { + finishWorkerTask(task); + if (task.terminated) { + return; // ignoring errors from the terminated thread + } + throw reason; + }); + }); + }); + + handler.on('Cleanup', function wphCleanup(data) { + return pdfManager.cleanup(); + }); + + handler.on('Terminate', function wphTerminate(data) { + terminated = true; + if (pdfManager) { + pdfManager.terminate(); + pdfManager = null; + } + if (cancelXHRs) { + cancelXHRs(); + } + + var waitOn = []; + WorkerTasks.forEach(function (task) { + waitOn.push(task.finished); + task.terminate(); + }); + + return Promise.all(waitOn).then(function () { + // Notice that even if we destroying handler, resolved response promise + // must be sent back. + handler.destroy(); + handler = null; + }); + }); + + handler.on('Ready', function wphReady(data) { + setupDoc(docParams); + docParams = null; // we don't need docParams anymore -- saving memory. + }); + return workerHandlerName; + } +}; + +function initializeWorker() { + if (!('console' in globalScope)) { + 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 + }); + throw 'pdf.js execution error'; + }, + + time: function time(name) { + consoleTimer[name] = Date.now(); + }, + + timeEnd: function timeEnd(name) { + var time = consoleTimer[name]; + if (!time) { + error('Unknown timer name ' + name); + } + this.log('Timer:', name, Date.now() - time); + } + }; + + globalScope.console = workerConsole; + } + + var handler = new MessageHandler('worker', 'main', self); + WorkerMessageHandler.setup(handler, self); + handler.send('ready', null); +} + +// Worker thread (and not node.js)? +if (typeof window === 'undefined' && + !(typeof module !== 'undefined' && module.require)) { + initializeWorker(); +} + +exports.WorkerTask = WorkerTask; +exports.WorkerMessageHandler = WorkerMessageHandler; +})); + + + }).call(pdfjsLibs); + + exports.PDFJS = pdfjsLibs.pdfjsSharedGlobal.PDFJS; + +})); + + diff --git a/static/js/speaker.js b/static/js/speaker.js new file mode 100644 index 0000000..057b109 --- /dev/null +++ b/static/js/speaker.js @@ -0,0 +1,291 @@ +$(function() { sio = (function() { + + var sio = {}; + + var counter = $('#counter'); + + var canvasPdf = $('#canvas-pdf').get(0); + var contextPdf = canvasPdf.getContext('2d'); + + var canvasPaint = $('#canvas-paint').get(0); + var contextPaint = canvasPaint.getContext('2d'); + + var pdf; + var currentPage = 1; + + var startTime = 0; + var startSlide = 0; + var refreshIntervalId = 0; + + var pointer = false; + var shouldUpdatePointer = false; + + var canvasPdfBounding; + + var lasers = {}; + var drawAudienceLasers = false; + + PDFJS.getDocument('/static/uploaded/' + filename + '.pdf').then(function getPdf(_pdf) { + pdf = _pdf; + updateUI(); + }); + + var socket = io(); + + socket.on('welcome', function() { + socket.emit('speaker', filename, socket.id); + }); + + socket.on('pointer', canvasPointer); + + function filterInt(value) { + if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) + return Number(value); + return NaN; + } + + var updateUI = function() { + + counter.val(currentPage + '/' + pdf.pdfInfo.numPages); + + $('#previous,#first').prop('disabled', currentPage === 1); + $('#next,#last').prop('disabled', currentPage === pdf.pdfInfo.numPages); + + pdf.getPage(currentPage).then(function(page) { + + previousPage = currentPage; + + var viewport = page.getViewport(2.0); + + canvasPdf.width = viewport.width; + canvasPdf.height = viewport.height; + + canvasPaint.width = viewport.width; + canvasPaint.height = viewport.height; + + $('#canvases').width(canvasPdf.width + 'px'); + $('#canvases').height(canvasPdf.height + 'px'); + + canvasPdfBounding = canvasPdf.getBoundingClientRect(); + + var renderContext = { + canvasContext: contextPdf, + viewport: viewport + }; + + page.render(renderContext); + + }); + + }; + + function updateAudience() { socket.emit('change-slide', filename, currentPage); } + + function formatTime(ms) { + var sec = padToTwo(Math.floor((ms / 1000) % 60)); + var min = padToTwo(Math.floor(((ms / 1000 - sec) % 3600) / 60)); + + return min + ':' + sec; + } + + function updateTimers() { + if (refreshIntervalId !== 0) { + $('#totalTime').html(formatTime(Date.now() - startTime)); + $('#slideTime').html(formatTime(Date.now() - startSlide)); + } + } + + function padToTwo(number) { + if (number<=99) { number = ("0"+number).slice(-2); } + return number; + } + + function resetTimeSlide() { + startSlide = Date.now(); + updateTimers(); + } + + + // Check if number is valid, and updates + // number undefined means sync all clients + function changeSlide(number) { + + if (isNaN(number) || number < 1 || number > pdf.pdfInfo.numPages) { + return false; + } + + if (currentPage === undefined || currentPage === number) { + updateAudience(); + return true; + } + + currentPage = number; + + updateUI(); + updateAudience(); + resetTimeSlide(); + + return true; + + } + + function canvasPointer(id,x,y) { + + // Clear canvas + canvasPaint.width = canvasPaint.width; + + if (id != undefined) { + + if (x != undefined && y != undefined) { + + lasers[id] = {x:x, y:y}; + + } else { + + delete lasers[id]; + + } + + } + + for (var laserIndex in lasers) { + + var laser = lasers[laserIndex]; + + if (drawAudienceLasers === true || laserIndex === socket.id) { + + contextPaint.fillStyle = laserIndex === socket.id ? 'red' : 'green'; + contextPaint.beginPath(); + contextPaint.arc(laser.x * canvasPdf.width, laser.y * canvasPdf.height, 10, 0, Math.PI*2, true); + contextPaint.closePath(); + contextPaint.fill(); + + } + + } + + } + + sio.onMouseDown = function(event) { + + var x = (event.x - canvasPdfBounding.left) / canvasPdf.width; + var y = (event.y - canvasPdfBounding.top) / canvasPdf.height; + + socket.emit('pointer', filename, socket.id, x, y); + + pointer = true; + shouldUpdatePointer = true; + + canvasPointer(socket.id, x, y); + + }; + + sio.onMouseMove = function(event) { + + if (pointer) { + + var x = (event.x - canvasPdfBounding.left) / canvasPdf.width; + var y = (event.y - canvasPdfBounding.top) / canvasPdf.height; + + if (shouldUpdatePointer) { + // Update + socket.emit('pointer', filename, socket.id, x, y); + + shouldUpdatePointer = false; + + setTimeout(function() { + + shouldUpdatePointer = true; + + }, 20); + + } + + canvasPointer(socket.id, x, y); + + } + + }; + + sio.onMouseUp = function(event) { + + socket.emit('pointer', filename, socket.id); + + pointer = false; + shouldUpdatePointer = false; + + canvasPointer(socket.id); + + }; + + sio.startPresentation = function() { + + startTime = startSlide = Date.now(); + + refreshIntervalId = setInterval(updateTimers, 1000); + updateTimers(); + + $('#start').prop('disabled', true); + $('#stop').prop('disabled', false); + + }; + + sio.stopPresentation = function() { + + clearInterval(refreshIntervalId); + refreshIntervalId = 0; + + $('#start').prop('disabled', false); + $('#stop').prop('disabled', true); + + }; + + sio.changeSlideFromCounter = function() { + + var slideNumber = filterInt($('#counter').val()); + + changeSlide(slideNumber); + + // lose focus + $(':focus').blur(); + + }; + + sio.switchAudienceLaser = function() { + + var laser = $('#viewer-laser'); + + if (drawAudienceLasers === false) { + + // Laser is disabled, will be enabled + laser.text('Audience laser is enabled'); + laser.removeClass('btn-default').addClass('btn-primary'); + drawAudienceLasers = true; + + + } else { + + laser.text('Audience laser is disabled'); + laser.removeClass('btn-primary').addClass('btn-default'); + drawAudienceLasers = false; + + } + + socket.emit('viewer-laser', filename, drawAudienceLasers); + + }; + + sio.clearCounter = function() { $('#counter').val(''); }; + sio.nextSlide = function() { changeSlide(currentPage + 1); }; + sio.previousSlide = function() { changeSlide(currentPage - 1); }; + sio.firstSlide = function() { changeSlide(1); }; + sio.lastSlide = function() { changeSlide(pdf.pdfInfo.numPages); }; + + sio.syncAudience = updateAudience; + sio.update = updateUI; + + $(window).resize(updateUI); + + return sio; + +})(); }); diff --git a/static/js/viewer.js b/static/js/viewer.js new file mode 100644 index 0000000..63aedbd --- /dev/null +++ b/static/js/viewer.js @@ -0,0 +1,175 @@ +$(function() { sio = (function() { + + var sio = {}; + + var canvasPdf = $('#canvas-pdf').get(0); + var contextPdf = canvasPdf.getContext('2d'); + + var canvasPaint = $('#canvas-paint').get(0); + var contextPaint = canvasPaint.getContext('2d'); + + var pdf; + var pageNumber = 1; + + var pointer = false; + var canvasPdfBounding; + + var drawAudienceLaser = false; + var lasers = {}; + + + PDFJS.getDocument('/static/uploaded/' + filename + '.pdf').then(function getPdfHelloWorld(_pdf) { + + pdf = _pdf; + update(); + + }); + + var socket = io(); + + socket.on('welcome', function() { + socket.emit('viewer', filename); + }); + + socket.on('update', function(newPageNumber) { + pageNumber = newPageNumber; + update(); + }); + + socket.on('viewer-laser', function(enabled) { + drawAudienceLaser = enabled; + }); + + socket.on('pointer', canvasPointer); + + function update() { + + pdf.getPage(pageNumber).then(function(page) { + + var scale; + + // width / height + var ratio = page.pageInfo.view[2] / page.pageInfo.view[3]; + + if (window.innerWidth < window.innerHeight) { + + canvasPdf.width = window.innerWidth; + canvasPdf.height = canvasPdf.width / ratio; + scale = canvasPdf.width / page.getViewport(1.0).width; + + } else { + + canvasPdf.height = window.innerHeight; + canvasPdf.width = ratio * canvasPdf.height; + scale = canvasPdf.width / page.getViewport(1.0).width; + } + + canvasPaint.width = canvasPdf.width; + canvasPaint.height = canvasPdf.height; + + $('#canvases').width(canvasPdf.width + 'px'); + $('#canvases').height(canvasPdf.height + 'px'); + + canvasPdfBounding = canvasPdf.getBoundingClientRect(); + + var viewport = page.getViewport(scale); + + var renderContext = { + canvasContext: contextPdf, + viewport: viewport + }; + + page.render(renderContext); + + }); + + } + + function canvasPointer(id,x,y) { + + // Clear canvas + canvasPaint.width = canvasPaint.width; + + if (id != undefined) { + if ( x != undefined && y != undefined) { + lasers[id] = {x:x, y:y}; + } else { + delete lasers[id]; + } + } + + for (var laserIndex in lasers) { + + var laser = lasers[laserIndex]; + + if (drawAudienceLaser === true || laserIndex === 'speaker') { + + contextPaint.fillStyle = laserIndex === 'speaker' ? 'red' : 'green'; + contextPaint.beginPath(); + contextPaint.arc(laser.x * canvasPdf.width, laser.y * canvasPdf.height, 10, 0, Math.PI*2, true); + contextPaint.closePath(); + contextPaint.fill(); + + } + + } + + } + + $(window).resize(update); + + sio.onMouseDown = function() { + + var x = (event.x - canvasPdfBounding.left) / canvasPdf.width; + var y = (event.y - canvasPdfBounding.top) / canvasPdf.height; + + socket.emit('pointer', filename, socket.id, x, y); + + pointer = true; + shouldUpdatePointer = true; + + canvasPointer(socket.id, x, y); + + }; + + sio.onMouseMove = function(event) { + + if (pointer) { + + var x = (event.x - canvasPdfBounding.left) / canvasPdf.width; + var y = (event.y - canvasPdfBounding.top) / canvasPdf.height; + + if (shouldUpdatePointer) { + // Update + socket.emit('pointer', filename, socket.id, x, y); + + shouldUpdatePointer = false; + + setTimeout(function() { + + shouldUpdatePointer = true; + + }, 20); + + } + + canvasPointer(socket.id, x, y); + + } + + }; + + sio.onMouseUp = function(event) { + + socket.emit('pointer', filename, socket.id); + + pointer = false; + shouldUpdatePointer = false; + + canvasPointer(socket.id); + + }; + + return sio; + +})(); }); diff --git a/static/uploaded/last_slides.pdf b/static/uploaded/last_slides.pdf new file mode 100644 index 0000000000000000000000000000000000000000..0e3d24e1ccc455213862ded34275f3412b304999 GIT binary patch literal 58906 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 @wkquD*J7n`1axa66H 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 literal 0 HcmV?d00001 diff --git a/static/uploaded/main.pdf b/static/uploaded/main.pdf new file mode 100644 index 0000000000000000000000000000000000000000..99bb721b4ae10d7b7d4279d51658654331e58c0e GIT binary patch literal 721845 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 z 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

My?Hl3zky7=*OP;}Rl?&^2j9qI!G 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

    pkX6HV1QD$2{3KSo5&2Gjg3ti05>YGBB{ROues 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

    U%mKt zf4V?(XT6X$V;d6;47>l|_bxB5cBCu0W$25t0@^$W9N(N7Vw<3sQ4W)DuWi?3IZtCn z3zQF1Xtfz^6JOb_KOq$Py2hO4)($Dkdad5U8IzSJ5iFEG{9!v;rYp0tY1mL zDIL?s4!4RhjMJ9O4h_7hC{gd1nnns&a^s!9ktKE0QRgPr)Fl=4xiX-K8_j7Ed z2ufYuwVKhYl<>C2l!J$tpT@Y^myXX3k*-*$`S<$zmWg=;=%{}DsEyp<)J6)HWN_2Z z-?@zHX;Ra0Rr>5usXqIRZBw7^I*W5dz{VJe2?hW)@WL|x>YYjFSD#e?JlPqmR# z+{T+bG6Kl@6!UgxVyNf;Yesp-6rsOh0PBwav4&tsX<9Z`V z$$`$6U*AO?YYhz$c`szLatfFGruckDAM-Z+V|R2jG+Ry9&mW-p<+0t+09r$MKL=koW^?$;~F+0E=j5U*vV zC7269i&N>%$G+|T)^oYKnI&MiUa4zo-H+Zu7fPN>^Br{NweH+zyEG72hFaO!8MELo z+mONXCmUHn%L!{UdQJw+7Gq&AWxiHrg&foqeE#DrYzQk0&(UR}S$wzGVPnjl<5kRU zt~k;VeV1Xi(>E$1IB0l>c1WBh2;2*Y43S#ihQu zlHx0Q(Rds}s}Olt!kWU`h{UgNv70TmJF3hNfLu}TA86K;Pe<7Me}A2aecCZVdvf7F zVTcEEx8fgY!fQU@(i79(sJ%n7MnnIx+%6zn$o}N;aOD@q($@RZXTO&=|cImgyX(K>i-x9pdIiGn41mx zVxjKGk}_RmsadV-jsn<>{M|A757c>S&qbKs)bWGe;ydi?!(PVPqz$k6vB#LC&%%%H zKFL@UU$hlJi0WsrQ!ZEg3R89jg1pve0NqQKo8y!9yFlTQRVXocFF3c^_4~p zo?yoC(YvbWeHndYdZ8*~3>4?-GBWIHL?h_#5>!f0A<1*_i;al?qqB*aRBtD3KMSh6 zKxu<_UZ6{8z_F9wJi4Ia6?=1pU>T27S%^oDzU$%Q4}p1N7VW1=TP+9;%=a)C`~SLq*iNXdbVNf4b~^bH1Vz zbc*QSPc-9kc&0)?G?k-DcPMvDzLqQTwQvGfUgVoSo^iepEA6$fe8V;Ht2<2I_HZ~? zz@up~s}ES>iB^UIkZ-P2;-ck*^c`S?x?V<-CJyblLOlF+ zZF3!(J$dBzKIfJSE{vn@4@n->*FNUq=M#Y%?9t!;k_6MNjeJWp#CBuZr^+@pzbiSv znx9=*wh@|PtjN^Kc5yky$I|-@`^owFw4@1y4yH4#m$Q(>w}^A&xG=8_DWiNy@QnRS z=J*ikdO|#(>Zz}B0vGb?i-nvF-;+}%GU6R*du2nD*8+_3&~oqX+0TQMSNN8#bFlIV zNu|P^f1qORbgMZk&{qP4SX^1LzA0HOY@_^PhyE7$rLGBAwXXiv&! zC{rd*KHCNLSN-BAaS7~7{E8+i9}|AERo4~2MqoF$$4~v;?|eLafMf-fL%i<9GnJK%I?O%)?eFDfaY%KnP+!x3$*t5=yzwFNB){1cm9boz4gNfD{9mB5% zkZe8ds5N_v?SCK6%&jy5NQ%Q0!VG=*{NSPvJQ1sV-h8`pwPUmxKGwR@ge@aEaZf~| z?Qgx|6n5VebYw2UzuaE5aa^mBoEc!JXZikwf4{wGp1%NG_A

    KIb!7Hg7k(YPG74 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
  1. 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

    ?Glvt?q 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 literal 0 HcmV?d00001 diff --git a/views/base.pug b/views/base.pug new file mode 100644 index 0000000..e1da729 --- /dev/null +++ b/views/base.pug @@ -0,0 +1,14 @@ +doctype +html( lang="en" ) + head + title slideshow.io + meta( charset='utf-8' ) + meta( http-equiv='X-UA-Compatible', content='IE=edge' ) + block css + + body + block base_content + + script( src='http://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js' ) + + block js diff --git a/views/main.pug b/views/main.pug new file mode 100644 index 0000000..15cbb20 --- /dev/null +++ b/views/main.pug @@ -0,0 +1,28 @@ +extends ./base.pug + +block css + meta( name='viewport', content='width=device-width, initial-scale=1.0' ) + meta( name='description', content='Baking Bootstrap Snippets with Jade' ) + //- Bootswatch Theme + link(href="https://bootswatch.com/cerulean/bootstrap.min.css", rel="stylesheet") + +block base_content + nav.navbar.navbar-default( role="navigation" ) + .container + .navbar-header + button.navbar-toggle.collapsed( type="button", data-toggle="collapse", data-target="#navbar-inverse", aria-expanded="false", aria-controls="navbar") + span.sr-only Toggle navigation + span.icon-bar + span.icon-bar + span.icon-bar + a.navbar-brand(href="#") slideshow.io + + #navbar-inverse.collapse.navbar-collapse + ul.nav.navbar-nav + li: a( href="#about" ) About + + .container + block content + +block prepend js + script( src='http://maxcdn.bootstrapcdn.com/bootstrap/3.3.1/js/bootstrap.min.js' )

    2. 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