Lines Matching refs:options
71 …ile = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(filename, options) {
77 options = options || {};
92 return this.read(stream, options);
115 value: function read(stream, options) {
118 options = options || {};
120 var worksheet = _this.workbook.addWorksheet(options.sheetName);
122 …var dateFormats = options.dateFormats || ['YYYY-MM-DD[T]HH:mm:ssZ', 'YYYY-MM-DD[T]HH:mm:ss', 'MM-D…
124 var map = options.map || function (datum) {
162 var csvStream = fastCsv.parse(options.parserOptions).on('data', function (data) {
182 value: function write(stream, options) {
186 options = options || {}; // const encoding = options.encoding || 'utf8';
190 var worksheet = _this2.workbook.getWorksheet(options.sheetName || options.sheetId);
192 var csvStream = fastCsv.format(options.formatterOptions);
198 var _options = options,
202 var map = options.map || function (value) {
232 var includeEmptyRows = options.includeEmptyRows === undefined || options.includeEmptyRows;
255 value: function writeFile(filename, options) {
256 options = options || {};
258 encoding: options.encoding || 'utf8'
261 return this.write(stream, options);
266 …_writeBuffer = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(options) {
274 return this.write(stream, options);
1808 value: function eachCell(options, iteratee) {
1812 iteratee = options;
1813 options = null;
1816 this._worksheet.eachRow(options, function (row, rowNumber) {
3089 value: function eachCell(options, iteratee) {
3091 iteratee = options;
3092 options = null;
3095 if (options && options.includeEmpty) {
4027 value: function addWorksheet(name, options) {
4054 if (options) {
4055 if (typeof options === 'string') {
4058 options = {
4061 argb: options
4065 } else if (options.argb || options.theme || options.indexed) {
4068 options = {
4070 tabColor: options
4080 var worksheetOptions = Object.assign({}, options, {
4323 function Worksheet(options) {
4326 options = options || {}; // in a workbook, each sheet will have a number
4328 this.id = options.id;
4329 this.orderNo = options.orderNo; // and a name
4331 this.name = options.name || "Sheet".concat(this.id); // add a state
4333 …this.state = options.state || 'visible'; // rows allows access organised by row. Sparse array of a…
4345 this._workbook = options.workbook; // for tabColor, default row height, outline levels, etc
4352 }, options.properties); // for all things printing
4366 …fitToPage: !!(options.pageSetup && (options.pageSetup.fitToWidth || options.pageSetup.fitToHeight)…
4383 }, options.pageSetup);
4393 }, options.headerFooter);
4396 this.views = options.views || [];
4397 this.autoFilter = options.autoFilter || null; // for images, etc
4762 value: function eachRow(options, iteratee) {
4764 iteratee = options;
4765 options = undefined;
4768 if (options && options.includeEmpty) {
5009 value: function protect(password, options) {
5019 if (options && 'spinCount' in options) {
5021 …options.spinCount = Number.isFinite(options.spinCount) ? Math.round(Math.max(0, options.spinCount)…
5027 …_this5.sheetProtection.spinCount = options && 'spinCount' in options ? options.spinCount : 100000;…
5032 if (options) {
5033 _this5.sheetProtection = Object.assign(_this5.sheetProtection, options);
5035 if (!password && 'spinCount' in options) {
6452 var StreamBuf = function StreamBuf(options) {
6453 options = options || {};
6454 this.bufSize = options.bufSize || 1024 * 1024;
6458 this.batch = options.batch || false;
6788 function StringBuf(options) {
6791 this._buf = Buffer.alloc(options && options.size || 16384);
6792 this._encoding = options && options.encoding || 'utf8'; // where in the buffer we are at
7536 function ZipWriter(options) {
7542 _this.options = Object.assign({
7545 }, options);
7553 value: function append(data, options) {
7554 if (options.hasOwnProperty('base64') && options.base64) {
7555 this.zip.file(options.name, data, {
7565 this.zip.file(options.name, data);
7578 return this.zip.generateAsync(this.options);
7628 value: function pipe(destination, options) {
7629 return this.stream.pipe(destination, options);
7972 value: function reconcile(model, options) {// optional post-parse step (opposite to prepare)
9846 value: function reconcile(model, options) {
9851 _this3.map['xdr:twoCellAnchor'].reconcile(anchor, options);
9853 _this3.map['xdr:oneCellAnchor'].reconcile(anchor, options);
11199 value: function reconcilePicture(model, options) {
11201 var rel = options.rels[model.rId];
11206 var mediaId = options.mediaIndex[name];
11207 return options.media[mediaId];
11664 function CellPositionXform(options) {
11670 _this.tag = options.tag;
11909 value: function reconcile(model, options) {
11914 _this4.map['xdr:twoCellAnchor'].reconcile(anchor, options);
11916 _this4.map['xdr:oneCellAnchor'].reconcile(anchor, options);
12062 function ExtXform(options) {
12068 _this.tag = options.tag;
12383 value: function prepare(model, options) {
12384 this.map['xdr:pic'].prepare(model.picture, options);
12423 value: function reconcile(model, options) {
12424 model.medium = this.reconcilePicture(model.picture, options);
12494 value: function prepare(model, options) {
12495 model.index = options.index + 1;
12659 value: function prepare(model, options) {
12660 this.map['xdr:pic'].prepare(model.picture, options);
12699 value: function reconcile(model, options) {
12700 model.medium = this.reconcilePicture(model.picture, options);
12746 function ListXform(options) {
12752 _this.tag = options.tag;
12753 _this.always = !!options.always;
12754 _this.count = options.count;
12755 _this.empty = options.empty;
12756 _this.$count = options.$count || 'count';
12757 _this.$ = options.$;
12758 _this.childXform = options.childXform;
12759 _this.maxItems = options.maxItems;
12765 value: function prepare(model, options) {
12770 options.index = index;
12771 childXform.prepare(childModel, options);
12843 value: function reconcile(model, options) {
12847 childXform.reconcile(childModel, options);
13050 value: function prepare(model, options) {
13051 var styleId = options.styles.addStyleModel(model.style || {}, getEffectiveCellType(model));
13058 options.comments.push(_objectSpread(_objectSpread({}, model.comment), {}, {
13066 if (options.sharedStrings) {
13067 model.ssId = options.sharedStrings.add(model.value);
13073 if (options.date1904) {
13080 if (options.sharedStrings && model.text !== undefined && model.text !== null) {
13081 model.ssId = options.sharedStrings.add(model.text);
13084 options.hyperlinks.push({
13092 options.merges.add(model);
13096 if (options.date1904) {
13102 model.si = options.siFormulae++;
13106 options.formulae[model.address] = model;
13108 var master = options.formulae[model.sharedFormula];
13116 master.si = options.siFormulae++;
13462 value: function reconcile(model, options) {
13463 var style = model.styleId && options.styles && options.styles.getStyleModel(model.styleId);
13476 if (options.sharedStrings) {
13477 model.value = options.sharedStrings.getString(model.value);
13490 model.value = utils.excelToDate(model.value, options.date1904);
13497 model.result = utils.excelToDate(model.result, options.date1904);
13503 options.formulae[model.si] = model.address;
13506 model.sharedFormula = options.formulae[model.si];
13520 var hyperlink = options.hyperlinkMap[model.address];
13535 var comment = options.commentsMap && options.commentsMap[model.address];
13911 value: function prepare(model, options) {
13915 _this2.cfRule.prepare(rule, options);
14030 value: function prepare(model, options) {
14034 _this2.cfXform.prepare(cf, options);
15194 value: function prepare(model, options) {
15208 rule.dxfId = options.styles.addDxfStyle(rule.style);
15264 value: function reconcile(model, options) {
15268 rule.style = options.styles.getDxfStyle(rule.dxfId);
15744 value: function prepare(model, options) {
15745 var styleId = options.styles.addStyleModel(model.style || {});
15830 value: function reconcile(model, options) {
15833 model.style = options.styles.getStyleModel(model.styleId);
16426 value: function prepare(model, options) {
16427 this.conditionalFormattings.prepare(model.conditionalFormattings, options);
16478 value: function prepare(model, options) {
16479 this.ext.prepare(model, options);
17677 var options = {
17682 return _super.call(this, options);
17747 function RowXform(options) {
17753 _this.maxItems = options && options.maxItems;
17762 value: function prepare(model, options) {
17763 var styleId = options.styles.addStyleModel(model.style);
17771 cellXform.prepare(cellModel, options);
17776 value: function render(xmlStream, model, options) {
17810 cellXform.render(xmlStream, cellModel, options);
17898 value: function reconcile(model, options) {
17899 model.style = model.styleId ? options.styles.getStyleModel(model.styleId) : {};
17907 cellXform.reconcile(cellModel, options);
18808 function WorkSheetXform(options) {
18815 var _ref = options || {},
18875 value: function prepare(model, options) {
18878 options.merges = new Merges();
18879 model.hyperlinks = options.hyperlinks = [];
18880 model.comments = options.comments = [];
18881 options.formulae = {};
18882 options.siFormulae = 0;
18883 this.map.cols.prepare(model.cols, options);
18884 this.map.sheetData.prepare(model.rows, options);
18885 this.map.conditionalFormatting.prepare(model.conditionalFormattings, options);
18886 model.mergeCells = options.merges.mergeCells; // prepare relationships
18921 options.commentRefs.push({
18932 bookImage = options.media[medium.imageId];
18941 model.image = options.media[medium.imageId];
18944 bookImage = options.media[medium.imageId];
18949 name: "drawing".concat(++options.drawingsCount),
18953 options.drawings.push(drawing);
19014 column.dxfId = options.styles.addDxfStyle(style);
19019 this.map.extLst.prepare(model, options);
19189 value: function reconcile(model, options) {
19196 model.comments = options.comments[rel.Target].comments;
19200 var vmlComment = options.vmlDrawings[rel.Target].comments;
19208 options.commentsMap = (model.comments || []).reduce(function (h, comment) {
19215 options.hyperlinkMap = (model.hyperlinks || []).reduce(function (h, hyperlink) {
19222 options.formulae = {}; // compact the rows and cells
19228 this.map.cols.reconcile(model.cols, options);
19229 this.map.sheetData.reconcile(model.rows, options);
19230 this.map.conditionalFormatting.reconcile(model.conditionalFormattings, options);
19239 var drawing = options.drawings[drawingName];
19258 var imageId = options.mediaIndex && options.mediaIndex[target];
19270 return options.tables[rel.Target];
19322 function BooleanXform(options) {
19328 _this.tag = options.tag;
19329 _this.attr = options.attr;
19395 function DateXform(options) {
19401 _this.tag = options.tag;
19402 _this.attr = options.attr;
19403 _this.attrs = options.attrs;
19405 _this._format = options.format || function (dt) {
19414 _this._parse = options.parse || function (str) {
19506 function IntegerXform(options) {
19512 _this.tag = options.tag;
19513 _this.attr = options.attr;
19514 _this.attrs = options.attrs; // option to render zero
19516 _this.zero = options.zero;
19610 function StringXform(options) {
19616 _this.tag = options.tag;
19617 _this.attr = options.attr;
19618 _this.attrs = options.attrs;
21835 function FontXform(options) {
21841 _this.options = options || FontXform.OPTIONS;
21936 _this.map[_this.options.fontNameTag] = {
21939 tag: _this.options.fontNameTag,
21950 xmlStream.openNode(this.options.tagName);
21972 case this.options.tagName:
22002 case this.options.tagName:
22012 return this.options.tagName;
22282 function StyleXform(options) {
22288 _this.xfId = !!(options && options.xfId);
23432 value: function prepare(model, options) {
23433 model.colId = options.index.toString();
23517 value: function prepare(model, options) {
23518 model.id = options.index + 1;
23724 value: function prepare(model, options) {
23726 this.map.tableColumns.prepare(model.columns, options);
23822 value: function reconcile(model, options) {
23826 column.style = options.styles.getDxfStyle(column.dxfId);
23910 function fsReadFileAsync(filename, options) {
23912 fs.readFile(filename, options, function (error, data) {
23936 …ile = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(filename, options) {
23957 return this.read(stream, options);
24004 value: function reconcile(model, options) {
24006 var worksheetXform = new WorksheetXform(options);
24073 …or( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(stream, model, sheetNo, options, path) {
24079 xform = new WorksheetXform(options);
24389 …ead = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee11(stream, options) {
24473 return _context11.abrupt("return", this.load(Buffer.concat(chunks), options));
24492 …_load = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee12(data, options) {
24499 if (options && options.base64) {
24683 return this._processWorksheetEntry(stream, model, match[1], options, entryName);
24806 this.reconcile(model, options); // apply model
25330 value: function prepareModel(model, options) {
25336 … model.useSharedStrings = options.useSharedStrings !== undefined ? options.useSharedStrings : true;
25337 …model.useStyles = options.useStyles !== undefined ? options.useStyles : true; // Manage the shared…
25371 …ite = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee25(stream, options) {
25377 options = options || {};
25379 zip = new ZipStream.ZipWriter(options.zip);
25381 this.prepareModel(model, options); // render
25445 value: function writeFile(filename, options) {
25457 _this2.write(stream, options).then(function () {
25465 …writeBuffer = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee26(options) {
25473 return this.write(stream, options);
26146 exports.format = function (options) {
26147 …turn new CsvFormatterStream_1.CsvFormatterStream(new FormatterOptions_1.FormatterOptions(options));
26150 exports.write = function (rows, options) {
26151 var csvStream = exports.format(options);
26167 exports.writeToStream = function (ws, rows, options) {
26168 return exports.write(rows, options).pipe(ws);
26188 exports.writeToString = function (rows, options) {
26189 return exports.writeToBuffer(rows, options).then(function (buffer) {
26194 exports.writeToPath = function (path, rows, options) {
26198 return exports.write(rows, options).pipe(stream);
26680 exports.parseStream = function (stream, options) {
26681 …urn stream.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
26685 var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
26686 …(location).pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
26689 exports.parseString = function (string, options) {
26693 return rs.pipe(new CsvParserStream_1.CsvParserStream(new ParserOptions_1.ParserOptions(options)));
27964 Entity.prototype.decode = function decode(data, enc, options) {
27965 return this._getDecoder(enc).decode(data, options);
27992 function DecoderBuffer(base, options) {
27993 Reporter.call(this, options);
28345 Node.prototype._decode = function decode(input, options) {
28348 if (state.parent === null) return input.wrapResult(state.children[0]._decode(input, options));
28363 …oice === null) this._decodeGeneric(state.tag, input, options);else this._decodeChoice(input, optio…
28402 …if (options && options.track && state.tag !== null) options.track(input.path(), start, input.lengt…
28403 …if (options && options.track && state.tag !== null) options.track(input.path(), input.offset, inpu…
28407 result = this._decodeGeneric(state.tag, input, options);
28409 result = this._decodeChoice(input, options);
28418 child._decode(input, options);
28425 result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
28436 Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
28439 …options);else if (/str$/.test(tag)) return this._decodeStr(input, tag, options);else if (tag === '…
28442 return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
28463 Node.prototype._decodeChoice = function decodeChoice(input, options) {
28472 var value = node._decode(input, options);
29422 PEMEncoder.prototype.encode = function encode(data, options) {
29425 var out = ['-----BEGIN ' + options.label + '-----'];
29431 out.push('-----END ' + options.label + '-----');
40836 module.exports = function (METHOD_NAME, options) {
40838 if (!options) options = {};
40840 var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;
40841 var argument0 = has(options, 0) ? options[0] : thrower;
40842 var argument1 = has(options, 1) ? options[1] : undefined;
41241 module.exports = function (options, source) {
41242 var TARGET = options.target;
41243 var GLOBAL = options.global;
41244 var STATIC = options.stat;
41255 if (options.noTargetGet) {
41259 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
41266 if (options.sham || (targetProperty && targetProperty.sham)) {
41270 redefine(target, key, sourceProperty, options);
42167 module.exports = function (target, src, options) {
42168 for (var key in src) redefine(target, key, src[key], options);
42184 (module.exports = function (O, key, value, options) {
42185 var unsafe = options ? !!options.unsafe : false;
42186 var simple = options ? !!options.enumerable : false;
42187 var noTargetGet = options ? !!options.noTargetGet : false;
44620 function CBC(options) {
44621 Base.call(this, options);
44634 CBC.create = function create(options) {
44635 return new CBC(options);
44644 var state = new CBCState(this.options.iv);
44681 function Cipher(options) {
44682 this.options = options;
44683 this.type = this.options.type;
44822 function DES(options) {
44823 Cipher.call(this, options);
44826 this.deriveKeys(state, options.key);
44832 DES.create = function create(options) {
44833 return new DES(options);
44976 function EDE(options) {
44977 Cipher.call(this, options);
44978 var state = new EDEState(this.type, this.options.key);
44985 EDE.create = function create(options) {
44986 return new EDE(options);
47418 function PresetCurve(options) {
47419 …options.type === 'short') this.curve = new curve.short(options);else if (options.type === 'edwards…
47422 this.hash = options.hash;
47429 function defineCurve(name, options) {
47434 var curve = new PresetCurve(options);
47577 function EC(options) {
47578 if (!(this instanceof EC)) return new EC(options); // Shortcut `elliptic.ec(curve-name)`
47580 if (typeof options === 'string') {
47581 assert(curves.hasOwnProperty(options), 'Unknown curve ' + options);
47582 options = curves[options];
47586 if (options instanceof curves.PresetCurve) options = {
47587 curve: options
47589 this.curve = options.curve.curve;
47594 this.g = options.curve.g;
47595 this.g.precompute(options.curve.n.bitLength() + 1); // Hash for function for DRBG
47597 this.hash = options.hash || options.curve.hash;
47602 EC.prototype.keyPair = function keyPair(options) {
47603 return new KeyPair(this, options);
47614 EC.prototype.genKeyPair = function genKeyPair(options) {
47615 if (!options) options = {}; // Instantiate Hmac_DRBG
47619 pers: options.pers,
47620 persEnc: options.persEnc || 'utf8',
47621 entropy: options.entropy || rand(this.hash.hmacStrength),
47622 entropyEnc: options.entropy && options.entropyEnc || 'utf8',
47642 EC.prototype.sign = function sign(msg, key, enc, options) {
47644 options = enc;
47648 if (!options) options = {};
47661 pers: options.pers,
47662 persEnc: options.persEnc || 'utf8'
47668 var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
47681 if (options.canonical && s.cmp(this.nh) > 0) {
47773 function KeyPair(ec, options) {
47778 if (options.priv) this._importPrivate(options.priv, options.privEnc);
47779 if (options.pub) this._importPublic(options.pub, options.pubEnc);
47867 KeyPair.prototype.sign = function sign(msg, enc, options) {
47868 return this.ec.sign(msg, this, enc, options);
47888 function Signature(options, enc) {
47889 if (options instanceof Signature) return options;
47890 if (this._importDER(options, enc)) return;
47891 assert(options.r && options.s, 'Signature without r or s');
47892 this.r = new BN(options.r, 16);
47893 this.s = new BN(options.s, 16);
47894 …if (options.recoveryParam === undefined) this.recoveryParam = null;else this.recoveryParam = optio…
50395 function HmacDRBG(options) {
50396 if (!(this instanceof HmacDRBG)) return new HmacDRBG(options);
50397 this.hash = options.hash;
50398 this.predResist = !!options.predResist;
50400 this.minEntropy = options.minEntropy || this.hash.hmacStrength;
50405 var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
50406 var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
50407 var pers = utils.toArray(options.pers, options.persEnc || 'hex');
51064 function FlateWorker(action, options) {
51068 this._pakoOptions = options; // the `meta` object from the last chunk received
51706 exports.generateWorker = function (zip, options, comment) {
51707 …var zipFileWorker = new ZipFileWorker(options.streamFiles, comment, options.platform, options.enco…
51713 var compression = getCompression(file.options.compression, options.compression);
51714 var compressionOptions = file.options.compressionOptions || options.compressionOptions || {};
51783 JSZip.loadAsync = function (content, options) {
51784 return new JSZip().loadAsync(content, options);
51828 module.exports = function (data, options) {
51830 options = utils.extend(options || {}, {
51842 … utils.prepareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.ba…
51843 var zipEntries = new ZipEntries(options);
51850 if (options.checkCRC32) {
51871 createFolders: options.createFolders
51980 function NodejsStreamOutputAdapter(helper, options, updateCb) {
51981 Readable.call(this, options);
52400 generate: function generate(options) {
52411 generateInternalStream: function generateInternalStream(options) {
52416 opts = utils.extend(options || {}, {
52461 generateAsync: function generateAsync(options, onUpdate) {
52462 return this.generateInternalStream(options).accumulate(onUpdate);
52469 generateNodeStream: function generateNodeStream(options, onUpdate) {
52470 options = options || {};
52472 if (!options.type) {
52473 options.type = "nodebuffer";
52476 return this.generateInternalStream(options).toNodejsStream(onUpdate);
54807 function ZipEntry(options, loadOptions) {
54808 this.options = options;
55098 var ZipObject = function ZipObject(name, data, options) {
55100 this.dir = options.dir;
55101 this.date = options.date;
55102 this.comment = options.comment;
55103 this.unixPermissions = options.unixPermissions;
55104 this.dosPermissions = options.dosPermissions;
55106 this._dataBinary = options.binary; // keep only the compression
55108 this.options = {
55109 compression: options.compression,
55110 compressionOptions: options.compressionOptions
61885 function Deflate(options) {
61886 if (!(this instanceof Deflate)) return new Deflate(options);
61887 this.options = utils.assign({
61895 }, options || {});
61896 var opt = this.options;
61978 var chunkSize = this.options.chunkSize;
62017 if (this.options.to === 'string') {
62071 if (this.options.to === 'string') {
62118 function deflate(input, options) {
62119 var deflator = new Deflate(options);
62138 function deflateRaw(input, options) {
62139 options = options || {};
62140 options.raw = true;
62141 return deflate(input, options);
62153 function gzip(input, options) {
62154 options = options || {};
62155 options.gzip = true;
62156 return deflate(input, options);
62261 function Inflate(options) {
62262 if (!(this instanceof Inflate)) return new Inflate(options);
62263 this.options = utils.assign({
62267 }, options || {});
62268 var opt = this.options; // Force window size for `raw` data, if not set directly,
62280 if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
62363 var chunkSize = this.options.chunkSize;
62364 var dictionary = this.options.dictionary;
62418 if (this.options.to === 'string') {
62499 if (this.options.to === 'string') {
62553 function inflate(input, options) {
62554 var inflator = new Inflate(options);
62573 function inflateRaw(input, options) {
62574 options = options || {};
62575 options.raw = true;
62576 return inflate(input, options);
71495 function Duplex(options) {
71496 if (!(this instanceof Duplex)) return new Duplex(options);
71497 Readable.call(this, options);
71498 Writable.call(this, options);
71501 if (options) {
71502 if (options.readable === false) this.readable = false;
71503 if (options.writable === false) this.writable = false;
71505 if (options.allowHalfOpen === false) {
71612 function PassThrough(options) {
71613 if (!(this instanceof PassThrough)) return new PassThrough(options);
71614 Transform.call(this, options);
71728 function ReadableState(options, stream, isDuplex) {
71730 options = options || {}; // Duplex streams are both readable and writable, but share
71739 this.objectMode = !!options.objectMode;
71740 …if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at w…
71743 …this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A link…
71768 …this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and pote…
71770 this.autoDestroy = !!options.autoDestroy; // has it been destroyed
71776 …this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiti…
71784 if (options.encoding) {
71786 this.decoder = new StringDecoder(options.encoding);
71787 this.encoding = options.encoding;
71791 function Readable(options) {
71793 …if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex ins…
71797 this._readableState = new ReadableState(options, this, isDuplex); // legacy
71801 if (options) {
71802 if (typeof options.read === 'function') this._read = options.read;
71803 if (typeof options.destroy === 'function') this._destroy = options.destroy;
72848 function Transform(options) {
72849 if (!(this instanceof Transform)) return new Transform(options);
72850 Duplex.call(this, options);
72866 if (options) {
72867 if (typeof options.transform === 'function') this._transform = options.transform;
72868 if (typeof options.flush === 'function') this._flush = options.flush;
73057 function WritableState(options, stream, isDuplex) {
73059 options = options || {}; // Duplex streams are both readable and writable, but share
73068 this.objectMode = !!options.objectMode;
73069 …if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at w…
73073 …this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _fi…
73089 var noDecode = options.decodeStrings === false;
73094 …this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of…
73132 …this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and p…
73134 this.autoDestroy = !!options.autoDestroy; // count buffered requests
73183 function Writable(options) {
73194 if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
73195 this._writableState = new WritableState(options, this, isDuplex); // legacy.
73199 if (options) {
73200 if (typeof options.write === 'function') this._write = options.write;
73201 if (typeof options.writev === 'function') this._writev = options.writev;
73202 if (typeof options.destroy === 'function') this._destroy = options.destroy;
73203 if (typeof options.final === 'function') this._final = options.final;
74136 value: function value(_, options) {
74137 return inspect(this, _objectSpread({}, options, {
74476 function highWaterMarkFrom(options, isDuplex, duplexKey) {
74477 …return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : nul…
74480 function getHighWaterMark(state, options, duplexKey, isDuplex) {
74481 var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
78916 Stream.prototype.pipe = function (dest, options) {
78938 if (!dest._isStdio && (!options || options.end !== false)) {
79062 function Duplex(options) {
79063 if (!(this instanceof Duplex)) return new Duplex(options);
79064 Readable.call(this, options);
79065 Writable.call(this, options);
79066 if (options && options.readable === false) this.readable = false;
79067 if (options && options.writable === false) this.writable = false;
79069 if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
79162 function PassThrough(options) {
79163 if (!(this instanceof PassThrough)) return new PassThrough(options);
79164 Transform.call(this, options);
79284 function ReadableState(options, stream) {
79286 options = options || {}; // Duplex streams are both readable and writable, but share
79295 this.objectMode = !!options.objectMode;
79296 …if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at w…
79299 var hwm = options.highWaterMark;
79300 var readableHwm = options.readableHighWaterMark;
79332 …this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiti…
79340 if (options.encoding) {
79342 this.decoder = new StringDecoder(options.encoding);
79343 this.encoding = options.encoding;
79347 function Readable(options) {
79349 if (!(this instanceof Readable)) return new Readable(options);
79350 this._readableState = new ReadableState(options, this); // legacy
79354 if (options) {
79355 if (typeof options.read === 'function') this._read = options.read;
79356 if (typeof options.destroy === 'function') this._destroy = options.destroy;
80313 function Transform(options) {
80314 if (!(this instanceof Transform)) return new Transform(options);
80315 Duplex.call(this, options);
80331 if (options) {
80332 if (typeof options.transform === 'function') this._transform = options.transform;
80333 if (typeof options.flush === 'function') this._flush = options.flush;
80530 function WritableState(options, stream) {
80532 options = options || {}; // Duplex streams are both readable and writable, but share
80541 this.objectMode = !!options.objectMode;
80542 …if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at w…
80546 var hwm = options.highWaterMark;
80547 var writableHwm = options.writableHighWaterMark;
80567 var noDecode = options.decodeStrings === false;
80572 …this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of…
80657 function Writable(options) {
80666 return new Writable(options);
80669 this._writableState = new WritableState(options, this); // legacy.
80673 if (options) {
80674 if (typeof options.write === 'function') this._write = options.write;
80675 if (typeof options.writev === 'function') this._writev = options.writev;
80676 if (typeof options.destroy === 'function') this._destroy = options.destroy;
80677 if (typeof options.final === 'function') this._final = options.final;
83028 function v1(options, buf, offset) {
83031 options = options || {};
83032 var node = options.node || _nodeId;
83033 …var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq…
83038 var seedBytes = options.random || (options.rng || _rng.default)();
83055 …var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of…
83058 …var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid …
83062 if (dt < 0 && options.clockseq === undefined) {
83068 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
83235 function v4(options, buf, offset) {
83236 options = options || {};
83238 …var rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and…