|
@@ -22,8 +22,8 @@ if (typeof PDFJS === 'undefined') {
|
|
|
(typeof window !== 'undefined' ? window : this).PDFJS = {};
|
|
|
}
|
|
|
|
|
|
-PDFJS.version = '1.2.47';
|
|
|
-PDFJS.build = '15b00ea';
|
|
|
+PDFJS.version = '1.2.49';
|
|
|
+PDFJS.build = 'c27d312';
|
|
|
|
|
|
(function pdfjsWrapper() {
|
|
|
// Use strict in our context only - users might not want it
|
|
@@ -8232,38179 +8232,6 @@ var SVGGraphics = (function SVGGraphicsClosure() {
|
|
|
PDFJS.SVGGraphics = SVGGraphics;
|
|
|
|
|
|
|
|
|
-
|
|
|
-
|
|
|
-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 {
|
|
|
- pendingRequest.onDone({
|
|
|
- begin: 0,
|
|
|
- chunk: chunk
|
|
|
- });
|
|
|
- }
|
|
|
- },
|
|
|
-
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-// TODO(mack): Make use of PDFJS.Util.inherit() when it becomes available
|
|
|
-var BasePdfManager = (function BasePdfManagerClosure() {
|
|
|
- function BasePdfManager() {
|
|
|
- throw new Error('Cannot initialize BaseManagerManager');
|
|
|
- }
|
|
|
-
|
|
|
- BasePdfManager.prototype = {
|
|
|
- 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_pagePage(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_ensure(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(data, password) {
|
|
|
- var stream = new Stream(data);
|
|
|
- this.pdfDocument = new PDFDocument(this, stream, password);
|
|
|
- this._loadedStreamCapability = createPromiseCapability();
|
|
|
- this._loadedStreamCapability.resolve(stream);
|
|
|
- }
|
|
|
-
|
|
|
- LocalPdfManager.prototype = Object.create(BasePdfManager.prototype);
|
|
|
- LocalPdfManager.prototype.constructor = LocalPdfManager;
|
|
|
-
|
|
|
- LocalPdfManager.prototype.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);
|
|
|
- }
|
|
|
- });
|
|
|
- };
|
|
|
-
|
|
|
- LocalPdfManager.prototype.requestRange =
|
|
|
- function LocalPdfManager_requestRange(begin, end) {
|
|
|
- return Promise.resolve();
|
|
|
- };
|
|
|
-
|
|
|
- LocalPdfManager.prototype.requestLoadedStream =
|
|
|
- function LocalPdfManager_requestLoadedStream() {
|
|
|
- };
|
|
|
-
|
|
|
- LocalPdfManager.prototype.onLoadedStream =
|
|
|
- function LocalPdfManager_getLoadedStream() {
|
|
|
- return this._loadedStreamCapability.promise;
|
|
|
- };
|
|
|
-
|
|
|
- LocalPdfManager.prototype.terminate =
|
|
|
- function LocalPdfManager_terminate() {
|
|
|
- return;
|
|
|
- };
|
|
|
-
|
|
|
- return LocalPdfManager;
|
|
|
-})();
|
|
|
-
|
|
|
-var NetworkPdfManager = (function NetworkPdfManagerClosure() {
|
|
|
- function NetworkPdfManager(args, msgHandler) {
|
|
|
-
|
|
|
- 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);
|
|
|
- }
|
|
|
-
|
|
|
- NetworkPdfManager.prototype = Object.create(BasePdfManager.prototype);
|
|
|
- NetworkPdfManager.prototype.constructor = NetworkPdfManager;
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.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();
|
|
|
- });
|
|
|
- };
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.requestRange =
|
|
|
- function NetworkPdfManager_requestRange(begin, end) {
|
|
|
- return this.streamManager.requestRange(begin, end);
|
|
|
- };
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.requestLoadedStream =
|
|
|
- function NetworkPdfManager_requestLoadedStream() {
|
|
|
- this.streamManager.requestAllChunks();
|
|
|
- };
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.sendProgressiveData =
|
|
|
- function NetworkPdfManager_sendProgressiveData(chunk) {
|
|
|
- this.streamManager.onReceiveData({ chunk: chunk });
|
|
|
- };
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.onLoadedStream =
|
|
|
- function NetworkPdfManager_getLoadedStream() {
|
|
|
- return this.streamManager.onLoadedStream();
|
|
|
- };
|
|
|
-
|
|
|
- NetworkPdfManager.prototype.terminate =
|
|
|
- function NetworkPdfManager_terminate() {
|
|
|
- this.streamManager.abort();
|
|
|
- };
|
|
|
-
|
|
|
- return NetworkPdfManager;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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, pdfManager, partialEvaluator, task, intent);
|
|
|
- return annotationsReadyPromise.then(function () {
|
|
|
- pageOpList.flush(true);
|
|
|
- return pageOpList;
|
|
|
- });
|
|
|
- });
|
|
|
- },
|
|
|
-
|
|
|
- extractTextContent: function Page_extractTextContent(task) {
|
|
|
- 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);
|
|
|
- });
|
|
|
- },
|
|
|
-
|
|
|
- getAnnotationsData: function Page_getAnnotationsData() {
|
|
|
- var annotations = this.annotations;
|
|
|
- var annotationsData = [];
|
|
|
- for (var i = 0, n = annotations.length; i < n; ++i) {
|
|
|
- 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 &&
|
|
|
- (annotation.isViewable() || annotation.isPrintable())) {
|
|
|
- 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);
|
|
|
- this.catalog = new Catalog(this.pdfManager, this.xref);
|
|
|
- },
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-var Catalog = (function CatalogClosure() {
|
|
|
- function Catalog(pdfManager, xref) {
|
|
|
- this.pdfManager = pdfManager;
|
|
|
- this.xref = xref;
|
|
|
- this.catDict = xref.getCatalogObj();
|
|
|
- this.fontCache = new RefSetCache();
|
|
|
- assert(isDict(this.catDict),
|
|
|
- 'catalog object is not a dictionary');
|
|
|
-
|
|
|
- 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 dest = outlineDict.get('A');
|
|
|
- if (dest) {
|
|
|
- dest = dest.get('D');
|
|
|
- } else if (outlineDict.has('Dest')) {
|
|
|
- dest = outlineDict.getRaw('Dest');
|
|
|
- if (isName(dest)) {
|
|
|
- dest = dest.name;
|
|
|
- }
|
|
|
- }
|
|
|
- var title = outlineDict.get('Title');
|
|
|
- var outlineItem = {
|
|
|
- dest: dest,
|
|
|
- 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 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 new Page(this.pdfManager, this.xref, 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 is like a Dict but has some advantageous properties, see the
|
|
|
- * spec (7.9.6) for more details.
|
|
|
- * TODO: implement all the Dict functions and make this more efficent.
|
|
|
- */
|
|
|
-var NameTree = (function NameTreeClosure() {
|
|
|
- function NameTree(root, xref) {
|
|
|
- this.root = root;
|
|
|
- this.xref = xref;
|
|
|
- }
|
|
|
-
|
|
|
- NameTree.prototype = {
|
|
|
- getAll: function NameTree_getAll() {
|
|
|
- var dict = {};
|
|
|
- if (!this.root) {
|
|
|
- return dict;
|
|
|
- }
|
|
|
- var xref = this.xref;
|
|
|
- // reading name 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];
|
|
|
- if (processed.has(kid)) {
|
|
|
- error('invalid destinations');
|
|
|
- }
|
|
|
- queue.push(kid);
|
|
|
- processed.put(kid);
|
|
|
- }
|
|
|
- continue;
|
|
|
- }
|
|
|
- var names = obj.get('Names');
|
|
|
- if (names) {
|
|
|
- for (i = 0, n = names.length; i < n; i += 2) {
|
|
|
- dict[xref.fetchIfRef(names[i])] = xref.fetchIfRef(names[i + 1]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return dict;
|
|
|
- },
|
|
|
-
|
|
|
- get: function NameTree_get(destinationId) {
|
|
|
- if (!this.root) {
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- var xref = this.xref;
|
|
|
- var kidsOrNames = xref.fetchIfRef(this.root);
|
|
|
- var loopCount = 0;
|
|
|
- var MAX_NAMES_LEVELS = 10;
|
|
|
- var l, r, m;
|
|
|
-
|
|
|
- // Perform a binary search to quickly find the entry that
|
|
|
- // contains the named destination we are looking for.
|
|
|
- while (kidsOrNames.has('Kids')) {
|
|
|
- loopCount++;
|
|
|
- if (loopCount > MAX_NAMES_LEVELS) {
|
|
|
- warn('Search depth limit for named destionations has been reached.');
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- var kids = kidsOrNames.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 (destinationId < xref.fetchIfRef(limits[0])) {
|
|
|
- r = m - 1;
|
|
|
- } else if (destinationId > xref.fetchIfRef(limits[1])) {
|
|
|
- l = m + 1;
|
|
|
- } else {
|
|
|
- kidsOrNames = 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 named destinations in the Named dictionary
|
|
|
- // until we find the exact destination we're looking for.
|
|
|
- var names = kidsOrNames.get('Names');
|
|
|
- if (isArray(names)) {
|
|
|
- // Perform a binary search to reduce the lookup time.
|
|
|
- l = 0;
|
|
|
- r = names.length - 2;
|
|
|
- while (l <= r) {
|
|
|
- // Check only even indices (0, 2, 4, ...) because the
|
|
|
- // odd indices contain the actual D array.
|
|
|
- m = (l + r) & ~1;
|
|
|
- if (destinationId < xref.fetchIfRef(names[m])) {
|
|
|
- r = m - 2;
|
|
|
- } else if (destinationId > xref.fetchIfRef(names[m])) {
|
|
|
- l = m + 2;
|
|
|
- } else {
|
|
|
- return xref.fetchIfRef(names[m + 1]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- };
|
|
|
- return NameTree;
|
|
|
-})();
|
|
|
-
|
|
|
-/**
|
|
|
- * "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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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'
|
|
|
-];
|
|
|
-
|
|
|
-
|
|
|
-var DEFAULT_ICON_SIZE = 22; // px
|
|
|
-
|
|
|
-/**
|
|
|
- * @constructor
|
|
|
- */
|
|
|
-function AnnotationFactory() {}
|
|
|
-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);
|
|
|
-
|
|
|
- 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;
|
|
|
- var data = this.data = {};
|
|
|
-
|
|
|
- data.subtype = dict.get('Subtype').name;
|
|
|
- data.annotationFlags = dict.get('F');
|
|
|
-
|
|
|
- this.setRectangle(dict.get('Rect'));
|
|
|
- data.rect = this.rectangle;
|
|
|
-
|
|
|
- this.setColor(dict.get('C'));
|
|
|
- data.color = this.color;
|
|
|
-
|
|
|
- this.borderStyle = data.borderStyle = new AnnotationBorderStyle();
|
|
|
- this.setBorderStyle(dict);
|
|
|
-
|
|
|
- this.appearance = getDefaultAppearance(dict);
|
|
|
- data.hasAppearance = !!this.appearance;
|
|
|
- data.id = params.ref.num;
|
|
|
- }
|
|
|
-
|
|
|
- Annotation.prototype = {
|
|
|
- /**
|
|
|
- * 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) {
|
|
|
- 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);
|
|
|
- }
|
|
|
- },
|
|
|
-
|
|
|
- isInvisible: function Annotation_isInvisible() {
|
|
|
- var data = this.data;
|
|
|
- return !!(data &&
|
|
|
- data.annotationFlags && // Default: not invisible
|
|
|
- data.annotationFlags & 0x1); // Invisible
|
|
|
- },
|
|
|
-
|
|
|
- isViewable: function Annotation_isViewable() {
|
|
|
- var data = this.data;
|
|
|
- return !!(!this.isInvisible() &&
|
|
|
- data &&
|
|
|
- (!data.annotationFlags ||
|
|
|
- !(data.annotationFlags & 0x22)) && // Hidden or NoView
|
|
|
- data.rect); // rectangle is necessary
|
|
|
- },
|
|
|
-
|
|
|
- isPrintable: function Annotation_isPrintable() {
|
|
|
- var data = this.data;
|
|
|
- return !!(!this.isInvisible() &&
|
|
|
- data &&
|
|
|
- data.annotationFlags && // Default: not printable
|
|
|
- data.annotationFlags & 0x4 && // Print
|
|
|
- !(data.annotationFlags & 0x2) && // Hidden
|
|
|
- data.rect); // rectangle is necessary
|
|
|
- },
|
|
|
-
|
|
|
- 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, pdfManager, partialEvaluator, task, intent) {
|
|
|
-
|
|
|
- function reject(e) {
|
|
|
- annotationsReadyCapability.reject(e);
|
|
|
- }
|
|
|
-
|
|
|
- var annotationsReadyCapability = createPromiseCapability();
|
|
|
-
|
|
|
- var annotationPromises = [];
|
|
|
- for (var i = 0, n = annotations.length; i < n; ++i) {
|
|
|
- if (intent === 'display' && annotations[i].isViewable() ||
|
|
|
- intent === 'print' && annotations[i].isPrintable()) {
|
|
|
- annotationPromises.push(
|
|
|
- annotations[i].getOperatorList(partialEvaluator, task));
|
|
|
- }
|
|
|
- }
|
|
|
- Promise.all(annotationPromises).then(function(datas) {
|
|
|
- opList.addOp(OPS.beginAnnotations, []);
|
|
|
- for (var i = 0, n = datas.length; i < n; ++i) {
|
|
|
- var annotOpList = datas[i];
|
|
|
- opList.addOpList(annotOpList);
|
|
|
- }
|
|
|
- opList.addOp(OPS.endAnnotations, []);
|
|
|
- annotationsReadyCapability.resolve();
|
|
|
- }, reject);
|
|
|
-
|
|
|
- return annotationsReadyCapability.promise;
|
|
|
- };
|
|
|
-
|
|
|
- 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.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;
|
|
|
-
|
|
|
- // 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('.');
|
|
|
- }
|
|
|
-
|
|
|
- var parent = Annotation.prototype;
|
|
|
- Util.inherit(WidgetAnnotation, Annotation, {
|
|
|
- isViewable: function WidgetAnnotation_isViewable() {
|
|
|
- if (this.data.fieldType === 'Sig') {
|
|
|
- warn('unimplemented annotation type: Widget signature');
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- return parent.isViewable.call(this);
|
|
|
- }
|
|
|
- });
|
|
|
-
|
|
|
- return WidgetAnnotation;
|
|
|
-})();
|
|
|
-
|
|
|
-var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {
|
|
|
- function TextWidgetAnnotation(params) {
|
|
|
- WidgetAnnotation.call(this, params);
|
|
|
-
|
|
|
- this.data.textAlignment = Util.getInheritableProperty(params.dict, 'Q');
|
|
|
- this.data.annotationType = AnnotationType.WIDGET;
|
|
|
- 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() {
|
|
|
- function TextAnnotation(params) {
|
|
|
- Annotation.call(this, params);
|
|
|
-
|
|
|
- var dict = params.dict;
|
|
|
- var data = this.data;
|
|
|
-
|
|
|
- var content = dict.get('Contents');
|
|
|
- var title = dict.get('T');
|
|
|
- data.annotationType = AnnotationType.TEXT;
|
|
|
- data.content = stringToPDFString(content || '');
|
|
|
- data.title = stringToPDFString(title || '');
|
|
|
- data.hasHtml = true;
|
|
|
-
|
|
|
- if (data.hasAppearance) {
|
|
|
- data.name = 'NoIcon';
|
|
|
- } else {
|
|
|
- data.rect[1] = data.rect[3] - DEFAULT_ICON_SIZE;
|
|
|
- data.rect[2] = data.rect[0] + DEFAULT_ICON_SIZE;
|
|
|
- data.name = dict.has('Name') ? dict.get('Name').name : 'Note';
|
|
|
- }
|
|
|
-
|
|
|
- if (dict.has('C')) {
|
|
|
- data.hasBgColor = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- 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 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, min, max;
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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') || 40;
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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) {
|
|
|
-
|
|
|
- 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;
|
|
|
- }
|
|
|
- UnsupportedManager.notify(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 appears to be too small and breaks the
|
|
|
-// extend. 1e-7 works in FF but chrome seems to use an even smaller sized number
|
|
|
-// internally so we have to go bigger.
|
|
|
-Shadings.SMALL_NUMBER = 1e-2;
|
|
|
-
|
|
|
-// 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);
|
|
|
- }
|
|
|
-
|
|
|
- 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
|
|
|
- ];
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-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')
|
|
|
- };
|
|
|
- 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;
|
|
|
- });
|
|
|
- }).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];
|
|
|
- if (glyph === null) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- 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_font_' + (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);
|
|
|
- }
|
|
|
-
|
|
|
- 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?
|
|
|
- UnsupportedManager.notify(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);
|
|
|
- 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);
|
|
|
- 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) {
|
|
|
-
|
|
|
- stateManager = (stateManager || new StateManager(new TextState()));
|
|
|
-
|
|
|
- var textContent = {
|
|
|
- items: [],
|
|
|
- styles: Object.create(null)
|
|
|
- };
|
|
|
- var bidiTexts = textContent.items;
|
|
|
- var SPACE_FACTOR = 0.3;
|
|
|
- var MULTI_SPACE_FACTOR = 1.5;
|
|
|
-
|
|
|
- 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 newTextChunk() {
|
|
|
- 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
|
|
|
- };
|
|
|
- }
|
|
|
- return {
|
|
|
- // |str| is initially an array which we push individual chars to, and
|
|
|
- // then runBidi() overwrites it with the final string.
|
|
|
- str: [],
|
|
|
- dir: null,
|
|
|
- width: 0,
|
|
|
- height: 0,
|
|
|
- transform: null,
|
|
|
- fontName: font.loadedName
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- function runBidi(textChunk) {
|
|
|
- var str = textChunk.str.join('');
|
|
|
- var bidiResult = PDFJS.bidi(str, -1, textState.font.vertical);
|
|
|
- textChunk.str = bidiResult.str;
|
|
|
- textChunk.dir = bidiResult.dir;
|
|
|
- return textChunk;
|
|
|
- }
|
|
|
-
|
|
|
- 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 buildTextGeometry(chars, textChunk) {
|
|
|
- var font = textState.font;
|
|
|
- textChunk = textChunk || newTextChunk();
|
|
|
- if (!textChunk.transform) {
|
|
|
- // 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 = textChunk.transform = Util.transform(textState.ctm,
|
|
|
- Util.transform(textState.textMatrix, tsm));
|
|
|
- if (!font.vertical) {
|
|
|
- textChunk.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]);
|
|
|
- } else {
|
|
|
- textChunk.width = Math.sqrt(trm[0] * trm[0] + trm[1] * trm[1]);
|
|
|
- }
|
|
|
- }
|
|
|
- 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];
|
|
|
- if (!glyph) { // Previous glyph was a space.
|
|
|
- width += textState.wordSpacing * textState.textHScale;
|
|
|
- continue;
|
|
|
- }
|
|
|
- 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 = 0;
|
|
|
- if (textChunk.str.length > 0) {
|
|
|
- // Apply char spacing only when there are chars.
|
|
|
- // As a result there is only spacing between glyphs.
|
|
|
- charSpacing = textState.charSpacing;
|
|
|
- }
|
|
|
-
|
|
|
- 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);
|
|
|
- }
|
|
|
-
|
|
|
- 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);
|
|
|
- if (!font.vertical) {
|
|
|
- textChunk.width += width * scaleCtmX * scaleLineX;
|
|
|
- } else {
|
|
|
- textChunk.height += Math.abs(height * scaleCtmX * scaleLineX);
|
|
|
- }
|
|
|
- return textChunk;
|
|
|
- }
|
|
|
-
|
|
|
- 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;
|
|
|
-
|
|
|
- switch (fn | 0) {
|
|
|
- case OPS.setFont:
|
|
|
- textState.fontSize = args[1];
|
|
|
- return handleSetFont(args[0].name).then(function() {
|
|
|
- next(resolve, reject);
|
|
|
- }, reject);
|
|
|
- case OPS.setTextRise:
|
|
|
- textState.textRise = args[0];
|
|
|
- break;
|
|
|
- case OPS.setHScale:
|
|
|
- textState.textHScale = args[0] / 100;
|
|
|
- break;
|
|
|
- case OPS.setLeading:
|
|
|
- textState.leading = args[0];
|
|
|
- break;
|
|
|
- case OPS.moveText:
|
|
|
- textState.translateTextLineMatrix(args[0], args[1]);
|
|
|
- textState.textMatrix = textState.textLineMatrix.slice();
|
|
|
- break;
|
|
|
- case OPS.setLeadingMoveText:
|
|
|
- textState.leading = -args[1];
|
|
|
- textState.translateTextLineMatrix(args[0], args[1]);
|
|
|
- textState.textMatrix = textState.textLineMatrix.slice();
|
|
|
- break;
|
|
|
- case OPS.nextLine:
|
|
|
- textState.carriageReturn();
|
|
|
- break;
|
|
|
- case OPS.setTextMatrix:
|
|
|
- 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:
|
|
|
- textState.textMatrix = IDENTITY_MATRIX.slice();
|
|
|
- textState.textLineMatrix = IDENTITY_MATRIX.slice();
|
|
|
- break;
|
|
|
- case OPS.showSpacedText:
|
|
|
- var items = args[0];
|
|
|
- var textChunk = newTextChunk();
|
|
|
- var offset;
|
|
|
- for (var j = 0, jj = items.length; j < jj; j++) {
|
|
|
- if (typeof items[j] === 'string') {
|
|
|
- buildTextGeometry(items[j], textChunk);
|
|
|
- } else {
|
|
|
- // 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.
|
|
|
- var val = items[j] * textState.fontSize / 1000;
|
|
|
- if (textState.font.vertical) {
|
|
|
- offset = val * textState.textMatrix[3];
|
|
|
- textState.translateTextMatrix(0, offset);
|
|
|
- // Value needs to be added to height to paint down.
|
|
|
- textChunk.height += offset;
|
|
|
- } else {
|
|
|
- offset = val * textState.textHScale *
|
|
|
- textState.textMatrix[0];
|
|
|
- textState.translateTextMatrix(offset, 0);
|
|
|
- // Value needs to be subtracted from width to paint left.
|
|
|
- textChunk.width -= offset;
|
|
|
- }
|
|
|
- if (items[j] < 0 && textState.font.spaceWidth > 0) {
|
|
|
- var fakeSpaces = -items[j] / textState.font.spaceWidth;
|
|
|
- if (fakeSpaces > MULTI_SPACE_FACTOR) {
|
|
|
- fakeSpaces = Math.round(fakeSpaces);
|
|
|
- while (fakeSpaces--) {
|
|
|
- textChunk.str.push(' ');
|
|
|
- }
|
|
|
- } else if (fakeSpaces > SPACE_FACTOR) {
|
|
|
- textChunk.str.push(' ');
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- bidiTexts.push(runBidi(textChunk));
|
|
|
- break;
|
|
|
- case OPS.showText:
|
|
|
- bidiTexts.push(runBidi(buildTextGeometry(args[0])));
|
|
|
- break;
|
|
|
- case OPS.nextLineShowText:
|
|
|
- textState.carriageReturn();
|
|
|
- bidiTexts.push(runBidi(buildTextGeometry(args[0])));
|
|
|
- break;
|
|
|
- case OPS.nextLineSetSpacingShowText:
|
|
|
- textState.wordSpacing = args[0];
|
|
|
- textState.charSpacing = args[1];
|
|
|
- textState.carriageReturn();
|
|
|
- bidiTexts.push(runBidi(buildTextGeometry(args[2])));
|
|
|
- break;
|
|
|
- case OPS.paintXObject:
|
|
|
- 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(bidiTexts, 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).
|
|
|
- then(function (formTextContent) {
|
|
|
- Util.appendToArray(bidiTexts, formTextContent.items);
|
|
|
- Util.extendObj(textContent.styles, formTextContent.styles);
|
|
|
- stateManager.restore();
|
|
|
-
|
|
|
- xobjsCache.key = name;
|
|
|
- xobjsCache.texts = formTextContent;
|
|
|
-
|
|
|
- next(resolve, reject);
|
|
|
- }, reject);
|
|
|
- case OPS.setGState:
|
|
|
- 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;
|
|
|
- }
|
|
|
- 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 (<something>, setFont, setTextMatrix,
|
|
|
- // showText, endText), include that as well. (E.g. <something> 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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.');
|
|
|
- }
|
|
|
- };
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-// 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;
|
|
|
-
|
|
|
-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 <compat> 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[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) {
|
|
|
- this.fontChar = fontChar;
|
|
|
- this.unicode = unicode;
|
|
|
- this.accent = accent;
|
|
|
- this.width = width;
|
|
|
- this.vmetric = vmetric;
|
|
|
- this.operatorListId = operatorListId;
|
|
|
- }
|
|
|
-
|
|
|
- Glyph.prototype.matchesForCache =
|
|
|
- function(fontChar, unicode, accent, width, vmetric, operatorListId) {
|
|
|
- return this.fontChar === fontChar &&
|
|
|
- this.unicode === unicode &&
|
|
|
- this.accent === accent &&
|
|
|
- this.width === width &&
|
|
|
- this.vmetric === vmetric &&
|
|
|
- this.operatorListId === operatorListId;
|
|
|
- };
|
|
|
-
|
|
|
- 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) {
|
|
|
- error('should not call .charCodeOf');
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- 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') {
|
|
|
- subtype = isType1File(file) ? 'CIDFontType0' : '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) {
|
|
|
- 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 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) {
|
|
|
- // Array.sort() sorts by characters, not numerically, so convert to an
|
|
|
- // array of characters.
|
|
|
- var codes = [];
|
|
|
- for (var charCode in glyphs) {
|
|
|
- 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) {
|
|
|
- var ranges = getRanges(glyphs);
|
|
|
- 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) {
|
|
|
- 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);
|
|
|
-
|
|
|
- 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.glyf || !tables.loca) {
|
|
|
- error('Required "glyf" or "loca" tables are not found');
|
|
|
- }
|
|
|
- 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;
|
|
|
- }
|
|
|
-
|
|
|
- // 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;
|
|
|
- } else {
|
|
|
- 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)
|
|
|
- };
|
|
|
-
|
|
|
- if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) {
|
|
|
- // extract some more font properties from the OpenType head and
|
|
|
- // hhea tables; yMin and descent value are always negative
|
|
|
- var override = {
|
|
|
- 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
|
|
|
- };
|
|
|
-
|
|
|
- tables['OS/2'] = {
|
|
|
- tag: 'OS/2',
|
|
|
- data: createOS2Table(properties, newMapping.charCodeToGlyphId,
|
|
|
- override)
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- // 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));
|
|
|
- // 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 && 'toUnicode' in this) {
|
|
|
- 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) {
|
|
|
- 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)) {
|
|
|
- glyph = new Glyph(fontChar, unicode, accent, width, vmetric,
|
|
|
- operatorListId);
|
|
|
- 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;
|
|
|
- glyph = this.charToGlyph(charcode);
|
|
|
- glyphs.push(glyph);
|
|
|
- // placing null after each word break charcode (ASCII SPACE)
|
|
|
- // Ignore occurences of 0x20 in multiple-byte codes.
|
|
|
- if (length === 1 && chars.charCodeAt(i - 1) === 0x20) {
|
|
|
- glyphs.push(null);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (i = 0, ii = chars.length; i < ii; ++i) {
|
|
|
- charcode = chars.charCodeAt(i);
|
|
|
- glyph = this.charToGlyph(charcode);
|
|
|
- glyphs.push(glyph);
|
|
|
- if (charcode === 0x20) {
|
|
|
- glyphs.push(null);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // 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 charStringsAndSeacs = this.parseCharStrings(charStringOffset);
|
|
|
- cff.charStrings = charStringsAndSeacs.charStrings;
|
|
|
- cff.seacs = charStringsAndSeacs.seacs;
|
|
|
- cff.widths = charStringsAndSeacs.widths;
|
|
|
-
|
|
|
- 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'),
|
|
|
- cff.charStrings.count, cff.strings, true);
|
|
|
- cff.fdSelect = this.parseFDSelect(topDict.getByName('FDSelect'),
|
|
|
- cff.charStrings.count);
|
|
|
- } else {
|
|
|
- charset = this.parseCharsets(topDict.getByName('charset'),
|
|
|
- cff.charStrings.count, cff.strings, false);
|
|
|
- encoding = this.parseEncoding(topDict.getByName('Encoding'),
|
|
|
- properties,
|
|
|
- cff.strings, charset.charset);
|
|
|
- }
|
|
|
- cff.charset = charset;
|
|
|
- cff.encoding = encoding;
|
|
|
-
|
|
|
- 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;
|
|
|
- },
|
|
|
- parseCharStrings: function CFFParser_parseCharStrings(charStringOffset) {
|
|
|
- var charStrings = this.parseIndex(charStringOffset).obj;
|
|
|
- var seacs = [];
|
|
|
- var widths = [];
|
|
|
- var count = charStrings.count;
|
|
|
- for (var i = 0; i < count; i++) {
|
|
|
- var charstring = charStrings.get(i);
|
|
|
-
|
|
|
- var stackSize = 0;
|
|
|
- var stack = [];
|
|
|
- var undefStack = true;
|
|
|
- var hints = 0;
|
|
|
- var valid = true;
|
|
|
- var data = charstring;
|
|
|
- var length = data.length;
|
|
|
- var firstStackClearing = true;
|
|
|
- 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) {
|
|
|
- seacs[i] = stack.slice(stackSize, stackSize + 4);
|
|
|
- valid = 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) {
|
|
|
- hints += stackSize >> 1;
|
|
|
- j += (hints + 7) >> 3; // skipping right amount of hints flag data
|
|
|
- stackSize %= 2;
|
|
|
- validationCommand = CharstringValidationData[value];
|
|
|
- } else {
|
|
|
- validationCommand = CharstringValidationData[value];
|
|
|
- }
|
|
|
- if (validationCommand) {
|
|
|
- if (validationCommand.stem) {
|
|
|
- hints += stackSize >> 1;
|
|
|
- }
|
|
|
- if ('min' in validationCommand) {
|
|
|
- if (!undefStack && stackSize < validationCommand.min) {
|
|
|
- warn('Not enough parameters for ' + validationCommand.id +
|
|
|
- '; actual: ' + stackSize +
|
|
|
- ', expected: ' + validationCommand.min);
|
|
|
- valid = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (firstStackClearing && validationCommand.stackClearing) {
|
|
|
- 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) {
|
|
|
- widths[i] = 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;
|
|
|
- undefStack = false;
|
|
|
- } else if (validationCommand.undefStack) {
|
|
|
- stackSize = 0;
|
|
|
- undefStack = true;
|
|
|
- firstStackClearing = false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- 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;
|
|
|
- }
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-// Workaround for seac on Windows.
|
|
|
-(function checkSeacSupport() {
|
|
|
- if (/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 (/Windows.*Chrome/.test(navigator.userAgent)) {
|
|
|
- SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = true;
|
|
|
- }
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-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)) {
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-// 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
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
- for (i = 0, j = 0; i < scanLength; i++) {
|
|
|
- var b = scanBytes[i];
|
|
|
- if (b !== ENDSTREAM_SIGNATURE[j]) {
|
|
|
- i -= j;
|
|
|
- j = 0;
|
|
|
- } else {
|
|
|
- j++;
|
|
|
- if (j >= ENDSTREAM_SIGNATURE_LENGTH) {
|
|
|
- i++;
|
|
|
- found = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (found) {
|
|
|
- skipped += i - ENDSTREAM_SIGNATURE_LENGTH;
|
|
|
- stream.pos += i - ENDSTREAM_SIGNATURE_LENGTH;
|
|
|
- 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;
|
|
|
- var strBuf = this.strBuf;
|
|
|
- strBuf.length = 0;
|
|
|
- while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
|
|
|
- if (ch === 0x23) { // '#'
|
|
|
- ch = this.nextChar();
|
|
|
- var x = toHexDigit(ch);
|
|
|
- if (x !== -1) {
|
|
|
- var x2 = toHexDigit(this.nextChar());
|
|
|
- if (x2 === -1) {
|
|
|
- error('Illegal digit in hex char in name: ' + x2);
|
|
|
- }
|
|
|
- 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)
|
|
|
- };
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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) {
|
|
|
- var pdfManager;
|
|
|
- var terminated = false;
|
|
|
- var cancelXHRs = null;
|
|
|
- var WorkerTasks = [];
|
|
|
-
|
|
|
- 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(source.data, source.password);
|
|
|
- pdfManagerCapability.resolve(pdfManager);
|
|
|
- } catch (ex) {
|
|
|
- pdfManagerCapability.reject(ex);
|
|
|
- }
|
|
|
- return pdfManagerCapability.promise;
|
|
|
- } else if (source.chunkedViewerLoading) {
|
|
|
- try {
|
|
|
- pdfManager = new NetworkPdfManager(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(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(pdfFile, source.password);
|
|
|
- pdfManagerCapability.resolve(pdfManager);
|
|
|
- } catch (ex) {
|
|
|
- pdfManagerCapability.reject(ex);
|
|
|
- }
|
|
|
- cancelXHRs = null;
|
|
|
- },
|
|
|
-
|
|
|
- onError: function onError(status) {
|
|
|
- var exception;
|
|
|
- if (status === 404) {
|
|
|
- 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;
|
|
|
- }
|
|
|
-
|
|
|
- handler.on('test', function wphSetupTest(data) {
|
|
|
- // check if Uint8Array can be sent to worker
|
|
|
- if (!(data instanceof Uint8Array)) {
|
|
|
- handler.send('test', 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) {
|
|
|
- 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('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', []);
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- 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
|
|
|
- }
|
|
|
-
|
|
|
- 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;
|
|
|
- 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).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 () {});
|
|
|
- });
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-var consoleTimer = {};
|
|
|
-
|
|
|
-var workerConsole = {
|
|
|
- log: function log() {
|
|
|
- var args = Array.prototype.slice.call(arguments);
|
|
|
- globalScope.postMessage({
|
|
|
- action: 'console_log',
|
|
|
- data: args
|
|
|
- });
|
|
|
- },
|
|
|
-
|
|
|
- error: function error() {
|
|
|
- var args = Array.prototype.slice.call(arguments);
|
|
|
- globalScope.postMessage({
|
|
|
- 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);
|
|
|
- }
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-// Worker thread?
|
|
|
-if (typeof window === 'undefined') {
|
|
|
- if (!('console' in globalScope)) {
|
|
|
- globalScope.console = workerConsole;
|
|
|
- }
|
|
|
-
|
|
|
- // Listen for unsupported features so we can pass them on to the main thread.
|
|
|
- PDFJS.UnsupportedManager.listen(function (msg) {
|
|
|
- globalScope.postMessage({
|
|
|
- action: '_unsupported_feature',
|
|
|
- data: msg
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- var handler = new MessageHandler('worker_processor', this);
|
|
|
- WorkerMessageHandler.setup(handler);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-/* 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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 precision = frame.precision;
|
|
|
- var samplesPerLine = frame.samplesPerLine;
|
|
|
- var scanLines = frame.scanLines;
|
|
|
- var mcusPerLine = frame.mcusPerLine;
|
|
|
- var progressive = frame.progressive;
|
|
|
- var maxH = frame.maxH, maxV = frame.maxV;
|
|
|
-
|
|
|
- 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, length = data.length;
|
|
|
- var jfif = null;
|
|
|
- var adobe = null;
|
|
|
- var pixels = 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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];
|
|
|
- var precedence = data[position + 1];
|
|
|
- var approximation = data[position + 2];
|
|
|
- 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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 pageStripingInformatiom = 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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
-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;
|
|
|
-})();
|
|
|
-
|
|
|
-
|
|
|
}).call((typeof window === 'undefined') ? this : window);
|
|
|
|
|
|
if (!PDFJS.workerSrc && typeof document !== 'undefined') {
|