| 'use strict'; |
| |
| function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; } |
| |
| function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } |
| |
| var _require = require('buffer'), |
| Buffer = _require.Buffer; |
| |
| var _require2 = require('util'), |
| inspect = _require2.inspect; |
| |
| var custom = inspect && inspect.custom || 'inspect'; |
| |
| function copyBuffer(src, target, offset) { |
| Buffer.prototype.copy.call(src, target, offset); |
| } |
| |
| module.exports = |
| /*#__PURE__*/ |
| function () { |
| function BufferList() { |
| this.head = null; |
| this.tail = null; |
| this.length = 0; |
| } |
| |
| var _proto = BufferList.prototype; |
| |
| _proto.push = function push(v) { |
| var entry = { |
| data: v, |
| next: null |
| }; |
| if (this.length > 0) this.tail.next = entry;else this.head = entry; |
| this.tail = entry; |
| ++this.length; |
| }; |
| |
| _proto.unshift = function unshift(v) { |
| var entry = { |
| data: v, |
| next: this.head |
| }; |
| if (this.length === 0) this.tail = entry; |
| this.head = entry; |
| ++this.length; |
| }; |
| |
| _proto.shift = function shift() { |
| if (this.length === 0) return; |
| var ret = this.head.data; |
| if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; |
| --this.length; |
| return ret; |
| }; |
| |
| _proto.clear = function clear() { |
| this.head = this.tail = null; |
| this.length = 0; |
| }; |
| |
| _proto.join = function join(s) { |
| if (this.length === 0) return ''; |
| var p = this.head; |
| var ret = '' + p.data; |
| |
| while (p = p.next) { |
| ret += s + p.data; |
| } |
| |
| return ret; |
| }; |
| |
| _proto.concat = function concat(n) { |
| if (this.length === 0) return Buffer.alloc(0); |
| var ret = Buffer.allocUnsafe(n >>> 0); |
| var p = this.head; |
| var i = 0; |
| |
| while (p) { |
| copyBuffer(p.data, ret, i); |
| i += p.data.length; |
| p = p.next; |
| } |
| |
| return ret; |
| } // Consumes a specified amount of bytes or characters from the buffered data. |
| ; |
| |
| _proto.consume = function consume(n, hasStrings) { |
| var ret; |
| |
| if (n < this.head.data.length) { |
| // `slice` is the same for buffers and strings. |
| ret = this.head.data.slice(0, n); |
| this.head.data = this.head.data.slice(n); |
| } else if (n === this.head.data.length) { |
| // First chunk is a perfect match. |
| ret = this.shift(); |
| } else { |
| // Result spans more than one buffer. |
| ret = hasStrings ? this._getString(n) : this._getBuffer(n); |
| } |
| |
| return ret; |
| }; |
| |
| _proto.first = function first() { |
| return this.head.data; |
| } // Consumes a specified amount of characters from the buffered data. |
| ; |
| |
| _proto._getString = function _getString(n) { |
| var p = this.head; |
| var c = 1; |
| var ret = p.data; |
| n -= ret.length; |
| |
| while (p = p.next) { |
| var str = p.data; |
| var nb = n > str.length ? str.length : n; |
| if (nb === str.length) ret += str;else ret += str.slice(0, n); |
| n -= nb; |
| |
| if (n === 0) { |
| if (nb === str.length) { |
| ++c; |
| if (p.next) this.head = p.next;else this.head = this.tail = null; |
| } else { |
| this.head = p; |
| p.data = str.slice(nb); |
| } |
| |
| break; |
| } |
| |
| ++c; |
| } |
| |
| this.length -= c; |
| return ret; |
| } // Consumes a specified amount of bytes from the buffered data. |
| ; |
| |
| _proto._getBuffer = function _getBuffer(n) { |
| var ret = Buffer.allocUnsafe(n); |
| var p = this.head; |
| var c = 1; |
| p.data.copy(ret); |
| n -= p.data.length; |
| |
| while (p = p.next) { |
| var buf = p.data; |
| var nb = n > buf.length ? buf.length : n; |
| buf.copy(ret, ret.length - n, 0, nb); |
| n -= nb; |
| |
| if (n === 0) { |
| if (nb === buf.length) { |
| ++c; |
| if (p.next) this.head = p.next;else this.head = this.tail = null; |
| } else { |
| this.head = p; |
| p.data = buf.slice(nb); |
| } |
| |
| break; |
| } |
| |
| ++c; |
| } |
| |
| this.length -= c; |
| return ret; |
| } // Make sure the linked list only shows the minimal necessary information. |
| ; |
| |
| _proto[custom] = function (_, options) { |
| return inspect(this, _objectSpread({}, options, { |
| // Only inspect one level. |
| depth: 0, |
| // It should not recurse. |
| customInspect: false |
| })); |
| }; |
| |
| return BufferList; |
| }(); |