Lines Matching refs:stream
529 pdfManager.onLoadedStream().then(function (stream) {
531 length: stream.bytes.byteLength
599 return pdfManager.onLoadedStream().then(function (stream) {
600 return stream.bytes;
6845 function AcquireWritableStreamDefaultWriter(stream) {
6846 return new WritableStreamDefaultWriter(stream);
6861 function IsWritableStreamLocked(stream) {
6862 …assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known wri…
6864 if (stream._writer === undefined) {
6871 function WritableStreamAbort(stream, reason) {
6872 var state = stream._state;
6879 return Promise.reject(stream._storedError);
6884 if (stream._pendingAbortRequest !== undefined) {
6897 stream._pendingAbortRequest = {
6906 WritableStreamStartErroring(stream, error);
6912 function WritableStreamAddWriteRequest(stream) {
6913 assert(IsWritableStreamLocked(stream) === true);
6914 assert(stream._state === 'writable');
6921 stream._writeRequests.push(writeRequest);
6926 function WritableStreamDealWithRejection(stream, error) {
6927 var state = stream._state;
6930 WritableStreamStartErroring(stream, error);
6935 WritableStreamFinishErroring(stream);
6938 function WritableStreamStartErroring(stream, reason) {
6939 assert(stream._storedError === undefined, 'stream._storedError === undefined');
6940 assert(stream._state === 'writable', 'state must be writable');
6941 var controller = stream._writableStreamController;
6943 stream._state = 'erroring';
6944 stream._storedError = reason;
6945 var writer = stream._writer;
6951 … if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
6952 WritableStreamFinishErroring(stream);
6956 function WritableStreamFinishErroring(stream) {
6957 assert(stream._state === 'erroring', 'stream._state === erroring');
6958 …assert(WritableStreamHasOperationMarkedInFlight(stream) === false, 'WritableStreamHasOperationMark…
6959 stream._state = 'errored';
6961 stream._writableStreamController.__errorSteps();
6963 var storedError = stream._storedError;
6965 for (var i = 0; i < stream._writeRequests.length; i++) {
6966 var writeRequest = stream._writeRequests[i];
6971 stream._writeRequests = [];
6973 if (stream._pendingAbortRequest === undefined) {
6974 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6978 var abortRequest = stream._pendingAbortRequest;
6979 stream._pendingAbortRequest = undefined;
6984 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6988 var promise = stream._writableStreamController.__abortSteps(abortRequest._reason);
6993 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6997 WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
7001 function WritableStreamFinishInFlightWrite(stream) {
7002 assert(stream._inFlightWriteRequest !== undefined);
7004 stream._inFlightWriteRequest._resolve(undefined);
7006 stream._inFlightWriteRequest = undefined;
7009 function WritableStreamFinishInFlightWriteWithError(stream, error) {
7010 assert(stream._inFlightWriteRequest !== undefined);
7012 stream._inFlightWriteRequest._reject(error);
7014 stream._inFlightWriteRequest = undefined;
7015 assert(stream._state === 'writable' || stream._state === 'erroring');
7016 WritableStreamDealWithRejection(stream, error);
7019 function WritableStreamFinishInFlightClose(stream) {
7020 assert(stream._inFlightCloseRequest !== undefined);
7022 stream._inFlightCloseRequest._resolve(undefined);
7024 stream._inFlightCloseRequest = undefined;
7025 var state = stream._state;
7029 stream._storedError = undefined;
7031 if (stream._pendingAbortRequest !== undefined) {
7032 stream._pendingAbortRequest._resolve();
7034 stream._pendingAbortRequest = undefined;
7038 stream._state = 'closed';
7039 var writer = stream._writer;
7045 assert(stream._pendingAbortRequest === undefined, 'stream._pendingAbortRequest === undefined');
7046 assert(stream._storedError === undefined, 'stream._storedError === undefined');
7049 function WritableStreamFinishInFlightCloseWithError(stream, error) {
7050 assert(stream._inFlightCloseRequest !== undefined);
7052 stream._inFlightCloseRequest._reject(error);
7054 stream._inFlightCloseRequest = undefined;
7055 assert(stream._state === 'writable' || stream._state === 'erroring');
7057 if (stream._pendingAbortRequest !== undefined) {
7058 stream._pendingAbortRequest._reject(error);
7060 stream._pendingAbortRequest = undefined;
7063 WritableStreamDealWithRejection(stream, error);
7066 function WritableStreamCloseQueuedOrInFlight(stream) {
7067 if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
7074 function WritableStreamHasOperationMarkedInFlight(stream) {
7075 if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
7082 function WritableStreamMarkCloseRequestInFlight(stream) {
7083 assert(stream._inFlightCloseRequest === undefined);
7084 assert(stream._closeRequest !== undefined);
7085 stream._inFlightCloseRequest = stream._closeRequest;
7086 stream._closeRequest = undefined;
7089 function WritableStreamMarkFirstWriteRequestInFlight(stream) {
7090 assert(stream._inFlightWriteRequest === undefined, 'there must be no pending write request');
7091 assert(stream._writeRequests.length !== 0, 'writeRequests must not be empty');
7092 stream._inFlightWriteRequest = stream._writeRequests.shift();
7095 function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
7096 assert(stream._state === 'errored', '_stream_.[[state]] is `"errored"`');
7098 if (stream._closeRequest !== undefined) {
7099 assert(stream._inFlightCloseRequest === undefined);
7101 stream._closeRequest._reject(stream._storedError);
7103 stream._closeRequest = undefined;
7106 var writer = stream._writer;
7109 defaultWriterClosedPromiseReject(writer, stream._storedError);
7115 function WritableStreamUpdateBackpressure(stream, backpressure) {
7116 assert(stream._state === 'writable');
7117 assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
7118 var writer = stream._writer;
7120 if (writer !== undefined && backpressure !== stream._backpressure) {
7129 stream._backpressure = backpressure;
7133 function WritableStreamDefaultWriter(stream) {
7136 if (IsWritableStream(stream) === false) {
7140 if (IsWritableStreamLocked(stream) === true) {
7144 this._ownerWritableStream = stream;
7145 stream._writer = this;
7146 var state = stream._state;
7149 … if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
7157 defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
7167 var storedError = stream._storedError;
7198 var stream = this._ownerWritableStream;
7200 if (stream === undefined) {
7204 if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
7217 var stream = this._ownerWritableStream;
7219 if (stream === undefined) {
7223 assert(stream._writer !== undefined);
7288 var stream = writer._ownerWritableStream;
7289 assert(stream !== undefined);
7290 return WritableStreamAbort(stream, reason);
7294 var stream = writer._ownerWritableStream;
7295 assert(stream !== undefined);
7296 var state = stream._state;
7303 assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
7309 stream._closeRequest = closeRequest;
7312 if (stream._backpressure === true && state === 'writable') {
7316 WritableStreamDefaultControllerClose(stream._writableStreamController);
7321 var stream = writer._ownerWritableStream;
7322 assert(stream !== undefined);
7323 var state = stream._state;
7325 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
7330 return Promise.reject(stream._storedError);
7358 var stream = writer._ownerWritableStream;
7359 var state = stream._state;
7369 return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
7373 var stream = writer._ownerWritableStream;
7374 assert(stream !== undefined);
7375 assert(stream._writer === writer);
7379 stream._writer = undefined;
7384 var stream = writer._ownerWritableStream;
7385 assert(stream !== undefined);
7386 var controller = stream._writableStreamController;
7389 if (stream !== writer._ownerWritableStream) {
7393 var state = stream._state;
7396 return Promise.reject(stream._storedError);
7399 if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
7404 return Promise.reject(stream._storedError);
7408 var promise = WritableStreamAddWriteRequest(stream);
7414 function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
7417 if (IsWritableStream(stream) === false) {
7421 if (stream._writableStreamController !== undefined) {
7425 this._controlledWritableStream = stream;
7435 WritableStreamUpdateBackpressure(stream, backpressure);
7469 var stream = this._controlledWritableStream;
7471 assert(stream._state === 'writable' || stream._state === 'erroring');
7475 assert(stream._state === 'writable' || stream._state === 'erroring');
7477 WritableStreamDealWithRejection(stream, r);
7521 var stream = controller._controlledWritableStream;
7523 if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {
7525 WritableStreamUpdateBackpressure(stream, backpressure);
7544 var stream = controller._controlledWritableStream;
7550 if (stream._inFlightWriteRequest !== undefined) {
7554 var state = stream._state;
7561 WritableStreamFinishErroring(stream);
7585 var stream = controller._controlledWritableStream;
7586 WritableStreamMarkCloseRequestInFlight(stream);
7591 WritableStreamFinishInFlightClose(stream);
7593 WritableStreamFinishInFlightCloseWithError(stream, reason);
7598 var stream = controller._controlledWritableStream;
7599 WritableStreamMarkFirstWriteRequestInFlight(stream);
7602 WritableStreamFinishInFlightWrite(stream);
7603 var state = stream._state;
7607 if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
7609 WritableStreamUpdateBackpressure(stream, backpressure);
7614 WritableStreamFinishInFlightWriteWithError(stream, reason);
7624 var stream = controller._controlledWritableStream;
7625 assert(stream._state === 'writable');
7626 WritableStreamStartErroring(stream, error);
8055 function isOrBecomesErrored(stream, promise, action) {
8056 if (stream._state === 'errored') {
8057 action(stream._storedError);
8063 function isOrBecomesClosed(stream, promise, action) {
8064 if (stream._state === 'closed') {
8154 function AcquireReadableStreamBYOBReader(stream) {
8155 return new ReadableStreamBYOBReader(stream);
8158 function AcquireReadableStreamDefaultReader(stream) {
8159 return new ReadableStreamDefaultReader(stream);
8174 function IsReadableStreamDisturbed(stream) {
8175 …assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known …
8176 return stream._disturbed;
8179 function IsReadableStreamLocked(stream) {
8180 …assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known rea…
8182 if (stream._reader === undefined) {
8189 function ReadableStreamTee(stream, cloneForBranch2) {
8190 assert(IsReadableStream(stream) === true);
8192 var reader = AcquireReadableStreamDefaultReader(stream);
8208 cancel1._stream = stream;
8211 cancel2._stream = stream;
8283 var stream = f._stream,
8290 var cancelResult = ReadableStreamCancel(stream, compositeReason);
8303 var stream = f._stream,
8310 var cancelResult = ReadableStreamCancel(stream, compositeReason);
8321 function ReadableStreamAddReadIntoRequest(stream) {
8322 assert(IsReadableStreamBYOBReader(stream._reader) === true);
8323 assert(stream._state === 'readable' || stream._state === 'closed');
8330 stream._reader._readIntoRequests.push(readIntoRequest);
8335 function ReadableStreamAddReadRequest(stream) {
8336 assert(IsReadableStreamDefaultReader(stream._reader) === true);
8337 assert(stream._state === 'readable');
8344 stream._reader._readRequests.push(readRequest);
8349 function ReadableStreamCancel(stream, reason) {
8350 stream._disturbed = true;
8352 if (stream._state === 'closed') {
8356 if (stream._state === 'errored') {
8357 return Promise.reject(stream._storedError);
8360 ReadableStreamClose(stream);
8362 var sourceCancelPromise = stream._readableStreamController.__cancelSteps(reason);
8369 function ReadableStreamClose(stream) {
8370 assert(stream._state === 'readable');
8371 stream._state = 'closed';
8372 var reader = stream._reader;
8392 function ReadableStreamError(stream, e) {
8393 assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
8394 assert(stream._state === 'readable', 'state must be readable');
8395 stream._state = 'errored';
8396 stream._storedError = e;
8397 var reader = stream._reader;
8428 function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
8429 var reader = stream._reader;
8437 function ReadableStreamFulfillReadRequest(stream, chunk, done) {
8438 var reader = stream._reader;
8446 function ReadableStreamGetNumReadIntoRequests(stream) {
8447 return stream._reader._readIntoRequests.length;
8450 function ReadableStreamGetNumReadRequests(stream) {
8451 return stream._reader._readRequests.length;
8454 function ReadableStreamHasBYOBReader(stream) {
8455 var reader = stream._reader;
8468 function ReadableStreamHasDefaultReader(stream) {
8469 var reader = stream._reader;
8483 function ReadableStreamDefaultReader(stream) {
8486 if (IsReadableStream(stream) === false) {
8490 if (IsReadableStreamLocked(stream) === true) {
8494 ReadableStreamReaderGenericInitialize(this, stream);
8556 function ReadableStreamBYOBReader(stream) {
8559 if (!IsReadableStream(stream)) {
8563 if (IsReadableByteStreamController(stream._readableStreamController) === false) {
8567 if (IsReadableStreamLocked(stream)) {
8571 ReadableStreamReaderGenericInitialize(this, stream);
8664 function ReadableStreamReaderGenericInitialize(reader, stream) {
8665 reader._ownerReadableStream = stream;
8666 stream._reader = reader;
8668 if (stream._state === 'readable') {
8670 } else if (stream._state === 'closed') {
8673 assert(stream._state === 'errored', 'state must be errored');
8674 defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
8681 var stream = reader._ownerReadableStream;
8682 assert(stream !== undefined);
8683 return ReadableStreamCancel(stream, reason);
8703 var stream = reader._ownerReadableStream;
8704 assert(stream !== undefined);
8705 stream._disturbed = true;
8707 if (stream._state === 'errored') {
8708 return Promise.reject(stream._storedError);
8711 return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
8715 var stream = reader._ownerReadableStream;
8716 assert(stream !== undefined);
8717 stream._disturbed = true;
8719 if (stream._state === 'closed') {
8723 if (stream._state === 'errored') {
8724 return Promise.reject(stream._storedError);
8727 assert(stream._state === 'readable');
8728 return stream._readableStreamController.__pullSteps();
8732 function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
8735 if (IsReadableStream(stream) === false) {
8739 if (stream._readableStreamController !== undefined) {
8743 this._controlledReadableStream = stream;
8812 var stream = this._controlledReadableStream;
8814 if (stream._state !== 'readable') {
8815 throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
8829 var stream = this._controlledReadableStream;
8835 ReadableStreamClose(stream);
8843 var pendingPromise = ReadableStreamAddReadRequest(stream);
8904 var stream = controller._controlledReadableStream;
8906 if (stream._state === 'closed' || stream._state === 'errored') {
8918 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
8932 var stream = controller._controlledReadableStream;
8934 assert(stream._state === 'readable');
8938 ReadableStreamClose(stream);
8943 var stream = controller._controlledReadableStream;
8945 assert(stream._state === 'readable');
8947 if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
8948 ReadableStreamFulfillReadRequest(stream, chunk, false);
8976 var stream = controller._controlledReadableStream;
8977 assert(stream._state === 'readable');
8979 ReadableStreamError(stream, e);
8989 var stream = controller._controlledReadableStream;
8990 var state = stream._state;
9052 function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
9055 if (IsReadableStream(stream) === false) {
9059 if (stream._readableStreamController !== undefined) {
9063 this._controlledReadableStream = stream;
9091 if (stream._state === 'readable') {
9146 var stream = this._controlledReadableStream;
9148 if (stream._state !== 'readable') {
9149 throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
9168 var stream = this._controlledReadableStream;
9169 assert(ReadableStreamHasDefaultReader(stream) === true);
9172 assert(ReadableStreamGetNumReadRequests(stream) === 0);
9213 var promise = ReadableStreamAddReadRequest(stream);
9305 function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
9306 assert(stream._state !== 'errored', 'state must not be errored');
9309 if (stream._state === 'closed') {
9317 ReadableStreamFulfillReadRequest(stream, filledView, done);
9320 ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
9429 var stream = controller._controlledReadableStream;
9452 return ReadableStreamAddReadIntoRequest(stream);
9455 if (stream._state === 'closed') {
9478 var promise = ReadableStreamAddReadIntoRequest(stream);
9486 var stream = controller._controlledReadableStream;
9488 if (ReadableStreamHasBYOBReader(stream) === true) {
9489 while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
9491 ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
9524 var stream = controller._controlledReadableStream;
9526 if (stream._state === 'closed') {
9533 assert(stream._state === 'readable');
9546 var stream = controller._controlledReadableStream;
9548 if (stream._state !== 'readable') {
9560 …if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > …
9564 …if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) >…
9576 var stream = controller._controlledReadableStream;
9578 assert(stream._state === 'readable');
9595 ReadableStreamClose(stream);
9599 var stream = controller._controlledReadableStream;
9601 assert(stream._state === 'readable');
9607 if (ReadableStreamHasDefaultReader(stream) === true) {
9608 if (ReadableStreamGetNumReadRequests(stream) === 0) {
9613 ReadableStreamFulfillReadRequest(stream, transferredView, false);
9615 } else if (ReadableStreamHasBYOBReader(stream) === true) {
9619 assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
9625 var stream = controller._controlledReadableStream;
9626 assert(stream._state === 'readable');
9629 ReadableStreamError(stream, e);
9633 var stream = controller._controlledReadableStream;
9634 var state = stream._state;
11450 var stream = new _stream.Stream(data);
11451 _this.pdfDocument = new _document.PDFDocument(_assertThisInitialized(_this), stream);
11452 _this._loadedStreamPromise = Promise.resolve(stream);
11958 this.stream = new ChunkedStream(this.length, this.chunkSize, this);
12031 var missingChunks = this.stream.getMissingChunks();
12051 if (!this.stream.hasChunk(_chunk)) {
12125 return this.stream;
12220 loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
12235 this.stream.onReceiveProgressiveData(chunk);
12238 this.stream.onReceiveData(begin, chunk);
12241 if (this.stream.allChunksLoaded()) {
12242 this._loadedStreamCapability.resolve(this.stream);
12288 if (this.stream.numChunksLoaded === 1) {
12289 var lastChunk = this.stream.numChunks - 1;
12291 if (!this.stream.hasChunk(lastChunk)) {
12295 nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
12311 loaded: this.stream.numChunksLoaded * this.chunkSize,
12600 var stream;
12629 stream = new _stream2.StreamsSequenceStream(streams);
12631 stream = content;
12633 stream = new _stream2.NullStream();
12636 return stream;
12685 stream: contentStream,
12791 stream: contentStream,
12925 function find(stream, needle, limit) {
12928 var str = (0, _util.bytesToString)(stream.peekBytes(limit));
12935 stream.pos += index;
12945 var stream;
12948 stream = arg;
12950 stream = new _stream2.Stream(arg);
12955 if (stream.length <= 0) {
12960 this.stream = stream;
12961 this.xref = new _obj.XRef(stream, pdfManager);
13016 var stream = this.stream;
13017 stream.reset();
13019 if (!find(stream, '%PDF-', 1024)) {
13023 stream.moveStart();
13028 while ((ch = stream.getByte()) > 0x20) {
13135 linearization = _parser.Linearization.create(this.stream);
13149 var stream = this.stream;
13153 stream.reset();
13155 if (find(stream, 'endobj', 1024)) {
13156 startXRef = stream.pos + 6;
13162 pos = stream.end;
13171 stream.pos = pos;
13172 found = find(stream, 'startxref', step, true);
13176 stream.skip(9);
13180 ch = stream.getByte();
13187 ch = stream.getByte();
13302 if (this.stream.ensureRange) {
13303 this.stream.ensureRange(0, Math.min(FINGERPRINT_FIRST_BYTES, this.stream.end));
13306 …hash = (0, _crypto.calculateMD5)(this.stream.bytes.subarray(0, FINGERPRINT_FIRST_BYTES), 0, FINGER…
13937 var stream = this.xref.fetch(streamRef, suppressEncryption);
13940 if (stream && (0, _primitives.isDict)(stream.dict)) {
13941 var type = stream.dict.get('Type');
13942 var subtype = stream.dict.get('Subtype');
13946 metadata = (0, _util.stringToUTF8String)((0, _util.bytesToString)(stream.getBytes()));
14535 function XRef(stream, pdfManager) {
14536 this.stream = stream;
14608 streamPos: parser.lexer.stream.pos,
14634 var stream = parser.lexer.stream;
14636 stream.pos = tableState.streamPos;
14659 tableState.streamPos = stream.pos;
14694 tableState.streamPos = stream.pos;
14707 processXRefStream: function XRef_processXRefStream(stream) {
14709 var streamParameters = stream.dict;
14721 streamPos: stream.pos
14725 this.readXRefStream(stream);
14727 return stream.dict;
14729 readXRefStream: function XRef_readXRefStream(stream) {
14732 stream.pos = streamState.streamPos;
14753 streamState.streamPos = stream.pos;
14759 type = type << 8 | stream.getByte();
14767 offset = offset << 8 | stream.getByte();
14771 generation = generation << 8 | stream.getByte();
14800 streamState.streamPos = stream.pos;
14860 var stream = this.stream;
14861 stream.pos = 0;
14862 var buffer = stream.getBytes();
14863 var position = stream.start,
14903 offset: position - stream.start,
14937 xrefStms.push(position - stream.start);
14938 this.xrefstms[position - stream.start] = 1;
14960 stream.pos = trailers[i];
14962 lexer: new _parser.Lexer(stream),
15009 var stream = this.stream;
15023 stream.pos = startXRef + stream.start;
15025 lexer: new _parser.Lexer(stream),
15155 var stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
15157 lexer: new _parser.Lexer(stream),
15204 var stream = this.fetch(_primitives.Ref.get(tableOffset, 0));
15206 if (!(0, _primitives.isStream)(stream)) {
15210 var first = stream.dict.get('First');
15211 var n = stream.dict.get('N');
15218 lexer: new _parser.Lexer(stream),
15661 …if (!(this.xref.stream instanceof _chunked_stream.ChunkedStream) || this.xref.stream.getMissingChu…
15718 var stream = baseStreams[i];
15720 if (stream.getMissingChunks && stream.getMissingChunks().length) {
15723 begin: stream.start,
15724 end: stream.end
15738 this.xref.stream.manager.requestRanges(pendingRequests).then(function () {
15960 value: function findDefaultInlineStreamEnd(stream) {
15968 var startPos = stream.pos,
15973 while ((ch = stream.getByte()) !== -1) {
15982 maybeEIPos = stream.pos;
15983 var followingBytes = stream.peekBytes(n);
16012 stream.skip(-(stream.pos - maybeEIPos));
16017 stream.skip(-endOffset);
16018 ch = stream.peekByte();
16019 stream.skip(endOffset);
16025 return stream.pos - endOffset - startPos;
16029 value: function findDCTDecodeInlineStreamEnd(stream) {
16030 var startPos = stream.pos,
16036 while ((b = stream.getByte()) !== -1) {
16041 switch (stream.getByte()) {
16046 stream.skip(-1);
16091 markerLength = stream.getUint16();
16094 stream.skip(markerLength - 2);
16096 stream.skip(-2);
16107 length = stream.pos - startPos;
16111 stream.skip(-length);
16112 return this.findDefaultInlineStreamEnd(stream);
16115 this.inlineStreamSkipEI(stream);
16120 value: function findASCII85DecodeInlineStreamEnd(stream) {
16123 var startPos = stream.pos,
16127 while ((ch = stream.getByte()) !== -1) {
16129 ch = stream.peekByte();
16132 stream.skip();
16133 ch = stream.peekByte();
16137 stream.skip();
16143 length = stream.pos - startPos;
16147 stream.skip(-length);
16148 return this.findDefaultInlineStreamEnd(stream);
16151 this.inlineStreamSkipEI(stream);
16156 value: function findASCIIHexDecodeInlineStreamEnd(stream) {
16158 var startPos = stream.pos,
16162 while ((ch = stream.getByte()) !== -1) {
16168 length = stream.pos - startPos;
16172 stream.skip(-length);
16173 return this.findDefaultInlineStreamEnd(stream);
16176 this.inlineStreamSkipEI(stream);
16181 value: function inlineStreamSkipEI(stream) {
16187 while ((ch = stream.getByte()) !== -1) {
16201 var stream = lexer.stream;
16221 dictLength = stream.pos - lexer.beginInlineImagePos;
16237 var startPos = stream.pos;
16241 length = this.findDCTDecodeInlineStreamEnd(stream);
16243 length = this.findASCII85DecodeInlineStreamEnd(stream);
16245 length = this.findASCIIHexDecodeInlineStreamEnd(stream);
16247 length = this.findDefaultInlineStreamEnd(stream);
16250 var imageStream = stream.makeSubStream(startPos, length, dict);
16256 var initialStreamPos = stream.pos;
16257 stream.pos = lexer.beginInlineImagePos;
16258 var dictBytes = stream.getBytes(dictLength);
16259 stream.pos = initialStreamPos;
16290 var stream = this.lexer.stream;
16291 stream.pos = startPos;
16295 while (stream.pos < stream.end) {
16296 var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
16313 stream.pos += pos;
16314 return stream.pos - startPos;
16320 stream.pos += scanLength;
16329 var stream = lexer.stream;
16331 var startPos = stream.pos - 1;
16339 stream.pos = startPos + length;
16359 var lastByte = stream.peekBytes(end + 1)[end];
16383 stream = stream.makeSubStream(startPos, length, dict);
16386 stream = cipherTransform.createStream(stream, length);
16389 stream = this.filter(stream, dict, length);
16390 stream.dict = dict;
16391 return stream;
16395 value: function filter(stream, dict, length) {
16404 return this.makeFilter(stream, filter.name, length, params);
16426 stream = this.makeFilter(stream, filter.name, maybeLength, params);
16431 return stream;
16435 value: function makeFilter(stream, name, maybeLength, params) {
16448 …return new _stream.PredictorStream(new _stream.FlateStream(stream, maybeLength), maybeLength, para…
16451 return new _stream.FlateStream(stream, maybeLength);
16463 …return new _stream.PredictorStream(new _stream.LZWStream(stream, maybeLength, earlyChange), maybeL…
16466 return new _stream.LZWStream(stream, maybeLength, earlyChange);
16471 return new _jpeg_stream.JpegStream(stream, maybeLength, stream.dict, params);
16476 return new _jpx_stream.JpxStream(stream, maybeLength, stream.dict, params);
16481 return new _stream.Ascii85Stream(stream, maybeLength);
16486 return new _stream.AsciiHexStream(stream, maybeLength);
16491 return new _ccitt_stream.CCITTFaxStream(stream, maybeLength, params);
16496 return new _stream.RunLengthStream(stream, maybeLength);
16501 return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
16505 return stream;
16538 function Lexer(stream) {
16543 this.stream = stream;
16553 return this.currentChar = this.stream.getByte();
16558 return this.stream.peekByte();
16995 this.beginInlineImagePos = this.stream.pos;
17038 value: function create(stream) {
17070 lexer: new Lexer(stream),
17081 } else if ((length = getInt(linDict, 'L')) !== stream.length) {
17388 var stream = streams[i];
17390 if (stream instanceof DecodeStream) {
17391 maybeLength += stream._rawMinBufferLength;
17393 maybeLength += stream.length;
17410 var stream = streams.shift();
17411 var chunk = stream.getBytes();
17423 var stream = this.streams[i];
17425 if (stream.getBaseStreams) {
17426 baseStreams.push.apply(baseStreams, _toConsumableArray(stream.getBaseStreams()));
19169 function Jbig2Stream(stream, maybeLength, dict, params) {
19170 this.stream = stream;
19181 return (0, _util.shadow)(this, 'bytes', this.stream.getBytes(this.maybeLength));
21821 function JpegStream(stream, maybeLength, dict, params) {
21824 while ((ch = stream.getByte()) !== -1) {
21826 stream.skip(-1);
21831 this.stream = stream;
21842 return (0, _util.shadow)(this, 'bytes', this.stream.getBytes(this.maybeLength));
23121 function JpxStream(stream, maybeLength, dict, params) {
23122 this.stream = stream;
23133 return (0, _util.shadow)(this, 'bytes', this.stream.getBytes(this.maybeLength));
23319 parseImageProperties: function JpxImage_parseImageProperties(stream) {
23320 var newByte = stream.getByte();
23324 newByte = stream.getByte();
23328 stream.skip(4);
23329 var Xsiz = stream.getInt32() >>> 0;
23330 var Ysiz = stream.getInt32() >>> 0;
23331 var XOsiz = stream.getInt32() >>> 0;
23332 var YOsiz = stream.getInt32() >>> 0;
23333 stream.skip(16);
23334 var Csiz = stream.getUint16();
26775 createStream: function CipherTransform_createStream(stream, length) {
26777 …return new _stream.DecryptStream(stream, length, function cipherTransformDecryptStream(data, final…
27479 var stream = xref.fetchIfRef(cs[1]);
27480 var dict = stream.dict;
28757 stream: _this.appearance,
29108 var stream = new _stream.Stream((0, _util.stringToBytes)(this.data.defaultAppearance));
29110 stream: stream,
30663 stream: xobj,
30916 stream: pattern,
31291 var stream = _ref4.stream,
31314 var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
31674 var stream = _ref5.stream,
31717 var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
32179 stream: xobj,
32799 var stream = toUnicode.str || toUnicode;
32800 …= stream.buffer ? new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) : new Uint8Array(st…
33071 stream: glyphStream,
33624 function EvaluatorPreprocessor(stream, xref, stateManager) {
33627 lexer: new _parser.Lexer(stream, this.opMap),
34173 var stream = new BinaryCMapStream(data);
34174 var header = stream.readByte();
34187 while ((b = stream.readByte()) >= 0) {
34193 stream.readString();
34197 useCMap = stream.readString();
34212 var subitemsCount = stream.readNumber();
34217 stream.readHex(start, dataSize);
34218 stream.readHexNumber(end, dataSize);
34224 stream.readHexNumber(start, dataSize);
34226 stream.readHexNumber(end, dataSize);
34234 stream.readHex(start, dataSize);
34235 stream.readHexNumber(end, dataSize);
34237 stream.readNumber();
34241 stream.readHexNumber(start, dataSize);
34243 stream.readHexNumber(end, dataSize);
34245 stream.readNumber();
34251 stream.readHex(_char, dataSize);
34252 code = stream.readNumber();
34259 stream.readHexNumber(tmp, dataSize);
34263 code = stream.readSigned() + (code + 1);
34270 stream.readHex(start, dataSize);
34271 stream.readHexNumber(end, dataSize);
34273 code = stream.readNumber();
34280 stream.readHexNumber(start, dataSize);
34286 stream.readHexNumber(end, dataSize);
34288 code = stream.readNumber();
34295 stream.readHex(_char, ucs2DataSize);
34296 stream.readHex(charCode, dataSize);
34303 stream.readHexNumber(tmp, ucs2DataSize);
34308 stream.readHexSigned(tmp, dataSize);
34316 stream.readHex(start, ucs2DataSize);
34317 stream.readHexNumber(end, ucs2DataSize);
34319 stream.readHex(charCode, dataSize);
34326 stream.readHexNumber(start, ucs2DataSize);
34332 stream.readHexNumber(end, ucs2DataSize);
34334 stream.readHex(charCode, dataSize);
35531 var stream = new _stream.Stream(os2.data);
35532 var version = stream.getUint16();
35533 stream.getBytes(60);
35534 var selection = stream.getUint16();
35540 var firstChar = stream.getUint16();
35541 var lastChar = stream.getUint16();
35547 stream.getBytes(6);
35548 var usWinAscent = stream.getUint16();
37511 function getHeaderBlock(stream, suggestedLength) {
37513 var streamStartPos = stream.pos;
37517 headerBytes = stream.getBytes(suggestedLength);
37530 stream: new _stream.Stream(headerBytes),
37537 stream.pos = streamStartPos;
37542 var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
37549 stream.pos += block.length;
37552 actualLength = stream.pos - streamStartPos;
37557 stream.pos = streamStartPos;
37561 stream: new _stream.Stream(stream.getBytes(actualLength)),
37568 stream: new _stream.Stream(stream.getBytes(suggestedLength)),
37573 function getEexecBlock(stream, suggestedLength) {
37574 var eexecBytes = stream.getBytes();
37576 stream: new _stream.Stream(eexecBytes),
37594 …var headerBlockParser = new _type1_parser.Type1Parser(headerBlock.stream, false, SEAC_ANALYSIS_ENA…
37603 …var eexecBlockParser = new _type1_parser.Type1Parser(eexecBlock.stream, true, SEAC_ANALYSIS_ENABLE…
48400 function Type1Parser(stream, encrypted, seacAnalysisEnabled) {
48402 var data = stream.getBytes();
48404 …stream = new _stream.Stream(isBinary ? decrypt(data, EEXEC_ENCRYPT_KEY, 4) : decryptAscii(data, EE…
48408 this.stream = stream;
48442 return this.currentChar = this.stream.getByte();
48488 var stream = this.stream;
48530 data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
48556 data = length > 0 ? stream.getBytes(length) : new Uint8Array(0);
48910 function MeshStreamReader(stream, context) {
48911 this.stream = stream;
48923 if (this.stream.end) {
48924 return this.stream.pos < this.stream.end;
48931 var nextByte = this.stream.getByte();
48948 …return (this.stream.getByte() << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | t…
48951 …buffer = buffer << 24 | this.stream.getByte() << 16 | this.stream.getByte() << 8 | this.stream.get…
48952 var nextByte = this.stream.getByte();
48958 return this.stream.getByte();
48962 buffer = buffer << 8 | this.stream.getByte();
49511 function Mesh(stream, matrix, xref, res, pdfFunctionFactory) {
49512 if (!(0, _primitives.isStream)(stream)) {
49516 var dict = stream.dict;
49539 var reader = new MeshStreamReader(stream, decodeContext);
52981 getSampleArray: function getSampleArray(size, outputSize, bps, stream) {
52994 var strBytes = stream.getBytes((length * bps + 7) / 8);
54406 function PostScriptLexer(stream) {
54409 this.stream = stream;
54417 return this.currentChar = this.stream.getByte();
54856 jpxImage.parseImageProperties(image.stream);
54857 image.stream.reset();
55549 if (data.stream) {
55676 stream: 'pull',
55691 stream: 'cancel',
55712 var stream = _ref.stream,
55721 stream: stream,
55747 stream: 'enqueue',
55759 stream: 'close'
55770 stream: 'error',
55786 stream: 'start_complete',
55791 stream: 'start_complete',
55805 var stream = _ref2.stream,
55812 stream: stream,
55827 switch (data.stream) {
55839 stream: 'pull_complete',
55852 stream: 'pull_complete',
55857 stream: 'pull_complete',
55903 stream: 'cancel_complete',
55908 stream: 'cancel_complete',