Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #13030 from Snuffleupagus/cmap-class-async

Browse Source 
Modernize some of the code in `src/core/cmap.js` by using classes and async/await
This commit is contained in:
Tim van der Meij 2021-02-27 16:11:37 +01:00 committed by GitHub
commit 8e74278b65
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 79 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
src/core/cmap.js
View File

@ -479,20 +479,21 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
var MAX_NUM_SIZE = 16; var MAX_NUM_SIZE = 16;
var MAX_ENCODED_NUM_SIZE = 19; // ceil(MAX_NUM_SIZE * 7 / 8) var MAX_ENCODED_NUM_SIZE = 19; // ceil(MAX_NUM_SIZE * 7 / 8)
function BinaryCMapStream(data) { class BinaryCMapStream {
this.buffer = data; constructor(data) {
this.pos = 0; this.buffer = data;
this.end = data.length; this.pos = 0;
this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE); this.end = data.length;
} this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
}
BinaryCMapStream.prototype = {
readByte() { readByte() {
if (this.pos >= this.end) { if (this.pos >= this.end) {
return -1; return -1;
} }
return this.buffer[this.pos++]; return this.buffer[this.pos++];
}, }
readNumber() { readNumber() {
var n = 0; var n = 0;
var last; var last;
@ -505,15 +506,18 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
n = (n << 7) | (b & 0x7f); n = (n << 7) | (b & 0x7f);
} while (!last); } while (!last);
return n; return n;
}, }
readSigned() { readSigned() {
var n = this.readNumber(); var n = this.readNumber();
return n & 1 ? ~(n >>> 1) : n >>> 1; return n & 1 ? ~(n >>> 1) : n >>> 1;
}, }
readHex(num, size) { readHex(num, size) {
num.set(this.buffer.subarray(this.pos, this.pos + size + 1)); num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
this.pos += size + 1; this.pos += size + 1;
}, }
readHexNumber(num, size) { readHexNumber(num, size) {
var last; var last;
var stack = this.tmpBuf, var stack = this.tmpBuf,
@ -539,7 +543,8 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
buffer >>= 8; buffer >>= 8;
bufferSize -= 8; bufferSize -= 8;
} }
}, }
readHexSigned(num, size) { readHexSigned(num, size) {
this.readHexNumber(num, size); this.readHexNumber(num, size);
var sign = num[size] & 1 ? 255 : 0; var sign = num[size] & 1 ? 255 : 0;
@ -548,7 +553,8 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
c = ((c & 1) << 8) | num[i]; c = ((c & 1) << 8) | num[i];
num[i] = (c >> 1) ^ sign; num[i] = (c >> 1) ^ sign;
} }
}, }
readString() { readString() {
var len = this.readNumber(); var len = this.readNumber();
var s = ""; var s = "";
@ -556,11 +562,12 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
s += String.fromCharCode(this.readNumber()); s += String.fromCharCode(this.readNumber());
} }
return s; return s;
}, }
}; }
function processBinaryCMap(data, cMap, extend) { // eslint-disable-next-line no-shadow
return new Promise(function (resolve, reject) { class BinaryCMapReader {
async process(data, cMap, extend) {
var stream = new BinaryCMapStream(data); var stream = new BinaryCMapStream(data);
var header = stream.readByte(); var header = stream.readByte();
cMap.vertical = !!(header & 1); cMap.vertical = !!(header & 1);
@ -592,7 +599,7 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
var dataSize = b & 15; var dataSize = b & 15;
if (dataSize + 1 > MAX_NUM_SIZE) { if (dataSize + 1 > MAX_NUM_SIZE) {
throw new Error("processBinaryCMap: Invalid dataSize."); throw new Error("BinaryCMapReader.process: Invalid dataSize.");
} }
var ucs2DataSize = 1; var ucs2DataSize = 1;
@ -730,26 +737,17 @@ var BinaryCMapReader = (function BinaryCMapReaderClosure() {
} }
break; break;
default: default:
reject(new Error("processBinaryCMap: Unknown type: " + type)); throw new Error(`BinaryCMapReader.process - unknown type: ${type}`);
return;
} }
} }
if (useCMap) { if (useCMap) {
resolve(extend(useCMap)); return extend(useCMap);
return;
} }
resolve(cMap); return cMap;
}); }
} }
// eslint-disable-next-line no-shadow
function BinaryCMapReader() {}
BinaryCMapReader.prototype = {
process: processBinaryCMap,
};
return BinaryCMapReader; return BinaryCMapReader;
})(); })();
@ -902,7 +900,7 @@ var CMapFactory = (function CMapFactoryClosure() {
} }
} }
function parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap) { async function parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap) {
var previous; var previous;
var embeddedUseCMap; var embeddedUseCMap;
objLoop: while (true) { objLoop: while (true) {
@ -960,74 +958,59 @@ var CMapFactory = (function CMapFactoryClosure() {
if (useCMap) { if (useCMap) {
return extendCMap(cMap, fetchBuiltInCMap, useCMap); return extendCMap(cMap, fetchBuiltInCMap, useCMap);
} }
return Promise.resolve(cMap); return cMap;
} }
function extendCMap(cMap, fetchBuiltInCMap, useCMap) { async function extendCMap(cMap, fetchBuiltInCMap, useCMap) {
return createBuiltInCMap(useCMap, fetchBuiltInCMap).then(function ( cMap.useCMap = await createBuiltInCMap(useCMap, fetchBuiltInCMap);
newCMap // If there aren't any code space ranges defined clone all the parent ones
) { // into this cMap.
cMap.useCMap = newCMap; if (cMap.numCodespaceRanges === 0) {
// If there aren't any code space ranges defined clone all the parent ones var useCodespaceRanges = cMap.useCMap.codespaceRanges;
// into this cMap. for (var i = 0; i < useCodespaceRanges.length; i++) {
if (cMap.numCodespaceRanges === 0) { cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();
var useCodespaceRanges = cMap.useCMap.codespaceRanges; }
for (var i = 0; i < useCodespaceRanges.length; i++) { cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;
cMap.codespaceRanges[i] = useCodespaceRanges[i].slice(); }
} // Merge the map into the current one, making sure not to override
cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges; // any previously defined entries.
cMap.useCMap.forEach(function (key, value) {
if (!cMap.contains(key)) {
cMap.mapOne(key, cMap.useCMap.lookup(key));
} }
// 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));
}
});
return cMap;
}); });
return cMap;
} }
function createBuiltInCMap(name, fetchBuiltInCMap) { async function createBuiltInCMap(name, fetchBuiltInCMap) {
if (name === "Identity-H") { if (name === "Identity-H") {
return Promise.resolve(new IdentityCMap(false, 2)); return new IdentityCMap(false, 2);
} else if (name === "Identity-V") { } else if (name === "Identity-V") {
return Promise.resolve(new IdentityCMap(true, 2)); return new IdentityCMap(true, 2);
} }
if (!BUILT_IN_CMAPS.includes(name)) { if (!BUILT_IN_CMAPS.includes(name)) {
return Promise.reject(new Error("Unknown CMap name: " + name)); throw new Error("Unknown CMap name: " + name);
} }
if (!fetchBuiltInCMap) { if (!fetchBuiltInCMap) {
return Promise.reject( throw new Error("Built-in CMap parameters are not provided.");
new Error("Built-in CMap parameters are not provided.")
);
} }
return fetchBuiltInCMap(name).then(function (data) { const { cMapData, compressionType } = await fetchBuiltInCMap(name);
var cMapData = data.cMapData, var cMap = new CMap(true);
compressionType = data.compressionType;
var cMap = new CMap(true);
if (compressionType === CMapCompressionType.BINARY) { if (compressionType === CMapCompressionType.BINARY) {
return new BinaryCMapReader().process( return new BinaryCMapReader().process(cMapData, cMap, useCMap => {
cMapData, return extendCMap(cMap, fetchBuiltInCMap, useCMap);
cMap, });
function (useCMap) { }
return extendCMap(cMap, fetchBuiltInCMap, useCMap); if (compressionType === CMapCompressionType.NONE) {
} var lexer = new Lexer(new Stream(cMapData));
); return parseCMap(cMap, lexer, fetchBuiltInCMap, null);
} }
if (compressionType === CMapCompressionType.NONE) { throw new Error(
var lexer = new Lexer(new Stream(cMapData)); "TODO: Only BINARY/NONE CMap compression is currently supported."
return parseCMap(cMap, lexer, fetchBuiltInCMap, null); );
}
return Promise.reject(
new Error(
"TODO: Only BINARY/NONE CMap compression is currently supported."
)
);
});
} }
return { return {
@ -1039,16 +1022,17 @@ var CMapFactory = (function CMapFactoryClosure() {
if (isName(encoding)) { if (isName(encoding)) {
return createBuiltInCMap(encoding.name, fetchBuiltInCMap); return createBuiltInCMap(encoding.name, fetchBuiltInCMap);
} else if (isStream(encoding)) { } else if (isStream(encoding)) {
var cMap = new CMap(); const parsedCMap = await parseCMap(
var lexer = new Lexer(encoding); /* cMap = */ new CMap(),
return parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap).then(function ( /* lexer = */ new Lexer(encoding),
parsedCMap fetchBuiltInCMap,
) { useCMap
if (parsedCMap.isIdentityCMap) { );
return createBuiltInCMap(parsedCMap.name, fetchBuiltInCMap);
} if (parsedCMap.isIdentityCMap) {
return parsedCMap; return createBuiltInCMap(parsedCMap.name, fetchBuiltInCMap);
}); }
return parsedCMap;
} }
throw new Error("Encoding required."); throw new Error("Encoding required.");
}, },