Lines Matching refs:data
162 var csvStream = fastCsv.parse(options.parserOptions).on('data', function (data) {
163 worksheet.addRow(data.map(map));
3651 table.rows.forEach(function (data) {
3653 data.forEach(function (value, j) {
3705 table.rows.forEach(function (data) {
3707 data.forEach(function (value, j) {
6277 function StringChunk(data, encoding) {
6280 this._data = data;
6310 function StringBufChunk(data) {
6313 this._data = data;
6339 function BufferChunk(data) {
6342 this._data = data;
6545 write: function write(data, encoding, callback) {
6561 if (!(data instanceof StringBuf)) {
6566 chunk = new StringBufChunk(data);
6571 if (!(data instanceof Buffer)) {
6576 chunk = new BufferChunk(data);
6581 … if (!(typeof data === 'string' || data instanceof String || data instanceof ArrayBuffer)) {
6586 chunk = new StringChunk(data, encoding);
7553 value: function append(data, options) {
7555 this.zip.file(options.name, data, {
7560 if (process.browser && typeof data === 'string') {
7562 data = stringToBuffer(data);
7565 this.zip.file(options.name, data);
9766 data: 1
23912 fs.readFile(filename, options, function (error, data) {
23916 resolve(data);
24492 …var _load = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee12(data, optio…
24500 buffer = Buffer.from(data.toString(), 'base64');
24502 buffer = data;
24838 var filename, data, dataimg64, content;
24859 data = _context13.sent;
24860 return _context13.abrupt("return", zip.append(data, {
26175 write: function write(data, enc, writeCb) {
26176 buffers.push(data);
26322 value: function _transform(data, encoding, done) {
26330 var newLine = lines + this.decoder.write(data);
26355 value: function parse(data, hasMoreData) {
26356 if (!data) {
26360 var _this$parser$parse = this.parser.parse(data, hasMoreData),
27964 Entity.prototype.decode = function decode(data, enc, options) {
27965 return this._getDecoder(enc).decode(data, options);
27975 Entity.prototype.encode = function encode(data, enc,
27978 return this._getEncoder(enc).encode(data, reporter);
28008 DecoderBuffer.isDecoderBuffer = function isDecoderBuffer(data) {
28009 if (data instanceof DecoderBuffer) {
28014 …data) === 'object' && Buffer.isBuffer(data.base) && data.constructor.name === 'DecoderBuffer' && t…
28083 EncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {
28084 if (data instanceof EncoderBuffer) {
28089 …ompatible = _typeof(data) === 'object' && data.constructor.name === 'EncoderBuffer' && typeof data…
28424 var data = new DecoderBuffer(result);
28425 result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
28494 Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
28495 return new EncoderBuffer(data, this.reporter);
28498 Node.prototype._encode = function encode(data, reporter, parent) {
28500 if (state['default'] !== null && state['default'] === data) return;
28502 var result = this._encodeValue(data, reporter, parent);
28509 Node.prototype._encodeValue = function encode(data, reporter, parent) {
28512 if (state.parent === null) return state.children[0]._encode(data, reporter || new Reporter());
28517 if (state.optional && data === undefined) {
28518 if (state['default'] !== null) data = state['default'];else return;
28527 result = this._createEncoderBuffer(data);
28529 result = this._encodeChoice(data, reporter);
28531 content = this._getUse(state.contains, parent)._encode(data, reporter);
28535 if (child._baseState.tag === 'null_') return child._encode(null, reporter, data);
28538 … if (_typeof(data) !== 'object') return reporter.error('Child expected, but input is not object');
28540 var res = child._encode(data[child._baseState.key], reporter, data);
28552 if (!Array.isArray(data)) return reporter.error('seqof/setof, but data is not Array');
28555 content = this._createEncoderBuffer(data.map(function (item) {
28557 return this._getUse(state.args[0], data)._encode(item, reporter);
28560 result = this._getUse(state.use, parent)._encode(data, reporter);
28562 content = this._encodePrimitive(state.tag, data);
28584 Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
28586 var node = state.choice[data.type];
28589 assert(false, data.type + ' not found in ' + JSON.stringify(Object.keys(state.choice)));
28592 return node._encode(data.value, reporter);
28595 Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
28597 …data, tag);else if (tag === 'objid' && state.args) return this._encodeObjid(data, state.reverseArg…
29378 var data = dataBuffer.join();
29380 if (data.length !== state.defaultBuffer.length) return false;
29382 for (i = 0; i < data.length; i++) {
29383 if (data[i] !== state.defaultBuffer[i]) return false;
29422 PEMEncoder.prototype.encode = function encode(data, options) {
29423 var buf = DEREncoder.prototype.encode.call(this, data);
37075 Decipher.prototype._update = function (data) {
37076 this._cache.add(data);
37109 Splitter.prototype.add = function (data) {
37110 this.cache = Buffer.concat([this.cache, data]);
37213 Cipher.prototype._update = function (data) {
37214 this._cache.add(data);
37257 Splitter.prototype.add = function (data) {
37258 this.cache = Buffer.concat([this.cache, data]);
37432 var data = xor(block, self._prev);
37433 self._prev = self._cipher.encryptBlock(data);
37453 function encryptStart(self, data, decrypt) {
37454 var len = data.length;
37455 var out = xor(data, self._cache);
37457 self._prev = Buffer.concat([self._prev, decrypt ? data : out]);
37461 exports.encrypt = function (self, data, decrypt) {
37465 while (data.length) {
37471 if (self._cache.length <= data.length) {
37473 out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
37474 data = data.slice(len);
37476 out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
38023 DES.prototype._update = function (data) {
38024 return Buffer.from(this._des.update(data));
38308 var data = algorithms[algorithm];
38309 if (!data) throw new Error('Unknown message digest');
38310 this._hashType = data.hash;
38311 this._hash = createHash(data.hash);
38312 this._tag = data.id;
38313 this._signType = data.sign;
38318 Sign.prototype._write = function _write(data, _, done) {
38319 this._hash.update(data);
38324 Sign.prototype.update = function update(data, enc) {
38325 if (typeof data === 'string') data = Buffer.from(data, enc);
38327 this._hash.update(data);
38343 var data = algorithms[algorithm];
38344 if (!data) throw new Error('Unknown message digest');
38345 this._hash = createHash(data.hash);
38346 this._tag = data.id;
38347 this._signType = data.sign;
38352 Verify.prototype._write = function _write(data, _, done) {
38353 this._hash.update(data);
38358 Verify.prototype.update = function update(data, enc) {
38359 if (typeof data === 'string') data = Buffer.from(data, enc);
38361 this._hash.update(data);
38621 var curveId = curves[pub.data.algorithm.curve.join('.')];
38622 if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'));
38624 var pubkey = pub.data.subjectPrivateKey.data;
38629 var p = pub.data.p;
38630 var q = pub.data.q;
38631 var g = pub.data.g;
38632 var y = pub.data.pub_key;
39039 if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
39040 return fromArrayLike(obj.data);
39686 data: Array.prototype.slice.call(this._arr || this, 0)
40584 CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
40585 if (typeof data === 'string') {
40586 data = Buffer.from(data, inputEnc);
40589 var outData = this._update(data);
40614 CipherBase.prototype._transform = function (data, _, next) {
40619 this._update(data);
40621 this.push(this._update(data));
41509 var value = data[normalize(feature)];
41520 var data = isForced.data = {};
41681 node.data = toggle = !toggle;
42344 run(event.data);
43754 Hash.prototype._update = function (data) {
43755 this._hash.update(data);
43830 Hmac.prototype._update = function (data) {
43831 this._hash.update(data);
43896 Hmac.prototype._update = function (data) {
43897 this._hash.push(data);
44697 Cipher.prototype.update = function update(data) {
44698 if (data.length === 0) return [];
44699 …f (this.type === 'decrypt') return this._updateDecrypt(data);else return this._updateEncrypt(data);
44702 Cipher.prototype._buffer = function _buffer(data, off) {
44704 var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);
44707 this.buffer[this.bufferOff + i] = data[off + i];
44722 Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
44725 var count = (this.bufferOff + data.length) / this.blockSize | 0;
44729 inputOff += this._buffer(data, inputOff);
44734 var max = data.length - (data.length - inputOff) % this.blockSize;
44737 this._update(data, inputOff, out, outputOff);
44743 for (; inputOff < data.length; inputOff++, this.bufferOff++) {
44744 this.buffer[this.bufferOff] = data[inputOff];
44750 Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
44753 var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
44757 inputOff += this._buffer(data, inputOff);
44762 inputOff += this._buffer(data, inputOff);
47948 Signature.prototype._importDER = function _importDER(data, enc) {
47949 data = utils.toArray(data, enc);
47952 if (data[p.place++] !== 0x30) {
47956 var len = getLength(data, p);
47962 if (len + p.place !== data.length) {
47966 if (data[p.place++] !== 0x02) {
47970 var rlen = getLength(data, p);
47976 var r = data.slice(p.place, rlen + p.place);
47979 if (data[p.place++] !== 0x02) {
47983 var slen = getLength(data, p);
47989 if (data.length !== slen + p.place) {
47993 var s = data.slice(p.place, slen + p.place);
49275 HashBase.prototype.update = function (data, encoding) {
49276 throwIfNotStringOrBuffer(data, 'Data');
49278 if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding); // consume data
49283 while (this._blockOffset + data.length - offset >= this._blockSize) {
49285 block[i++] = data[offset++];
49293 while (offset < data.length) {
49294 block[this._blockOffset++] = data[offset++];
49298 for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
50602 element.data = called = ++called % 2;
50864 function CompressedObject(compressedSize, uncompressedSize, crc32, compression, data) {
50869 this.compressedContent = data;
51086 this._pako.push(utils.transformTo(ARRAY_TYPE, chunk.data), false);
51127 this._pako.onData = function (data) {
51129 data: data,
51479 this.bytesWritten += chunk.data.length;
51481 data: chunk.data,
51503 data: record.fileRecord,
51528 data: generateDataDescriptors(streamInfo),
51537 data: record.fileRecord,
51560 data: this.dirRecords[i],
51570 data: dirEnd,
51828 module.exports = function (data, options) {
51838 if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
51842 …repareContent("the loaded zip file", data, true, options.optimizedBinaryString, options.base64).th…
51844 zipEntries.load(data);
51917 data: chunk,
51984 helper.on("data", function (data, meta) {
51985 if (!self.push(data)) {
52023 newBufferFrom: function newBufferFrom(data, encoding) {
52025 return Buffer.from(data, encoding);
52027 if (typeof data === "number") {
52033 return new Buffer(data, encoding);
52099 var fileAdd = function fileAdd(name, data, originalOptions) {
52101 var dataType = utils.getTypeOf(data),
52142 var isCompressedEmpty = data instanceof CompressedObject && data.uncompressedSize === 0;
52144 if (isCompressedEmpty || o.dir || !data || data.length === 0) {
52147 data = "";
52158 if (data instanceof CompressedObject || data instanceof GenericWorker) {
52159 zipObjectContent = data;
52160 } else if (nodejsUtils.isNode && nodejsUtils.isStream(data)) {
52161 zipObjectContent = new NodejsStreamInputAdapter(name, data);
52163 … zipObjectContent = utils.prepareContent(name, data, o.binary, o.optimizedBinaryString, o.base64);
52307 file: function file(name, data, o) {
52327 fileAdd.call(this, name, data, o);
52501 function ArrayReader(data) {
52502 DataReader.call(this, data);
52504 for (var i = 0; i < this.data.length; i++) {
52505 data[i] = data[i] & 0xFF;
52515 return this.data[this.zero + i];
52529 …if (this.data[i] === sig0 && this.data[i + 1] === sig1 && this.data[i + 2] === sig2 && this.data[i…
52546 data = this.readData(4);
52547 return sig0 === data[0] && sig1 === data[1] && sig2 === data[2] && sig3 === data[3];
52561 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
52573 function DataReader(data) {
52574 this.data = data; // type : see implementation
52576 this.length = data.length;
52703 function NodeBufferReader(data) {
52704 Uint8ArrayReader.call(this, data);
52714 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
52728 function StringReader(data) {
52729 DataReader.call(this, data);
52738 return this.data.charCodeAt(this.zero + i);
52746 return this.data.lastIndexOf(sig) - this.zero;
52754 var data = this.readData(4);
52755 return sig === data;
52765 var result = this.data.slice(this.zero + this.index, this.zero + this.index + size);
52779 function Uint8ArrayReader(data) {
52780 ArrayReader.call(this, data);
52796 var result = this.data.subarray(this.zero + this.index, this.zero + this.index + size);
52824 module.exports = function (data) {
52825 var type = utils.getTypeOf(data);
52829 return new StringReader(data);
52833 return new NodeBufferReader(data);
52837 return new Uint8ArrayReader(utils.transformTo("uint8array", data));
52840 return new ArrayReader(utils.transformTo("array", data));
52878 data: utils.transformTo(this.destType, chunk.data),
52910 this.streamInfo.crc32 = crc32(chunk.data, this.streamInfo.crc32 || 0);
52943 this.streamInfo[this.propName] = length + chunk.data.length;
52973 this.data = null;
52976 dataP.then(function (data) {
52978 self.data = data;
52979 self.max = data && data.length || 0;
52980 self.type = utils.getTypeOf(data);
52997 this.data = null;
53046 var data = null,
53055 data = this.data.substring(this.index, nextIndex);
53059 data = this.data.subarray(this.index, nextIndex);
53064 data = this.data.slice(this.index, nextIndex);
53070 data: data,
53473 helper.on('data', function (data, meta) {
53474 dataArray.push(data);
53558 fn.call(self, chunk.data, chunk.meta);
53896 …var data = utils.transformTo(support.uint8array ? "uint8array" : "array", chunk.data); // 1st step…
53900 var previousData = data;
53901 data = new Uint8Array(previousData.length + this.leftOver.length);
53902 data.set(this.leftOver, 0);
53903 data.set(previousData, this.leftOver.length);
53905 data = this.leftOver.concat(data);
53911 var nextBoundary = utf8border(data);
53912 var usableData = data;
53914 if (nextBoundary !== data.length) {
53916 usableData = data.subarray(0, nextBoundary);
53917 this.leftOver = data.subarray(nextBoundary, data.length);
53919 usableData = data.slice(0, nextBoundary);
53920 this.leftOver = data.slice(nextBoundary, data.length);
53925 data: exports.utf8decode(usableData),
53937 data: exports.utf8decode(this.leftOver),
53961 data: exports.utf8encode(chunk.data),
54427 var promise = external.Promise.resolve(inputData).then(function (data) {
54428 …sBlob = support.blob && (data instanceof Blob || ['[object File]', '[object Blob]'].indexOf(Object…
54442 reader.readAsArrayBuffer(data);
54445 return data;
54448 return promise.then(function (data) {
54449 var dataType = exports.getTypeOf(data);
54457 data = exports.transformTo("uint8array", data);
54460 data = base64.decode(data);
54466 data = string2binary(data);
54471 return data;
54742 prepareReader: function prepareReader(data) {
54743 this.reader = readerFor(data);
54750 load: function load(data) {
54751 this.prepareReader(data);
55098 var ZipObject = function ZipObject(name, data, options) {
55105 this._data = data;
56139 var data = this.__data__;
56142 var result = data[key];
56146 return hasOwnProperty.call(data, key) ? data[key] : undefined;
56160 var data = this.__data__;
56161 return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
56176 var data = this.__data__;
56177 data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
56229 var data = this.__data__,
56230 index = assocIndexOf(data, key);
56236 var lastIndex = data.length - 1;
56239 data.pop();
56241 splice.call(data, index, 1);
56258 var data = this.__data__,
56259 index = assocIndexOf(data, key);
56260 return index < 0 ? undefined : data[index][1];
56289 var data = this.__data__,
56290 index = assocIndexOf(data, key);
56293 data.push([key, value]);
56295 data[index][1] = value;
56819 var data = matchData[index];
56821 if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
56827 data = matchData[index];
56828 var key = data[0],
56830 srcValue = data[1];
56832 if (noCustomizer && data[2]) {
57351 var data = map.__data__;
57352 return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
58703 var data = this.__data__;
58706 var result = data[key];
58710 return hasOwnProperty.call(data, key) ? data[key] : undefined;
58724 var data = this.__data__;
58725 return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
58740 var data = this.__data__;
58742 data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
58795 var data = this.__data__,
58796 index = assocIndexOf(data, key);
58802 var lastIndex = data.length - 1;
58805 data.pop();
58807 splice.call(data, index, 1);
58825 var data = this.__data__,
58826 index = assocIndexOf(data, key);
58827 return index < 0 ? undefined : data[index][1];
58856 var data = this.__data__,
58857 index = assocIndexOf(data, key);
58861 data.push([key, value]);
58863 data[index][1] = value;
58967 var data = getMapData(this, key),
58968 size = data.size;
58969 data.set(key, value);
58970 this.size += data.size == size ? 0 : 1;
59042 var data = this.__data__ = new ListCache(entries);
59043 this.size = data.size;
59070 var data = this.__data__,
59071 result = data['delete'](key);
59072 this.size = data.size;
59116 var data = this.__data__;
59118 if (data instanceof ListCache) {
59119 var pairs = data.__data__;
59123 this.size = ++data.size;
59127 data = this.__data__ = new MapCache(pairs);
59130 data.set(key, value);
59131 this.size = data.size;
59641 var data = map.__data__;
59642 return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
60770 var data = this.__data__;
60773 var result = data[key];
60777 return hasOwnProperty.call(data, key) ? data[key] : undefined;
60791 var data = this.__data__;
60792 return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
60807 var data = this.__data__;
60808 data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
60860 var data = this.__data__,
60861 index = assocIndexOf(data, key);
60867 var lastIndex = data.length - 1;
60870 data.pop();
60872 splice.call(data, index, 1);
60889 var data = this.__data__,
60890 index = assocIndexOf(data, key);
60891 return index < 0 ? undefined : data[index][1];
60920 var data = this.__data__,
60921 index = assocIndexOf(data, key);
60924 data.push([key, value]);
60926 data[index][1] = value;
61216 var data = map.__data__;
61217 return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
61976 Deflate.prototype.push = function (data, mode) {
61988 if (typeof data === 'string') {
61990 strm.input = strings.string2buf(data);
61991 } else if (toString.call(data) === '[object ArrayBuffer]') {
61992 strm.input = new Uint8Array(data);
61994 strm.input = data;
62361 Inflate.prototype.push = function (data, mode) {
62379 if (typeof data === 'string') {
62381 strm.input = strings.binstring2buf(data);
62382 } else if (toString.call(data) === '[object ArrayBuffer]') {
62383 strm.input = new Uint8Array(data);
62385 strm.input = data;
70083 data: decrypted
70120 var data = stripped.data;
70125 ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo;
70130 ndata = asn1.PublicKey.decode(data, 'der');
70137 return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der');
70143 data: ndata
70147 ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der');
70150 data: ndata.algorithm.params
70160 data = asn1.EncryptedPrivateKey.decode(data, 'der');
70161 data = decrypt(data, password);
70165 ndata = asn1.PrivateKey.decode(data, 'der');
70192 return asn1.RSAPublicKey.decode(data, 'der');
70195 return asn1.RSAPrivateKey.decode(data, 'der');
70200 params: asn1.DSAPrivateKey.decode(data, 'der')
70204 data = asn1.ECPrivateKey.decode(data, 'der');
70206 curve: data.parameters.value,
70207 privateKey: data.privateKey
70217 function decrypt(data, password) {
70218 var salt = data.algorithm.decrypt.kde.kdeparams.salt;
70219 var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
70220 var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')];
70221 var iv = data.algorithm.decrypt.cipher.iv;
70222 var cipherText = data.subjectPrivateKey;
70456 Hmac.prototype.run = function (data, ipad) {
70457 data.copy(ipad, this.blocksize);
70464 function shaFunc(data) {
70465 return sha(alg).update(data).digest();
70468 function rmd160Func(data) {
70469 return new RIPEMD160().update(data).digest();
71957 content += decoder.write(p.data);
71998 … if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
72826 function afterTransform(er, data) {
72837 if (data != null) // single equals check for both `null` and `undefined`
72838 this.push(data);
72879 this._flush(function (er, data) {
72880 done(_this, er, data);
72941 function done(stream, er, data) {
72943 if (data != null) // single equals check for both `null` and `undefined`
72944 stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
73697 var data = iter[kStream].read(); // we defer if data is null
73701 if (data !== null) {
73705 resolve(createIterResult(data, false));
73778 var data = this[kStream].read();
73780 if (data !== null) {
73781 return Promise.resolve(createIterResult(data, false));
73830 var data = iterator[kStream].read();
73832 if (data) {
73836 resolve(createIterResult(data, false));
73979 data: v,
73990 data: v,
74001 var ret = this.head.data;
74017 var ret = '' + p.data;
74020 ret += s + p.data;
74034 copyBuffer(p.data, ret, i);
74035 i += p.data.length;
74047 if (n < this.head.data.length) {
74049 ret = this.head.data.slice(0, n);
74050 this.head.data = this.head.data.slice(n);
74051 } else if (n === this.head.data.length) {
74064 return this.head.data;
74072 var ret = p.data;
74076 var str = p.data;
74087 p.data = str.slice(nb);
74106 p.data.copy(ret);
74107 n -= p.data.length;
74110 var buf = p.data;
74121 p.data = buf.slice(nb);
78148 Hash.prototype.update = function (data, enc) {
78149 if (typeof data === 'string') {
78151 data = Buffer.from(data, enc);
78156 var length = data.length;
78164 block[assigned + i] = data[offset + i];
79536 … if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
80084 …ffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.bu…
80099 if (n < list.head.data.length) {
80101 ret = list.head.data.slice(0, n);
80102 list.head.data = list.head.data.slice(n);
80103 } else if (n === list.head.data.length) {
80121 var ret = p.data;
80125 var str = p.data;
80136 p.data = str.slice(nb);
80156 p.data.copy(ret);
80157 n -= p.data.length;
80160 var buf = p.data;
80171 p.data = buf.slice(nb);
80291 function afterTransform(er, data) {
80302 if (data != null) // single equals check for both `null` and `undefined`
80303 this.push(data);
80344 this._flush(function (er, data) {
80345 done(_this, er, data);
80410 function done(stream, er, data) {
80412 if (data != null) // single equals check for both `null` and `undefined`
80413 stream.push(data); // if there's nothing in the write buffer, then that means
81129 data: v,
81139 data: v,
81149 var ret = this.head.data;
81163 var ret = '' + p.data;
81166 ret += s + p.data;
81174 if (this.length === 1) return this.head.data;
81180 copyBuffer(p.data, ret, i);
81181 i += p.data.length;