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

Convert src/core/chunked_stream.js to ES6 syntax

Browse Source
This commit is contained in:
Tim van der Meij 2018-12-23 20:02:31 +01:00
parent 2e05827b87
commit 47344197f4
No known key found for this signature in database
GPG Key ID: 8C3FD2925A5F2762
1 changed files with 437 additions and 461 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

430
src/core/chunked_stream.js
View File

@ -18,8 +18,8 @@ import {
MissingDataException MissingDataException
} from '../shared/util'; } from '../shared/util';
var ChunkedStream = (function ChunkedStreamClosure() { class ChunkedStream {
function ChunkedStream(length, chunkSize, manager) { constructor(length, chunkSize, manager) {
this.bytes = new Uint8Array(length); this.bytes = new Uint8Array(length);
this.start = 0; this.start = 0;
this.pos = 0; this.pos = 0;
@ -30,79 +30,74 @@ var ChunkedStream = (function ChunkedStreamClosure() {
this.numChunks = Math.ceil(length / chunkSize); this.numChunks = Math.ceil(length / chunkSize);
this.manager = manager; this.manager = manager;
this.progressiveDataLength = 0; this.progressiveDataLength = 0;
this.lastSuccessfulEnsureByteChunk = -1; // a single-entry cache this.lastSuccessfulEnsureByteChunk = -1; // Single-entry cache
} }
// required methods for a stream. if a particular stream does not // If a particular stream does not implement one or more of these methods,
// implement these, an error should be thrown // an error should be thrown.
ChunkedStream.prototype = { getMissingChunks() {
const chunks = [];
getMissingChunks: function ChunkedStream_getMissingChunks() { for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
var chunks = [];
for (var chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
if (!this.loadedChunks[chunk]) { if (!this.loadedChunks[chunk]) {
chunks.push(chunk); chunks.push(chunk);
} }
} }
return chunks; return chunks;
}, }
getBaseStreams: function ChunkedStream_getBaseStreams() { getBaseStreams() {
return [this]; return [this];
}, }
allChunksLoaded: function ChunkedStream_allChunksLoaded() { allChunksLoaded() {
return this.numChunksLoaded === this.numChunks; return this.numChunksLoaded === this.numChunks;
}, }
onReceiveData: function ChunkedStream_onReceiveData(begin, chunk) { onReceiveData(begin, chunk) {
var end = begin + chunk.byteLength; const chunkSize = this.chunkSize;
if (begin % chunkSize !== 0) {
if (begin % this.chunkSize !== 0) {
throw new Error(`Bad begin offset: ${begin}`); throw new Error(`Bad begin offset: ${begin}`);
} }
// Using this.length is inaccurate here since this.start can be moved
// See ChunkedStream.moveStart() // Using `this.length` is inaccurate here since `this.start` can be moved
var length = this.bytes.length; // (see the `moveStart` method).
if (end % this.chunkSize !== 0 && end !== length) { const end = begin + chunk.byteLength;
if (end % chunkSize !== 0 && end !== this.bytes.length) {
throw new Error(`Bad end offset: ${end}`); throw new Error(`Bad end offset: ${end}`);
} }
this.bytes.set(new Uint8Array(chunk), begin); this.bytes.set(new Uint8Array(chunk), begin);
var chunkSize = this.chunkSize; const beginChunk = Math.floor(begin / chunkSize);
var beginChunk = Math.floor(begin / chunkSize); const endChunk = Math.floor((end - 1) / chunkSize) + 1;
var endChunk = Math.floor((end - 1) / chunkSize) + 1;
var curChunk;
for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) { for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
if (!this.loadedChunks[curChunk]) { if (!this.loadedChunks[curChunk]) {
this.loadedChunks[curChunk] = true; this.loadedChunks[curChunk] = true;
++this.numChunksLoaded; ++this.numChunksLoaded;
} }
} }
}, }
onReceiveProgressiveData: onReceiveProgressiveData(data) {
function ChunkedStream_onReceiveProgressiveData(data) { let position = this.progressiveDataLength;
var position = this.progressiveDataLength; const beginChunk = Math.floor(position / this.chunkSize);
var beginChunk = Math.floor(position / this.chunkSize);
this.bytes.set(new Uint8Array(data), position); this.bytes.set(new Uint8Array(data), position);
position += data.byteLength; position += data.byteLength;
this.progressiveDataLength = position; this.progressiveDataLength = position;
var endChunk = position >= this.end ? this.numChunks : const endChunk = position >= this.end ? this.numChunks :
Math.floor(position / this.chunkSize); Math.floor(position / this.chunkSize);
var curChunk;
for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) { for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
if (!this.loadedChunks[curChunk]) { if (!this.loadedChunks[curChunk]) {
this.loadedChunks[curChunk] = true; this.loadedChunks[curChunk] = true;
++this.numChunksLoaded; ++this.numChunksLoaded;
} }
} }
}, }
ensureByte: function ChunkedStream_ensureByte(pos) { ensureByte(pos) {
var chunk = Math.floor(pos / this.chunkSize); const chunk = Math.floor(pos / this.chunkSize);
if (chunk === this.lastSuccessfulEnsureByteChunk) { if (chunk === this.lastSuccessfulEnsureByteChunk) {
return; return;
} }
@ -111,169 +106,163 @@ var ChunkedStream = (function ChunkedStreamClosure() {
throw new MissingDataException(pos, pos + 1); throw new MissingDataException(pos, pos + 1);
} }
this.lastSuccessfulEnsureByteChunk = chunk; this.lastSuccessfulEnsureByteChunk = chunk;
}, }
ensureRange: function ChunkedStream_ensureRange(begin, end) { ensureRange(begin, end) {
if (begin >= end) { if (begin >= end) {
return; return;
} }
if (end <= this.progressiveDataLength) { if (end <= this.progressiveDataLength) {
return; return;
} }
var chunkSize = this.chunkSize; const chunkSize = this.chunkSize;
var beginChunk = Math.floor(begin / chunkSize); const beginChunk = Math.floor(begin / chunkSize);
var endChunk = Math.floor((end - 1) / chunkSize) + 1; const endChunk = Math.floor((end - 1) / chunkSize) + 1;
for (var chunk = beginChunk; chunk < endChunk; ++chunk) { for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
if (!this.loadedChunks[chunk]) { if (!this.loadedChunks[chunk]) {
throw new MissingDataException(begin, end); throw new MissingDataException(begin, end);
} }
} }
}, }
nextEmptyChunk: function ChunkedStream_nextEmptyChunk(beginChunk) { nextEmptyChunk(beginChunk) {
var chunk, numChunks = this.numChunks; const numChunks = this.numChunks;
for (var i = 0; i < numChunks; ++i) { for (let i = 0; i < numChunks; ++i) {
chunk = (beginChunk + i) % numChunks; // Wrap around to beginning const chunk = (beginChunk + i) % numChunks; // Wrap around to beginning.
if (!this.loadedChunks[chunk]) { if (!this.loadedChunks[chunk]) {
return chunk; return chunk;
} }
} }
return null; return null;
}, }
hasChunk: function ChunkedStream_hasChunk(chunk) { hasChunk(chunk) {
return !!this.loadedChunks[chunk]; return !!this.loadedChunks[chunk];
}, }
get length() { get length() {
return this.end - this.start; return this.end - this.start;
}, }
get isEmpty() { get isEmpty() {
return this.length === 0; return this.length === 0;
}, }
getByte: function ChunkedStream_getByte() { getByte() {
var pos = this.pos; const pos = this.pos;
if (pos >= this.end) { if (pos >= this.end) {
return -1; return -1;
} }
this.ensureByte(pos); this.ensureByte(pos);
return this.bytes[this.pos++]; return this.bytes[this.pos++];
}, }
getUint16: function ChunkedStream_getUint16() { getUint16() {
var b0 = this.getByte(); const b0 = this.getByte();
var b1 = this.getByte(); const b1 = this.getByte();
if (b0 === -1 || b1 === -1) { if (b0 === -1 || b1 === -1) {
return -1; return -1;
} }
return (b0 << 8) + b1; return (b0 << 8) + b1;
}, }
getInt32: function ChunkedStream_getInt32() { getInt32() {
var b0 = this.getByte(); const b0 = this.getByte();
var b1 = this.getByte(); const b1 = this.getByte();
var b2 = this.getByte(); const b2 = this.getByte();
var b3 = this.getByte(); const b3 = this.getByte();
return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3; return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
}, }
// Returns subarray of original buffer, should only be read. // Returns subarray of original buffer, should only be read.
getBytes(length, forceClamped = false) { getBytes(length, forceClamped = false) {
var bytes = this.bytes; const bytes = this.bytes;
var pos = this.pos; const pos = this.pos;
var strEnd = this.end; const strEnd = this.end;
if (!length) { if (!length) {
this.ensureRange(pos, strEnd); this.ensureRange(pos, strEnd);
let subarray = bytes.subarray(pos, strEnd); const subarray = bytes.subarray(pos, strEnd);
// `this.bytes` is always a `Uint8Array` here. // `this.bytes` is always a `Uint8Array` here.
return (forceClamped ? new Uint8ClampedArray(subarray) : subarray); return (forceClamped ? new Uint8ClampedArray(subarray) : subarray);
} }
var end = pos + length; let end = pos + length;
if (end > strEnd) { if (end > strEnd) {
end = strEnd; end = strEnd;
} }
this.ensureRange(pos, end); this.ensureRange(pos, end);
this.pos = end; this.pos = end;
let subarray = bytes.subarray(pos, end); const subarray = bytes.subarray(pos, end);
// `this.bytes` is always a `Uint8Array` here. // `this.bytes` is always a `Uint8Array` here.
return (forceClamped ? new Uint8ClampedArray(subarray) : subarray); return (forceClamped ? new Uint8ClampedArray(subarray) : subarray);
}, }
peekByte: function ChunkedStream_peekByte() { peekByte() {
var peekedByte = this.getByte(); const peekedByte = this.getByte();
this.pos--; this.pos--;
return peekedByte; return peekedByte;
}, }
peekBytes(length, forceClamped = false) { peekBytes(length, forceClamped = false) {
var bytes = this.getBytes(length, forceClamped); const bytes = this.getBytes(length, forceClamped);
this.pos -= bytes.length; this.pos -= bytes.length;
return bytes; return bytes;
}, }
getByteRange: function ChunkedStream_getBytes(begin, end) { getByteRange(begin, end) {
this.ensureRange(begin, end); this.ensureRange(begin, end);
return this.bytes.subarray(begin, end); return this.bytes.subarray(begin, end);
}, }
skip: function ChunkedStream_skip(n) { skip(n) {
if (!n) { if (!n) {
n = 1; n = 1;
} }
this.pos += n; this.pos += n;
}, }
reset: function ChunkedStream_reset() { reset() {
this.pos = this.start; this.pos = this.start;
}, }
moveStart: function ChunkedStream_moveStart() { moveStart() {
this.start = this.pos; this.start = this.pos;
}, }
makeSubStream: function ChunkedStream_makeSubStream(start, length, dict) { makeSubStream(start, length, dict) {
this.ensureRange(start, start + length); this.ensureRange(start, start + length);
function ChunkedStreamSubstream() {} function ChunkedStreamSubstream() {}
ChunkedStreamSubstream.prototype = Object.create(this); ChunkedStreamSubstream.prototype = Object.create(this);
ChunkedStreamSubstream.prototype.getMissingChunks = function() { ChunkedStreamSubstream.prototype.getMissingChunks = function() {
var chunkSize = this.chunkSize; const chunkSize = this.chunkSize;
var beginChunk = Math.floor(this.start / chunkSize); const beginChunk = Math.floor(this.start / chunkSize);
var endChunk = Math.floor((this.end - 1) / chunkSize) + 1; const endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
var missingChunks = []; const missingChunks = [];
for (var chunk = beginChunk; chunk < endChunk; ++chunk) { for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
if (!this.loadedChunks[chunk]) { if (!this.loadedChunks[chunk]) {
missingChunks.push(chunk); missingChunks.push(chunk);
} }
} }
return missingChunks; return missingChunks;
}; };
var subStream = new ChunkedStreamSubstream();
const subStream = new ChunkedStreamSubstream();
subStream.pos = subStream.start = start; subStream.pos = subStream.start = start;
subStream.end = start + length || this.end; subStream.end = start + length || this.end;
subStream.dict = dict; subStream.dict = dict;
return subStream; return subStream;
}, }
}; }
return ChunkedStream; class ChunkedStreamManager {
})(); constructor(pdfNetworkStream, args) {
this.length = args.length;
var ChunkedStreamManager = (function ChunkedStreamManagerClosure() { this.chunkSize = args.rangeChunkSize;
this.stream = new ChunkedStream(this.length, this.chunkSize, this);
function ChunkedStreamManager(pdfNetworkStream, args) {
var chunkSize = args.rangeChunkSize;
var length = args.length;
this.stream = new ChunkedStream(length, chunkSize, this);
this.length = length;
this.chunkSize = chunkSize;
this.pdfNetworkStream = pdfNetworkStream; this.pdfNetworkStream = pdfNetworkStream;
this.url = args.url; this.url = args.url;
this.disableAutoFetch = args.disableAutoFetch; this.disableAutoFetch = args.disableAutoFetch;
@ -290,32 +279,31 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
this._loadedStreamCapability = createPromiseCapability(); this._loadedStreamCapability = createPromiseCapability();
} }
ChunkedStreamManager.prototype = { onLoadedStream() {
onLoadedStream: function ChunkedStreamManager_getLoadedStream() {
return this._loadedStreamCapability.promise; return this._loadedStreamCapability.promise;
}, }
sendRequest: function ChunkedStreamManager_sendRequest(begin, end) { sendRequest(begin, end) {
var rangeReader = this.pdfNetworkStream.getRangeReader(begin, end); const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
if (!rangeReader.isStreamingSupported) { if (!rangeReader.isStreamingSupported) {
rangeReader.onProgress = this.onProgress.bind(this); rangeReader.onProgress = this.onProgress.bind(this);
} }
var chunks = [], loaded = 0;
var manager = this; let chunks = [], loaded = 0;
var promise = new Promise(function (resolve, reject) { const promise = new Promise((resolve, reject) => {
var readChunk = function (chunk) { const readChunk = (chunk) => {
try { try {
if (!chunk.done) { if (!chunk.done) {
var data = chunk.value; const data = chunk.value;
chunks.push(data); chunks.push(data);
loaded += arrayByteLength(data); loaded += arrayByteLength(data);
if (rangeReader.isStreamingSupported) { if (rangeReader.isStreamingSupported) {
manager.onProgress({ loaded, }); this.onProgress({ loaded, });
} }
rangeReader.read().then(readChunk, reject); rangeReader.read().then(readChunk, reject);
return; return;
} }
var chunkData = arraysToBytes(chunks); const chunkData = arraysToBytes(chunks);
chunks = null; chunks = null;
resolve(chunkData); resolve(chunkData);
} catch (e) { } catch (e) {
@ -326,30 +314,31 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
}); });
promise.then((data) => { promise.then((data) => {
if (this.aborted) { if (this.aborted) {
return; // ignoring any data after abort return; // Ignoring any data after abort.
} }
this.onReceiveData({ chunk: data, begin, }); this.onReceiveData({ chunk: data, begin, });
}); });
// TODO check errors // TODO check errors
}, }
// Get all the chunks that are not yet loaded and groups them into /**
// contiguous ranges to load in as few requests as possible * Get all the chunks that are not yet loaded and group them into
requestAllChunks: function ChunkedStreamManager_requestAllChunks() { * contiguous ranges to load in as few requests as possible.
var missingChunks = this.stream.getMissingChunks(); */
requestAllChunks() {
const missingChunks = this.stream.getMissingChunks();
this._requestChunks(missingChunks); this._requestChunks(missingChunks);
return this._loadedStreamCapability.promise; return this._loadedStreamCapability.promise;
}, }
_requestChunks: function ChunkedStreamManager_requestChunks(chunks) { _requestChunks(chunks) {
var requestId = this.currRequestId++; const requestId = this.currRequestId++;
var i, ii; const chunksNeeded = Object.create(null);
var chunksNeeded = Object.create(null);
this.chunksNeededByRequest[requestId] = chunksNeeded; this.chunksNeededByRequest[requestId] = chunksNeeded;
for (i = 0, ii = chunks.length; i < ii; i++) { for (const chunk of chunks) {
if (!this.stream.hasChunk(chunks[i])) { if (!this.stream.hasChunk(chunk)) {
chunksNeeded[chunks[i]] = true; chunksNeeded[chunk] = true;
} }
} }
@ -357,11 +346,11 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
return Promise.resolve(); return Promise.resolve();
} }
var capability = createPromiseCapability(); const capability = createPromiseCapability();
this.promisesByRequest[requestId] = capability; this.promisesByRequest[requestId] = capability;
var chunksToRequest = []; const chunksToRequest = [];
for (var chunk in chunksNeeded) { for (let chunk in chunksNeeded) {
chunk = chunk | 0; chunk = chunk | 0;
if (!(chunk in this.requestsByChunk)) { if (!(chunk in this.requestsByChunk)) {
this.requestsByChunk[chunk] = []; this.requestsByChunk[chunk] = [];
@ -374,46 +363,42 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
return capability.promise; return capability.promise;
} }
var groupedChunksToRequest = this.groupChunks(chunksToRequest); const groupedChunksToRequest = this.groupChunks(chunksToRequest);
for (const groupedChunk of groupedChunksToRequest) {
for (i = 0; i < groupedChunksToRequest.length; ++i) { const begin = groupedChunk.beginChunk * this.chunkSize;
var groupedChunk = groupedChunksToRequest[i]; const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
var begin = groupedChunk.beginChunk * this.chunkSize;
var end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
this.sendRequest(begin, end); this.sendRequest(begin, end);
} }
return capability.promise; 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);
} }
getStream() {
return this.stream;
}
/**
* Loads any chunks in the requested range that are not yet loaded.
*/
requestRange(begin, end) {
end = Math.min(end, this.length);
const beginChunk = this.getBeginChunk(begin);
const endChunk = this.getEndChunk(end);
const chunks = [];
for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
chunks.push(chunk);
}
return this._requestChunks(chunks); return this._requestChunks(chunks);
}, }
requestRanges: function ChunkedStreamManager_requestRanges(ranges) { requestRanges(ranges = []) {
ranges = ranges || []; const chunksToRequest = [];
var chunksToRequest = []; for (const range of ranges) {
const beginChunk = this.getBeginChunk(range.begin);
for (var i = 0; i < ranges.length; i++) { const endChunk = this.getEndChunk(range.end);
var beginChunk = this.getBeginChunk(ranges[i].begin); for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
var endChunk = this.getEndChunk(ranges[i].end);
for (var chunk = beginChunk; chunk < endChunk; ++chunk) {
if (!chunksToRequest.includes(chunk)) { if (!chunksToRequest.includes(chunk)) {
chunksToRequest.push(chunk); chunksToRequest.push(chunk);
} }
@ -424,17 +409,19 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
return a - b; return a - b;
}); });
return this._requestChunks(chunksToRequest); return this._requestChunks(chunksToRequest);
}, }
// Groups a sorted array of chunks into as few contiguous larger /**
// chunks as possible * Groups a sorted array of chunks into as few contiguous larger
groupChunks: function ChunkedStreamManager_groupChunks(chunks) { * chunks as possible.
var groupedChunks = []; */
var beginChunk = -1; groupChunks(chunks) {
var prevChunk = -1; const groupedChunks = [];
for (var i = 0; i < chunks.length; ++i) { let beginChunk = -1;
var chunk = chunks[i]; let prevChunk = -1;
for (let i = 0, ii = chunks.length; i < ii; ++i) {
const chunk = chunks[i];
if (beginChunk < 0) { if (beginChunk < 0) {
beginChunk = chunk; beginChunk = chunk;
} }
@ -452,25 +439,23 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
prevChunk = chunk; prevChunk = chunk;
} }
return groupedChunks; return groupedChunks;
}, }
onProgress: function ChunkedStreamManager_onProgress(args) { onProgress(args) {
var bytesLoaded = (this.stream.numChunksLoaded * this.chunkSize +
args.loaded);
this.msgHandler.send('DocProgress', { this.msgHandler.send('DocProgress', {
loaded: bytesLoaded, loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
total: this.length, total: this.length,
}); });
}, }
onReceiveData: function ChunkedStreamManager_onReceiveData(args) { onReceiveData(args) {
var chunk = args.chunk; let chunk = args.chunk;
var isProgressive = args.begin === undefined; const isProgressive = args.begin === undefined;
var begin = isProgressive ? this.progressiveDataLength : args.begin; const begin = isProgressive ? this.progressiveDataLength : args.begin;
var end = begin + chunk.byteLength; const end = begin + chunk.byteLength;
var beginChunk = Math.floor(begin / this.chunkSize); const beginChunk = Math.floor(begin / this.chunkSize);
var endChunk = end < this.length ? Math.floor(end / this.chunkSize) : const endChunk = end < this.length ? Math.floor(end / this.chunkSize) :
Math.ceil(end / this.chunkSize); Math.ceil(end / this.chunkSize);
if (isProgressive) { if (isProgressive) {
@ -484,16 +469,14 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
this._loadedStreamCapability.resolve(this.stream); this._loadedStreamCapability.resolve(this.stream);
} }
var loadedRequests = []; const loadedRequests = [];
var i, requestId; for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
for (chunk = beginChunk; chunk < endChunk; ++chunk) { // The server might return more chunks than requested.
// The server might return more chunks than requested const requestIds = this.requestsByChunk[chunk] || [];
var requestIds = this.requestsByChunk[chunk] || [];
delete this.requestsByChunk[chunk]; delete this.requestsByChunk[chunk];
for (i = 0; i < requestIds.length; ++i) { for (const requestId of requestIds) {
requestId = requestIds[i]; const chunksNeeded = this.chunksNeededByRequest[requestId];
var chunksNeeded = this.chunksNeededByRequest[requestId];
if (chunk in chunksNeeded) { if (chunk in chunksNeeded) {
delete chunksNeeded[chunk]; delete chunksNeeded[chunk];
} }
@ -501,20 +484,19 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
if (!isEmptyObj(chunksNeeded)) { if (!isEmptyObj(chunksNeeded)) {
continue; continue;
} }
loadedRequests.push(requestId); loadedRequests.push(requestId);
} }
} }
// If there are no pending requests, automatically fetch the next // If there are no pending requests, automatically fetch the next
// unfetched chunk of the PDF // unfetched chunk of the PDF file.
if (!this.disableAutoFetch && isEmptyObj(this.requestsByChunk)) { if (!this.disableAutoFetch && isEmptyObj(this.requestsByChunk)) {
var nextEmptyChunk; let nextEmptyChunk;
if (this.stream.numChunksLoaded === 1) { if (this.stream.numChunksLoaded === 1) {
// This is a special optimization so that after fetching the first // This is a special optimization so that after fetching the first
// chunk, rather than fetching the second chunk, we fetch the last // chunk, rather than fetching the second chunk, we fetch the last
// chunk. // chunk.
var lastChunk = this.stream.numChunks - 1; const lastChunk = this.stream.numChunks - 1;
if (!this.stream.hasChunk(lastChunk)) { if (!this.stream.hasChunk(lastChunk)) {
nextEmptyChunk = lastChunk; nextEmptyChunk = lastChunk;
} }
@ -526,9 +508,8 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
} }
} }
for (i = 0; i < loadedRequests.length; ++i) { for (const requestId of loadedRequests) {
requestId = loadedRequests[i]; const capability = this.promisesByRequest[requestId];
var capability = this.promisesByRequest[requestId];
delete this.promisesByRequest[requestId]; delete this.promisesByRequest[requestId];
capability.resolve(); capability.resolve();
} }
@ -537,36 +518,31 @@ var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {
loaded: this.stream.numChunksLoaded * this.chunkSize, loaded: this.stream.numChunksLoaded * this.chunkSize,
total: this.length, total: this.length,
}); });
}, }
onError: function ChunkedStreamManager_onError(err) { onError(err) {
this._loadedStreamCapability.reject(err); this._loadedStreamCapability.reject(err);
}, }
getBeginChunk: function ChunkedStreamManager_getBeginChunk(begin) { getBeginChunk(begin) {
var chunk = Math.floor(begin / this.chunkSize); return Math.floor(begin / this.chunkSize);
return chunk; }
},
getEndChunk: function ChunkedStreamManager_getEndChunk(end) { getEndChunk(end) {
var chunk = Math.floor((end - 1) / this.chunkSize) + 1; return Math.floor((end - 1) / this.chunkSize) + 1;
return chunk; }
},
abort: function ChunkedStreamManager_abort() { abort() {
this.aborted = true; this.aborted = true;
if (this.pdfNetworkStream) { if (this.pdfNetworkStream) {
this.pdfNetworkStream.cancelAllRequests('abort'); this.pdfNetworkStream.cancelAllRequests('abort');
} }
for (var requestId in this.promisesByRequest) { for (const requestId in this.promisesByRequest) {
var capability = this.promisesByRequest[requestId]; this.promisesByRequest[requestId].reject(
capability.reject(new Error('Request was aborted')); new Error('Request was aborted'));
} }
}, }
}; }
return ChunkedStreamManager;
})();
export { export {
ChunkedStream, ChunkedStream,