Lines Matching refs:Buffer
5420 Buffer = _require.Buffer;
5428 return Buffer.from(textEncoder.encode(str).buffer);
5431 return Buffer.from(str);
5968 (function (Buffer){
5986 hash.update(Buffer.concat(buffers));
6009 var passwordBuffer = Buffer.from(password, 'utf16le'); // Generate the initial hash
6011 …var key = this.hash(hashAlgorithm, Buffer.from(saltValue, 'base64'), passwordBuffer); // Now regen…
6014 var iterator = Buffer.alloc(4); // this is the 'special' element of Excel password hashing
6034 }).call(this,require("buffer").Buffer)
6254 (function (process,Buffer){
6294 this._buffer = Buffer.from(this._data, this._encoding);
6374 this.buffer = Buffer.alloc(size); // read index
6388 var buf = Buffer.alloc(this.iWrite - this.iRead);
6410 buf = Buffer.alloc(size);
6481 return Buffer.concat(this.buffers.map(function (rwBuf) {
6571 if (!(data instanceof Buffer)) {
6721 return Buffer.concat(buffers);
6728 return Buffer.concat(buffers);
6773 }).call(this,require('_process'),require("buffer").Buffer)
6776 (function (Buffer){
6791 this._buf = Buffer.alloc(options && options.size || 16384);
6804 this._buffer = Buffer.alloc(this.length);
6827 var buf = Buffer.alloc(size);
6888 }).call(this,require("buffer").Buffer)
23851 (function (process,Buffer){
24473 return _context11.abrupt("return", this.load(Buffer.concat(chunks), options));
24500 buffer = Buffer.from(data.toString(), 'base64');
25500 }).call(this,require('_process'),require("buffer").Buffer)
25509 (function (Buffer){
25592 _this2.push(Buffer.from(r, 'utf8'));
25619 _this3.push(Buffer.from(r, 'utf8'));
25633 }).call(this,require("buffer").Buffer)
26068 (function (Buffer){
26182 return res(Buffer.concat(buffers));
26201 }).call(this,require("buffer").Buffer)
27990 var Buffer = require('safer-buffer').Buffer;
27995 if (!Buffer.isBuffer(base)) {
28014 …var isCompatible = _typeof(data) === 'object' && Buffer.isBuffer(data.base) && data.constructor.na…
28072 this.length = Buffer.byteLength(value);
28073 } else if (Buffer.isBuffer(value)) {
28094 if (!out) out = Buffer.alloc(this.length);
28104 … (typeof this.value === 'string') out.write(this.value, offset);else if (Buffer.isBuffer(this.valu…
29322 if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
29329 num = Buffer.from(numArray);
29332 if (Buffer.isBuffer(num)) {
29336 var _out = Buffer.alloc(_size);
29362 return this._createEncoderBuffer(Buffer.from(out));
29489 var Buffer;
29492 Buffer = require('buffer').Buffer;
29924 assert(typeof Buffer !== 'undefined');
29925 return this.toArrayLike(Buffer, endian, length);
33078 var Buffer;
33081 Buffer = require('buffer').Buffer;
33546 if (Buffer) {
33548 return this.toArrayLike(Buffer, endian, length);
36685 var Buffer = require('safe-buffer').Buffer;
36688 if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
36862 var buf = Buffer.allocUnsafe(16);
36877 var buf = Buffer.allocUnsafe(16);
36898 var Buffer = require('safe-buffer').Buffer;
36924 self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])]);
36925 return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])]);
36935 ghash.update(Buffer.alloc(toPad, 0));
36938 ghash.update(Buffer.alloc(8, 0));
36940 var tail = Buffer.alloc(8);
36944 var out = Buffer.from(self._finID);
36951 var h = Buffer.alloc(4, 0);
36958 this._prev = Buffer.from(iv);
36959 this._cache = Buffer.allocUnsafe(0);
36960 this._secCache = Buffer.allocUnsafe(0);
36976 rump = Buffer.alloc(rump, 0);
37006 …if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag …
37049 var Buffer = require('safe-buffer').Buffer;
37068 this._prev = Buffer.from(iv);
37087 return Buffer.concat(out);
37106 this.cache = Buffer.allocUnsafe(0);
37110 this.cache = Buffer.concat([this.cache, data]);
37159 if (typeof iv === 'string') iv = Buffer.from(iv);
37161 if (typeof password === 'string') password = Buffer.from(password);
37190 var Buffer = require('safe-buffer').Buffer;
37206 this._prev = Buffer.from(iv);
37225 return Buffer.concat(out);
37228 var PADDING = Buffer.alloc(16, 0x10);
37254 this.cache = Buffer.allocUnsafe(0);
37258 this.cache = Buffer.concat([this.cache, data]);
37273 var padBuff = Buffer.allocUnsafe(len);
37280 return Buffer.concat([this.cache, padBuff]);
37286 if (typeof password === 'string') password = Buffer.from(password);
37288 if (typeof iv === 'string') iv = Buffer.from(iv);
37313 var Buffer = require('safe-buffer').Buffer;
37315 var ZEROES = Buffer.alloc(16, 0);
37322 var buf = Buffer.allocUnsafe(16);
37332 this.state = Buffer.alloc(16, 0);
37333 this.cache = Buffer.allocUnsafe(0);
37383 this.cache = Buffer.concat([this.cache, buf]);
37395 this.ghash(Buffer.concat([this.cache, ZEROES], 16));
37449 var Buffer = require('safe-buffer').Buffer;
37457 self._prev = Buffer.concat([self._prev, decrypt ? data : out]);
37462 var out = Buffer.allocUnsafe(0);
37468 self._prev = Buffer.allocUnsafe(0);
37473 out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
37476 out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
37487 var Buffer = require('safe-buffer').Buffer;
37510 var out = Buffer.allocUnsafe(buffer.length);
37511 buffer = Buffer.concat([buffer, Buffer.from([value])]);
37522 var out = Buffer.allocUnsafe(len);
37535 var Buffer = require('safe-buffer').Buffer;
37541 self._prev = Buffer.concat([self._prev.slice(1), Buffer.from([decrypt ? byteParam : out])]);
37547 var out = Buffer.allocUnsafe(len);
37562 var Buffer = require('safe-buffer').Buffer;
37578 self._cache = Buffer.concat([self._cache, Buffer.allocUnsafe(chunkNum * blockSize)]);
37826 (function (Buffer){
37838 self._cache = Buffer.concat([self._cache, getBlock(self)]);
37847 }).call(this,require("buffer").Buffer)
37854 var Buffer = require('safe-buffer').Buffer;
37863 this._prev = Buffer.from(iv);
37864 this._cache = Buffer.allocUnsafe(0);
37865 this._secCache = Buffer.allocUnsafe(0);
37973 var Buffer = require('safe-buffer').Buffer;
38002 if (!Buffer.isBuffer(key)) {
38003 key = Buffer.from(key);
38007 key = Buffer.concat([key, key.slice(0, 8)]);
38012 if (!Buffer.isBuffer(iv)) {
38013 iv = Buffer.from(iv);
38024 return Buffer.from(this._des.update(data));
38028 return Buffer.from(this._des.final());
38060 (function (Buffer){
38095 return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false, len));
38111 }).call(this,require("buffer").Buffer)
38287 var Buffer = require('safe-buffer').Buffer;
38302 algorithms[key].id = Buffer.from(algorithms[key].id, 'hex');
38325 if (typeof data === 'string') data = Buffer.from(data, enc);
38359 if (typeof data === 'string') data = Buffer.from(data, enc);
38367 if (typeof sig === 'string') sig = Buffer.from(sig, enc);
38394 var Buffer = require('safe-buffer').Buffer;
38422 hash = Buffer.concat([tag, hash]);
38447 return Buffer.from(out.toDER());
38484 return Buffer.from(res);
38488 x = Buffer.from(x.toArray());
38491 var zeros = Buffer.alloc(q.byteLength() - x.length);
38492 x = Buffer.concat([zeros, x]);
38497 var v = Buffer.alloc(hlen);
38499 var k = Buffer.alloc(hlen);
38500 k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest();
38502 k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest();
38520 var out = Buffer.from(bits.toArray());
38523 var zeros = Buffer.alloc(q.byteLength() - out.length);
38524 out = Buffer.concat([zeros, out]);
38535 t = Buffer.alloc(0);
38539 t = Buffer.concat([t, kv.v]);
38543 kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest();
38562 var Buffer = require('safe-buffer').Buffer;
38586 hash = Buffer.concat([tag, hash]);
38603 pad = Buffer.from(pad);
38607 sig = Buffer.from(sig.fromRed().toArray());
38659 var Buffer = buffer.Buffer; // alternative to using Object.keys for old browsers
38667 if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
38672 exports.Buffer = SafeBuffer;
38676 return Buffer(arg, encodingOrOffset, length);
38679 SafeBuffer.prototype = Object.create(Buffer.prototype); // Copy static methods from Buffer
38681 copyProps(Buffer, SafeBuffer);
38688 return Buffer(arg, encodingOrOffset, length);
38696 var buf = Buffer(size);
38716 return Buffer(size);
38730 (function (Buffer){
38747 exports.Buffer = Buffer;
38767 Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
38769 if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' && typeof console.error === 'func…
38789 Object.defineProperty(Buffer.prototype, 'parent', {
38792 if (!Buffer.isBuffer(this)) return undefined;
38796 Object.defineProperty(Buffer.prototype, 'offset', {
38799 if (!Buffer.isBuffer(this)) return undefined;
38811 buf.__proto__ = Buffer.prototype;
38825 function Buffer(arg, encodingOrOffset, length) {
38839 if (typeof Symbol !== 'undefined' && Symbol.species != null && Buffer[Symbol.species] === Buffer) {
38840 Object.defineProperty(Buffer, Symbol.species, {
38848 Buffer.poolSize = 8192; // not used by this implementation
38874 return Buffer.from(valueOf, encodingOrOffset, length);
38881 return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length);
38896 Buffer.from = function (value, encodingOrOffset, length) {
38902 Buffer.prototype.__proto__ = Uint8Array.prototype;
38903 Buffer.__proto__ = Uint8Array;
38935 Buffer.alloc = function (size, fill, encoding) {
38948 Buffer.allocUnsafe = function (size) {
38956 Buffer.allocUnsafeSlow = function (size) {
38965 if (!Buffer.isEncoding(encoding)) {
39014 buf.__proto__ = Buffer.prototype;
39019 if (Buffer.isBuffer(obj)) {
39060 return Buffer.alloc(+length);
39063 Buffer.isBuffer = function isBuffer(b) {
39064 …return b != null && b._isBuffer === true && b !== Buffer.prototype; // so Buffer.isBuffer(Buffer.p…
39067 Buffer.compare = function compare(a, b) {
39068 if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
39069 if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
39071 if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
39092 Buffer.isEncoding = function isEncoding(encoding) {
39112 Buffer.concat = function concat(list, length) {
39118 return Buffer.alloc(0);
39131 var buffer = Buffer.allocUnsafe(length);
39138 buf = Buffer.from(buf);
39141 if (!Buffer.isBuffer(buf)) {
39153 if (Buffer.isBuffer(string)) {
39205 Buffer.byteLength = byteLength;
39282 Buffer.prototype._isBuffer = true;
39290 Buffer.prototype.swap16 = function swap16() {
39304 Buffer.prototype.swap32 = function swap32() {
39319 Buffer.prototype.swap64 = function swap64() {
39336 Buffer.prototype.toString = function toString() {
39343 Buffer.prototype.toLocaleString = Buffer.prototype.toString;
39345 Buffer.prototype.equals = function equals(b) {
39346 if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
39348 return Buffer.compare(this, b) === 0;
39351 Buffer.prototype.inspect = function inspect() {
39359 Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
39361 target = Buffer.from(target, target.offset, target.byteLength);
39364 if (!Buffer.isBuffer(target)) {
39464 val = Buffer.from(val, encoding);
39468 if (Buffer.isBuffer(val)) {
39554 Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
39558 Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
39562 Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
39615 Buffer.prototype.write = function write(string, offset, length, encoding) {
39683 Buffer.prototype.toJSON = function toJSON() {
39850 Buffer.prototype.slice = function slice(start, end) {
39872 newBuf.__proto__ = Buffer.prototype;
39885 Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
39900 Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
39918 Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
39924 Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
39930 Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
39936 Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
39942 Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
39948 Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
39965 Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
39982 Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
39989 Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
39996 Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
40003 Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
40009 Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
40015 Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
40021 Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
40027 Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
40033 Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
40040 if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
40045 Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
40066 Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
40087 Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
40095 Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
40104 Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
40113 Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
40124 Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
40135 Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
40160 Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
40185 Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
40194 Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
40203 Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
40212 Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
40223 Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
40252 Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
40256 Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
40272 Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
40276 Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
40281 Buffer.prototype.copy = function copy(target, targetStart, start, end) {
40282 if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer');
40326 Buffer.prototype.fill = function fill(val, start, end, encoding) {
40342 if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
40377 var bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
40533 }).call(this,require("buffer").Buffer)
40536 (function (Buffer){
40541 var buffer = new Buffer(length);
40550 }).call(this,require("buffer").Buffer)
40555 var Buffer = require('safe-buffer').Buffer;
40586 data = Buffer.from(data, inputEnc);
40643 var outData = this.__final() || Buffer.alloc(0);
43461 (function (Buffer){
43576 exports.isBuffer = Buffer.isBuffer;
43585 (function (Buffer){
43654 if (!Buffer.isBuffer(other)) {
43655 other = new Buffer(other, inenc);
43684 if (!Buffer.isBuffer(pub)) {
43685 pub = new Buffer(pub, enc);
43696 if (!Buffer.isBuffer(priv)) {
43697 priv = new Buffer(priv, enc);
43715 var buf = new Buffer(bn);
43718 var zeros = new Buffer(len - buf.length);
43720 buf = Buffer.concat([zeros, buf]);
43730 }).call(this,require("buffer").Buffer)
43787 var Buffer = require('safe-buffer').Buffer;
43795 var ZEROS = Buffer.alloc(128);
43801 key = Buffer.from(key);
43812 key = Buffer.concat([key, ZEROS], blocksize);
43815 var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
43816 var opad = this._opad = Buffer.allocUnsafe(blocksize);
43860 var Buffer = require('safe-buffer').Buffer;
43864 var ZEROS = Buffer.alloc(128);
43871 key = Buffer.from(key);
43880 key = Buffer.concat([key, ZEROS], blocksize);
43883 var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
43884 var opad = this._opad = Buffer.allocUnsafe(blocksize);
43901 var h = this._alg(Buffer.concat(this._hash));
43903 return this._alg(Buffer.concat([this._opad, h]));
45223 (function (Buffer){
45233 var prime = new Buffer(primes[mod].prime, 'hex');
45234 var gen = new Buffer(primes[mod].gen, 'hex');
45245 if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {
45251 generator = generator || new Buffer([2]);
45253 if (!Buffer.isBuffer(generator)) {
45254 generator = new Buffer(generator, genc);
45261 if (!Buffer.isBuffer(prime)) {
45262 prime = new Buffer(prime, enc);
45271 }).call(this,require("buffer").Buffer)
45274 (function (Buffer){
45297 if (!Buffer.isBuffer(pub)) {
45298 pub = new Buffer(pub, enc);
45308 if (!Buffer.isBuffer(priv)) {
45309 priv = new Buffer(priv, enc);
45421 var out = new Buffer(secret.toArray());
45425 var front = new Buffer(prime.length - out.length);
45427 out = Buffer.concat([front, out]);
45452 if (!Buffer.isBuffer(gen)) {
45453 gen = new Buffer(gen, enc);
45462 var buf = new Buffer(bn.toArray());
45471 }).call(this,require("buffer").Buffer)
49077 var Buffer = require('safe-buffer').Buffer;
49084 if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary');
49087 if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary');
49092 var key = Buffer.alloc(keyLen);
49093 var iv = Buffer.alloc(ivLen || 0);
49094 var tmp = Buffer.alloc(0);
49228 var Buffer = require('safe-buffer').Buffer;
49235 if (!Buffer.isBuffer(val) && typeof val !== 'string') {
49242 this._block = Buffer.allocUnsafe(blockSize);
49278 if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding); // consume data
52006 (function (Buffer){
52015 isNode: typeof Buffer !== "undefined",
52024 if (Buffer.from && Buffer.from !== Uint8Array.from) {
52025 return Buffer.from(data, encoding);
52033 return new Buffer(data, encoding);
52043 if (Buffer.alloc) {
52044 return Buffer.alloc(size);
52046 var buf = new Buffer(size);
52058 return Buffer.isBuffer(b);
52065 }).call(this,require("buffer").Buffer)
53368 (function (Buffer){
53450 return Buffer.concat(dataArray);
53611 }).call(this,require("buffer").Buffer)
53614 (function (Buffer){
53621 exports.nodebuffer = typeof Buffer !== "undefined"; // contains true if JSZip can read/generate Uin…
53652 }).call(this,require("buffer").Buffer)
58613 var Buffer = moduleExports ? root.Buffer : undefined,
58622 nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
61425 var Buffer = require('safe-buffer').Buffer;
61542 var buffer = Buffer.allocUnsafe(16);
70058 var Buffer = require('safe-buffer').Buffer;
70067 decrypted = Buffer.from(match2[2].replace(/[\r\n]/g, ''), 'base64');
70070 var iv = Buffer.from(match[2], 'hex');
70071 var cipherText = Buffer.from(match[3].replace(/[\r\n]/g, ''), 'base64');
70077 decrypted = Buffer.concat(out);
70102 var Buffer = require('safe-buffer').Buffer;
70109 if (_typeof(buffer) === 'object' && !Buffer.isBuffer(buffer)) {
70115 buffer = Buffer.from(buffer);
70229 return Buffer.concat(out);
70242 var Buffer = require('safe-buffer').Buffer;
70280 ZERO_BUF = ZERO_BUF || Buffer.alloc(8);
70303 return Buffer.from(res);
70407 var Buffer = require('safe-buffer').Buffer;
70415 var ZEROS = Buffer.alloc(128);
70434 key = Buffer.concat([key, ZEROS], blocksize);
70437 var ipad = Buffer.allocUnsafe(blocksize + sizes[alg]);
70438 var opad = Buffer.allocUnsafe(blocksize + sizes[alg]);
70445 var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4);
70483 var DK = Buffer.allocUnsafe(keylen);
70484 var block1 = Buffer.allocUnsafe(salt.length + 4);
70515 var Buffer = require('safe-buffer').Buffer;
70518 if (Buffer.isBuffer(thing)) {
70521 return Buffer.from(thing, encoding);
70523 return Buffer.from(thing.buffer);
70816 var Buffer = require('safe-buffer').Buffer;
70819 var t = Buffer.alloc(0);
70825 t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]);
70832 var out = Buffer.allocUnsafe(4);
70856 var Buffer = require('safe-buffer').Buffer;
70884 var zBuffer = Buffer.alloc(k - msg.length);
70885 msg = Buffer.concat([zBuffer, msg], k);
70900 var iHash = createHash('sha1').update(Buffer.alloc(0)).digest();
70959 a = Buffer.from(a);
70960 b = Buffer.from(b);
70997 var Buffer = require('safe-buffer').Buffer;
71037 var iHash = createHash('sha1').update(Buffer.alloc(0)).digest();
71045 var ps = Buffer.alloc(k - mLen - hLen2 - 2);
71048 var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen));
71050 return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k));
71064 ps = Buffer.alloc(k - mLen - 3, 0xff);
71069 return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k));
71073 var out = Buffer.allocUnsafe(len);
71100 var Buffer = require('safe-buffer').Buffer;
71103 …return Buffer.from(paddedMsg.toRed(BN.mont(key.modulus)).redPow(new BN(key.publicExponent)).fromRe…
71136 var Buffer = require('safe-buffer').Buffer;
71149 var bytes = Buffer.allocUnsafe(size);
71189 var Buffer = safeBuffer.Buffer;
71233 if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
71291 if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
71668 var Buffer = require('buffer').Buffer;
71673 return Buffer.from(chunk);
71677 return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
71853 chunk = Buffer.from(chunk, encoding);
71885 …if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prot…
73024 var Buffer = require('buffer').Buffer;
73029 return Buffer.from(chunk);
73033 return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
73248 if (isBuf && !Buffer.isBuffer(chunk)) {
73299 chunk = Buffer.from(chunk, encoding);
73955 Buffer = _require.Buffer;
73963 Buffer.prototype.copy.call(src, target, offset);
74028 if (this.length === 0) return Buffer.alloc(0);
74029 var ret = Buffer.allocUnsafe(n >>> 0);
74103 var ret = Buffer.allocUnsafe(n);
75249 var Buffer = require('buffer').Buffer;
75357 var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20);
75398 var Buffer = buffer.Buffer; // alternative to using Object.keys for old browsers
75406 if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
75411 exports.Buffer = SafeBuffer;
75415 return Buffer(arg, encodingOrOffset, length);
75419 copyProps(Buffer, SafeBuffer);
75426 return Buffer(arg, encodingOrOffset, length);
75434 var buf = Buffer(size);
75454 return Buffer(size);
75474 var Buffer = buffer.Buffer;
75484 var Safer = safer.Buffer = {};
75486 for (key in Buffer) {
75487 if (!Buffer.hasOwnProperty(key)) continue;
75489 Safer[key] = Buffer[key];
75492 safer.Buffer.prototype = Buffer.prototype;
75504 return Buffer(value, encodingOrOffset, length);
75518 var buf = Buffer(size);
78138 var Buffer = require('safe-buffer').Buffer; // prototype class for hash functions
78142 this._block = Buffer.alloc(blockSize);
78151 data = Buffer.from(data, enc);
78250 var Buffer = require('safe-buffer').Buffer;
78320 var H = Buffer.allocUnsafe(20);
78346 var Buffer = require('safe-buffer').Buffer;
78420 var H = Buffer.allocUnsafe(20);
78447 var Buffer = require('safe-buffer').Buffer;
78473 var H = Buffer.allocUnsafe(28);
78500 var Buffer = require('safe-buffer').Buffer;
78593 var H = Buffer.allocUnsafe(32);
78616 var Buffer = require('safe-buffer').Buffer;
78649 var H = Buffer.allocUnsafe(48);
78674 var Buffer = require('safe-buffer').Buffer;
78853 var H = Buffer.allocUnsafe(64);
79231 var Buffer = require('safe-buffer').Buffer;
79236 return Buffer.from(chunk);
79240 return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
79403 chunk = Buffer.from(chunk, encoding);
79434 …if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prot…
80153 var ret = Buffer.allocUnsafe(n);
80510 var Buffer = require('safe-buffer').Buffer;
80515 return Buffer.from(chunk);
80519 return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
80723 if (isBuf && !Buffer.isBuffer(chunk)) {
80765 chunk = Buffer.from(chunk, encoding);
81110 var Buffer = require('safe-buffer').Buffer;
81173 if (this.length === 0) return Buffer.alloc(0);
81175 var ret = Buffer.allocUnsafe(n >>> 0);
81329 var Buffer = require('safe-buffer').Buffer;
81333 var isEncoding = Buffer.isEncoding || function (encoding) {
81395 …if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new …
81434 this.lastChar = Buffer.allocUnsafe(nb);