Lines Matching refs:stream
72 var stream, worksheet;
90 stream = fs.createReadStream(filename);
92 return this.read(stream, options);
96 stream.close();
115 value: function read(stream, options) {
168 stream.pipe(csvStream);
182 value: function write(stream, options) {
193 stream.on('finish', function () {
197 csvStream.pipe(stream);
260 var stream = fs.createWriteStream(filename, streamOptions);
261 return this.write(stream, options);
267 var stream;
272 stream = new StreamBuf();
274 return this.write(stream, options);
277 return _context2.abrupt("return", stream.read());
7547 _this.stream = new StreamBuf();
7582 this.stream.end(content);
7604 return this.stream.read(size);
7609 return this.stream.setEncoding(encoding);
7614 return this.stream.pause();
7619 return this.stream.resume();
7624 return this.stream.isPaused();
7629 return this.stream.pipe(destination, options);
7634 return this.stream.unpipe(destination);
7639 return this.stream.unshift(chunk);
7643 value: function wrap(stream) {
7644 return this.stream.wrap(stream);
8160 … _parseStream = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(stream) {
8165 return _context2.abrupt("return", this.parse(parseSax(stream)));
19753 var stream = new XmlStream();
19754 build(stream, this._model);
19755 this._xml = stream.xml;
23111 value: function parseStream(stream) {
23112 stream.autodrain();
23937 var stream, workbook;
23954 stream = fs.createReadStream(filename);
23957 return this.read(stream, options);
23961 stream.close();
23967 stream.close();
23986 value: function parseRels(stream) {
23988 return xform.parseStream(stream);
23992 value: function parseWorkbook(stream) {
23994 return xform.parseStream(stream);
23998 value: function parseSharedStrings(stream) {
24000 return xform.parseStream(stream);
24073 …asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(stream, model, sheetNo, o…
24081 return xform.parseStream(stream);
24106 … = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(stream, model, name) {
24114 return xform.parseStream(stream);
24137 … = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(stream, model, name) {
24145 return xform.parseStream(stream);
24168 …_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(stream, model, sheetNo) {
24176 return xform.parseStream(stream);
24353 var stream = new StreamBuf();
24355 stream.on('error', reject);
24356 stream.on('finish', function () {
24357 model.themes[name] = stream.read().toString();
24360 entry.pipe(stream);
24389 …var _read = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee11(stream, opt…
24398 if (!stream[Symbol.asyncIterator] && stream.pipe) {
24399 stream = stream.pipe(new PassThrough());
24406 _iterator = _asyncIterator(stream);
24493 …var buffer, model, zip, _i, _Object$values, entry, entryName, stream, content, chunkSize, i, workb…
24544 stream = void 0;
24552 stream = new PassThrough();
24553 _context12.t0 = stream;
24567 stream = new PassThrough({
24599 stream.write(content.substring(i, i + chunkSize));
24603 stream.end();
24610 return this.parseRels(stream);
24618 return this.parseWorkbook(stream);
24631 return this.parseRels(stream);
24640 return model.sharedStrings.parseStream(stream);
24648 return model.styles.parseStream(stream);
24656 return appXform.parseStream(stream);
24667 return coreXform.parseStream(stream);
24683 return this._processWorksheetEntry(stream, model, match[1], options, entryName);
24697 return this._processWorksheetRelsEntry(stream, model, match[1]);
24711 return this._processThemeEntry(stream, model, match[1]);
24725 return this._processMediaEntry(stream, model, match[1]);
24739 return this._processDrawingEntry(stream, model, match[1]);
24753 return this._processCommentEntry(stream, model, match[1]);
24767 return this._processTableEntry(stream, model, match[1]);
24781 return this._processDrawingRelsEntry(stream, model, match[1]);
24795 return this._processVmlDrawingEntry(stream, model, match[1]);
25371 …ite = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee25(stream, options) {
25380 zip.pipe(stream);
25448 var stream = fs.createWriteStream(filename);
25450 stream.on('finish', function () {
25453 stream.on('error', function (error) {
25457 _this2.write(stream, options).then(function () {
25458 stream.end();
25466 var stream;
25471 stream = new StreamBuf();
25473 return this.write(stream, options);
25476 return _context26.abrupt("return", stream.read());
26195 var stream = fs.createWriteStream(path, {
26198 return exports.write(rows, options).pipe(stream);
26680 exports.parseStream = function (stream, options) {
26681 …return stream.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options…
38291 var stream = require('readable-stream');
38307 stream.Writable.call(this);
38316 inherits(Sign, stream.Writable);
38342 stream.Writable.call(this);
38350 inherits(Verify, stream.Writable);
51897 function NodejsStreamInputAdapter(filename, stream) {
51901 this._bindStream(stream);
51911 NodejsStreamInputAdapter.prototype._bindStream = function (stream) {
51913 this._stream = stream;
51914 stream.pause();
51915 stream.on("data", function (chunk) {
71728 function ReadableState(options, stream, isDuplex) {
71736 …if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Use…
71871 function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
71873 var state = stream._readableState;
71877 onEofChunk(stream, state);
71883 errorOrDestroy(stream, er);
71890 …if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChu…
71892 errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
71900 …state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(s…
71902 addChunk(stream, state, chunk, false);
71907 maybeReadMore(stream, state);
71917 function addChunk(stream, state, chunk, addToFront) {
71920 stream.emit('data', chunk);
71925 if (state.needReadable) emitReadable(stream);
71928 maybeReadMore(stream, state);
72109 function onEofChunk(stream, state) {
72128 emitReadable(stream);
72135 emitReadable_(stream);
72143 function emitReadable(stream) {
72144 var state = stream._readableState;
72151 process.nextTick(emitReadable_, stream);
72155 function emitReadable_(stream) {
72156 var state = stream._readableState;
72160 stream.emit('readable');
72171 flow(stream);
72180 function maybeReadMore(stream, state) {
72183 process.nextTick(maybeReadMore_, stream, state);
72187 function maybeReadMore_(stream, state) {
72214 stream.read(0);
72524 function resume(stream, state) {
72527 process.nextTick(resume_, stream, state);
72531 function resume_(stream, state) {
72535 stream.read(0);
72539 stream.emit('resume');
72540 flow(stream);
72541 if (state.flowing && !state.reading) stream.read(0);
72557 function flow(stream) {
72558 var state = stream._readableState;
72561 while (state.flowing && stream.read() !== null) {
72569 Readable.prototype.wrap = function (stream) {
72574 stream.on('end', function () {
72584 stream.on('data', function (chunk) {
72594 stream.pause();
72599 for (var i in stream) {
72600 if (this[i] === undefined && typeof stream[i] === 'function') {
72603 return stream[method].apply(stream, arguments);
72611 stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
72621 stream.resume();
72700 function endReadable(stream) {
72701 var state = stream._readableState;
72706 process.nextTick(endReadableNT, state, stream);
72710 function endReadableNT(state, stream) {
72715 stream.readable = false;
72716 stream.emit('end');
72721 var wState = stream._writableState;
72724 stream.destroy();
72941 function done(stream, er, data) {
72942 if (er) return stream.emit('error', er);
72944 stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
72948 if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
72949 if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
72950 return stream.push(null);
73057 function WritableState(options, stream, isDuplex) {
73065 …if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to i…
73114 onwrite(stream, er);
73214 function writeAfterEnd(stream, cb) {
73217 errorOrDestroy(stream, er);
73224 function validChunk(stream, state, chunk, cb) {
73234 errorOrDestroy(stream, er);
73317 function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
73352 doWrite(stream, state, false, len, chunk, encoding, cb);
73358 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
73363 …new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stre…
73367 function onwriteError(stream, state, sync, er, cb) {
73376 process.nextTick(finishMaybe, stream, state);
73377 stream._writableState.errorEmitted = true;
73378 errorOrDestroy(stream, er);
73383 stream._writableState.errorEmitted = true;
73384 errorOrDestroy(stream, er); // this can emit finish, but finish must
73387 finishMaybe(stream, state);
73398 function onwrite(stream, er) {
73399 var state = stream._writableState;
73404 if (er) onwriteError(stream, state, sync, er, cb);else {
73406 var finished = needFinish(state) || stream.destroyed;
73409 clearBuffer(stream, state);
73413 process.nextTick(afterWrite, stream, state, finished, cb);
73415 afterWrite(stream, state, finished, cb);
73420 function afterWrite(stream, state, finished, cb) {
73421 if (!finished) onwriteDrain(stream, state);
73424 finishMaybe(stream, state);
73430 function onwriteDrain(stream, state) {
73433 stream.emit('drain');
73438 function clearBuffer(stream, state) {
73442 if (stream._writev && entry && entry.next) {
73459 …doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always…
73480 doWrite(stream, state, false, len, chunk, encoding, cb);
73543 function callFinal(stream, state) {
73544 stream._final(function (err) {
73548 errorOrDestroy(stream, err);
73552 stream.emit('prefinish');
73553 finishMaybe(stream, state);
73557 function prefinish(stream, state) {
73559 if (typeof stream._final === 'function' && !state.destroyed) {
73562 process.nextTick(callFinal, stream, state);
73565 stream.emit('prefinish');
73570 function finishMaybe(stream, state) {
73574 prefinish(stream, state);
73578 stream.emit('finish');
73583 var rState = stream._readableState;
73586 stream.destroy();
73595 function endWritable(stream, state, cb) {
73597 finishMaybe(stream, state);
73600 if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
73604 stream.writable = false;
73731 get stream() {
73810 var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
73814 value: stream,
73826 value: stream._readableState.endEmitted,
73845 finished(stream, function (err) {
73872 stream.on('readable', onReadable.bind(null, iterator));
74240 function errorOrDestroy(stream, err) {
74246 var rState = stream._readableState;
74247 var wState = stream._writableState;
74248 …if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.…
74282 function isRequest(stream) {
74283 return stream.setHeader && typeof stream.abort === 'function';
74286 function eos(stream, opts, callback) {
74287 if (typeof opts === 'function') return eos(stream, null, opts);
74290 var readable = opts.readable || opts.readable !== false && stream.readable;
74291 var writable = opts.writable || opts.writable !== false && stream.writable;
74294 if (!stream.writable) onfinish();
74297 var writableEnded = stream._writableState && stream._writableState.finished;
74302 if (!readable) callback.call(stream);
74305 var readableEnded = stream._readableState && stream._readableState.endEmitted;
74310 if (!writable) callback.call(stream);
74314 callback.call(stream, err);
74321 …if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
74322 return callback.call(stream, err);
74326 …if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
74327 return callback.call(stream, err);
74332 stream.req.on('finish', onfinish);
74335 if (isRequest(stream)) {
74336 stream.on('complete', onfinish);
74337 stream.on('abort', onclose);
74338 if (stream.req) onrequest();else stream.on('request', onrequest);
74339 } else if (writable && !stream._writableState) {
74341 stream.on('end', onlegacyfinish);
74342 stream.on('close', onlegacyfinish);
74345 stream.on('end', onend);
74346 stream.on('finish', onfinish);
74347 if (opts.error !== false) stream.on('error', onerror);
74348 stream.on('close', onclose);
74350 stream.removeListener('complete', onfinish);
74351 stream.removeListener('abort', onclose);
74352 stream.removeListener('request', onrequest);
74353 if (stream.req) stream.req.removeListener('finish', onfinish);
74354 stream.removeListener('end', onlegacyfinish);
74355 stream.removeListener('close', onlegacyfinish);
74356 stream.removeListener('finish', onfinish);
74357 stream.removeListener('end', onend);
74358 stream.removeListener('error', onerror);
74359 stream.removeListener('close', onclose);
74397 function isRequest(stream) {
74398 return stream.setHeader && typeof stream.abort === 'function';
74401 function destroyer(stream, reading, writing, callback) {
74404 stream.on('close', function () {
74408 eos(stream, {
74422 if (isRequest(stream)) return stream.abort();
74423 if (typeof stream.destroy === 'function') return stream.destroy();
74455 var destroys = streams.map(function (stream, i) {
74458 return destroyer(stream, reading, writing, function (err) {
79284 function ReadableState(options, stream) {
79292 …var isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and …
79421 function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
79422 var state = stream._readableState;
79426 onEofChunk(stream, state);
79432 stream.emit('error', er);
79439 …if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else add…
79441 stream.emit('error', new Error('stream.push() after EOF'));
79447 …state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(s…
79449 addChunk(stream, state, chunk, false);
79460 function addChunk(stream, state, chunk, addToFront) {
79462 stream.emit('data', chunk);
79463 stream.read(0);
79468 if (state.needReadable) emitReadable(stream);
79471 maybeReadMore(stream, state);
79646 function onEofChunk(stream, state) {
79660 emitReadable(stream);
79666 function emitReadable(stream) {
79667 var state = stream._readableState;
79673 if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
79677 function emitReadable_(stream) {
79679 stream.emit('readable');
79680 flow(stream);
79689 function maybeReadMore(stream, state) {
79692 pna.nextTick(maybeReadMore_, stream, state);
79696 function maybeReadMore_(stream, state) {
79701 stream.read(0);
79962 function resume(stream, state) {
79965 pna.nextTick(resume_, stream, state);
79969 function resume_(stream, state) {
79972 stream.read(0);
79977 stream.emit('resume');
79978 flow(stream);
79979 if (state.flowing && !state.reading) stream.read(0);
79994 function flow(stream) {
79995 var state = stream._readableState;
79998 while (state.flowing && stream.read() !== null) {}
80004 Readable.prototype.wrap = function (stream) {
80009 stream.on('end', function () {
80019 stream.on('data', function (chunk) {
80029 stream.pause();
80034 for (var i in stream) {
80035 if (this[i] === undefined && typeof stream[i] === 'function') {
80038 return stream[method].apply(stream, arguments);
80046 stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
80056 stream.resume();
80184 function endReadable(stream) {
80185 …var state = stream._readableState; // If we get here before consuming all the bytes, then that is a
80192 pna.nextTick(endReadableNT, state, stream);
80196 function endReadableNT(state, stream) {
80200 stream.readable = false;
80201 stream.emit('end');
80410 function done(stream, er, data) {
80411 if (er) return stream.emit('error', er);
80413 stream.push(data); // if there's nothing in the write buffer, then that means
80416 if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
80417 …if (stream._transformState.transforming) throw new Error('Calling transform done when still transf…
80418 return stream.push(null);
80530 function WritableState(options, stream) {
80538 …var isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this str…
80592 onwrite(stream, er);
80688 function writeAfterEnd(stream, cb) {
80691 stream.emit('error', er);
80698 function validChunk(stream, state, chunk, cb) {
80709 stream.emit('error', er);
80783 function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
80818 doWrite(stream, state, false, len, chunk, encoding, cb);
80824 function doWrite(stream, state, writev, len, chunk, encoding, cb) {
80829 …if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite…
80833 function onwriteError(stream, state, sync, er, cb) {
80842 pna.nextTick(finishMaybe, stream, state);
80843 stream._writableState.errorEmitted = true;
80844 stream.emit('error', er);
80849 stream._writableState.errorEmitted = true;
80850 stream.emit('error', er); // this can emit finish, but finish must
80853 finishMaybe(stream, state);
80864 function onwrite(stream, er) {
80865 var state = stream._writableState;
80869 if (er) onwriteError(stream, state, sync, er, cb);else {
80874 clearBuffer(stream, state);
80879 asyncWrite(afterWrite, stream, state, finished, cb);
80882 afterWrite(stream, state, finished, cb);
80887 function afterWrite(stream, state, finished, cb) {
80888 if (!finished) onwriteDrain(stream, state);
80891 finishMaybe(stream, state);
80897 function onwriteDrain(stream, state) {
80900 stream.emit('drain');
80905 function clearBuffer(stream, state) {
80909 if (stream._writev && entry && entry.next) {
80926 …doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always…
80947 doWrite(stream, state, false, len, chunk, encoding, cb);
80999 function callFinal(stream, state) {
81000 stream._final(function (err) {
81004 stream.emit('error', err);
81008 stream.emit('prefinish');
81009 finishMaybe(stream, state);
81013 function prefinish(stream, state) {
81015 if (typeof stream._final === 'function') {
81018 pna.nextTick(callFinal, stream, state);
81021 stream.emit('prefinish');
81026 function finishMaybe(stream, state) {
81030 prefinish(stream, state);
81034 stream.emit('finish');
81041 function endWritable(stream, state, cb) {
81043 finishMaybe(stream, state);
81046 if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
81050 stream.writable = false;