1 | 'use strict'
|
---|
2 |
|
---|
3 | const { Buffer } = require('buffer')
|
---|
4 | const symbol = Symbol.for('BufferList')
|
---|
5 |
|
---|
6 | function BufferList (buf) {
|
---|
7 | if (!(this instanceof BufferList)) {
|
---|
8 | return new BufferList(buf)
|
---|
9 | }
|
---|
10 |
|
---|
11 | BufferList._init.call(this, buf)
|
---|
12 | }
|
---|
13 |
|
---|
14 | BufferList._init = function _init (buf) {
|
---|
15 | Object.defineProperty(this, symbol, { value: true })
|
---|
16 |
|
---|
17 | this._bufs = []
|
---|
18 | this.length = 0
|
---|
19 |
|
---|
20 | if (buf) {
|
---|
21 | this.append(buf)
|
---|
22 | }
|
---|
23 | }
|
---|
24 |
|
---|
25 | BufferList.prototype._new = function _new (buf) {
|
---|
26 | return new BufferList(buf)
|
---|
27 | }
|
---|
28 |
|
---|
29 | BufferList.prototype._offset = function _offset (offset) {
|
---|
30 | if (offset === 0) {
|
---|
31 | return [0, 0]
|
---|
32 | }
|
---|
33 |
|
---|
34 | let tot = 0
|
---|
35 |
|
---|
36 | for (let i = 0; i < this._bufs.length; i++) {
|
---|
37 | const _t = tot + this._bufs[i].length
|
---|
38 | if (offset < _t || i === this._bufs.length - 1) {
|
---|
39 | return [i, offset - tot]
|
---|
40 | }
|
---|
41 | tot = _t
|
---|
42 | }
|
---|
43 | }
|
---|
44 |
|
---|
45 | BufferList.prototype._reverseOffset = function (blOffset) {
|
---|
46 | const bufferId = blOffset[0]
|
---|
47 | let offset = blOffset[1]
|
---|
48 |
|
---|
49 | for (let i = 0; i < bufferId; i++) {
|
---|
50 | offset += this._bufs[i].length
|
---|
51 | }
|
---|
52 |
|
---|
53 | return offset
|
---|
54 | }
|
---|
55 |
|
---|
56 | BufferList.prototype.get = function get (index) {
|
---|
57 | if (index > this.length || index < 0) {
|
---|
58 | return undefined
|
---|
59 | }
|
---|
60 |
|
---|
61 | const offset = this._offset(index)
|
---|
62 |
|
---|
63 | return this._bufs[offset[0]][offset[1]]
|
---|
64 | }
|
---|
65 |
|
---|
66 | BufferList.prototype.slice = function slice (start, end) {
|
---|
67 | if (typeof start === 'number' && start < 0) {
|
---|
68 | start += this.length
|
---|
69 | }
|
---|
70 |
|
---|
71 | if (typeof end === 'number' && end < 0) {
|
---|
72 | end += this.length
|
---|
73 | }
|
---|
74 |
|
---|
75 | return this.copy(null, 0, start, end)
|
---|
76 | }
|
---|
77 |
|
---|
78 | BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
|
---|
79 | if (typeof srcStart !== 'number' || srcStart < 0) {
|
---|
80 | srcStart = 0
|
---|
81 | }
|
---|
82 |
|
---|
83 | if (typeof srcEnd !== 'number' || srcEnd > this.length) {
|
---|
84 | srcEnd = this.length
|
---|
85 | }
|
---|
86 |
|
---|
87 | if (srcStart >= this.length) {
|
---|
88 | return dst || Buffer.alloc(0)
|
---|
89 | }
|
---|
90 |
|
---|
91 | if (srcEnd <= 0) {
|
---|
92 | return dst || Buffer.alloc(0)
|
---|
93 | }
|
---|
94 |
|
---|
95 | const copy = !!dst
|
---|
96 | const off = this._offset(srcStart)
|
---|
97 | const len = srcEnd - srcStart
|
---|
98 | let bytes = len
|
---|
99 | let bufoff = (copy && dstStart) || 0
|
---|
100 | let start = off[1]
|
---|
101 |
|
---|
102 | // copy/slice everything
|
---|
103 | if (srcStart === 0 && srcEnd === this.length) {
|
---|
104 | if (!copy) {
|
---|
105 | // slice, but full concat if multiple buffers
|
---|
106 | return this._bufs.length === 1
|
---|
107 | ? this._bufs[0]
|
---|
108 | : Buffer.concat(this._bufs, this.length)
|
---|
109 | }
|
---|
110 |
|
---|
111 | // copy, need to copy individual buffers
|
---|
112 | for (let i = 0; i < this._bufs.length; i++) {
|
---|
113 | this._bufs[i].copy(dst, bufoff)
|
---|
114 | bufoff += this._bufs[i].length
|
---|
115 | }
|
---|
116 |
|
---|
117 | return dst
|
---|
118 | }
|
---|
119 |
|
---|
120 | // easy, cheap case where it's a subset of one of the buffers
|
---|
121 | if (bytes <= this._bufs[off[0]].length - start) {
|
---|
122 | return copy
|
---|
123 | ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
|
---|
124 | : this._bufs[off[0]].slice(start, start + bytes)
|
---|
125 | }
|
---|
126 |
|
---|
127 | if (!copy) {
|
---|
128 | // a slice, we need something to copy in to
|
---|
129 | dst = Buffer.allocUnsafe(len)
|
---|
130 | }
|
---|
131 |
|
---|
132 | for (let i = off[0]; i < this._bufs.length; i++) {
|
---|
133 | const l = this._bufs[i].length - start
|
---|
134 |
|
---|
135 | if (bytes > l) {
|
---|
136 | this._bufs[i].copy(dst, bufoff, start)
|
---|
137 | bufoff += l
|
---|
138 | } else {
|
---|
139 | this._bufs[i].copy(dst, bufoff, start, start + bytes)
|
---|
140 | bufoff += l
|
---|
141 | break
|
---|
142 | }
|
---|
143 |
|
---|
144 | bytes -= l
|
---|
145 |
|
---|
146 | if (start) {
|
---|
147 | start = 0
|
---|
148 | }
|
---|
149 | }
|
---|
150 |
|
---|
151 | // safeguard so that we don't return uninitialized memory
|
---|
152 | if (dst.length > bufoff) return dst.slice(0, bufoff)
|
---|
153 |
|
---|
154 | return dst
|
---|
155 | }
|
---|
156 |
|
---|
157 | BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
|
---|
158 | start = start || 0
|
---|
159 | end = typeof end !== 'number' ? this.length : end
|
---|
160 |
|
---|
161 | if (start < 0) {
|
---|
162 | start += this.length
|
---|
163 | }
|
---|
164 |
|
---|
165 | if (end < 0) {
|
---|
166 | end += this.length
|
---|
167 | }
|
---|
168 |
|
---|
169 | if (start === end) {
|
---|
170 | return this._new()
|
---|
171 | }
|
---|
172 |
|
---|
173 | const startOffset = this._offset(start)
|
---|
174 | const endOffset = this._offset(end)
|
---|
175 | const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
|
---|
176 |
|
---|
177 | if (endOffset[1] === 0) {
|
---|
178 | buffers.pop()
|
---|
179 | } else {
|
---|
180 | buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])
|
---|
181 | }
|
---|
182 |
|
---|
183 | if (startOffset[1] !== 0) {
|
---|
184 | buffers[0] = buffers[0].slice(startOffset[1])
|
---|
185 | }
|
---|
186 |
|
---|
187 | return this._new(buffers)
|
---|
188 | }
|
---|
189 |
|
---|
190 | BufferList.prototype.toString = function toString (encoding, start, end) {
|
---|
191 | return this.slice(start, end).toString(encoding)
|
---|
192 | }
|
---|
193 |
|
---|
194 | BufferList.prototype.consume = function consume (bytes) {
|
---|
195 | // first, normalize the argument, in accordance with how Buffer does it
|
---|
196 | bytes = Math.trunc(bytes)
|
---|
197 | // do nothing if not a positive number
|
---|
198 | if (Number.isNaN(bytes) || bytes <= 0) return this
|
---|
199 |
|
---|
200 | while (this._bufs.length) {
|
---|
201 | if (bytes >= this._bufs[0].length) {
|
---|
202 | bytes -= this._bufs[0].length
|
---|
203 | this.length -= this._bufs[0].length
|
---|
204 | this._bufs.shift()
|
---|
205 | } else {
|
---|
206 | this._bufs[0] = this._bufs[0].slice(bytes)
|
---|
207 | this.length -= bytes
|
---|
208 | break
|
---|
209 | }
|
---|
210 | }
|
---|
211 |
|
---|
212 | return this
|
---|
213 | }
|
---|
214 |
|
---|
215 | BufferList.prototype.duplicate = function duplicate () {
|
---|
216 | const copy = this._new()
|
---|
217 |
|
---|
218 | for (let i = 0; i < this._bufs.length; i++) {
|
---|
219 | copy.append(this._bufs[i])
|
---|
220 | }
|
---|
221 |
|
---|
222 | return copy
|
---|
223 | }
|
---|
224 |
|
---|
225 | BufferList.prototype.append = function append (buf) {
|
---|
226 | if (buf == null) {
|
---|
227 | return this
|
---|
228 | }
|
---|
229 |
|
---|
230 | if (buf.buffer) {
|
---|
231 | // append a view of the underlying ArrayBuffer
|
---|
232 | this._appendBuffer(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength))
|
---|
233 | } else if (Array.isArray(buf)) {
|
---|
234 | for (let i = 0; i < buf.length; i++) {
|
---|
235 | this.append(buf[i])
|
---|
236 | }
|
---|
237 | } else if (this._isBufferList(buf)) {
|
---|
238 | // unwrap argument into individual BufferLists
|
---|
239 | for (let i = 0; i < buf._bufs.length; i++) {
|
---|
240 | this.append(buf._bufs[i])
|
---|
241 | }
|
---|
242 | } else {
|
---|
243 | // coerce number arguments to strings, since Buffer(number) does
|
---|
244 | // uninitialized memory allocation
|
---|
245 | if (typeof buf === 'number') {
|
---|
246 | buf = buf.toString()
|
---|
247 | }
|
---|
248 |
|
---|
249 | this._appendBuffer(Buffer.from(buf))
|
---|
250 | }
|
---|
251 |
|
---|
252 | return this
|
---|
253 | }
|
---|
254 |
|
---|
255 | BufferList.prototype._appendBuffer = function appendBuffer (buf) {
|
---|
256 | this._bufs.push(buf)
|
---|
257 | this.length += buf.length
|
---|
258 | }
|
---|
259 |
|
---|
260 | BufferList.prototype.indexOf = function (search, offset, encoding) {
|
---|
261 | if (encoding === undefined && typeof offset === 'string') {
|
---|
262 | encoding = offset
|
---|
263 | offset = undefined
|
---|
264 | }
|
---|
265 |
|
---|
266 | if (typeof search === 'function' || Array.isArray(search)) {
|
---|
267 | throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
|
---|
268 | } else if (typeof search === 'number') {
|
---|
269 | search = Buffer.from([search])
|
---|
270 | } else if (typeof search === 'string') {
|
---|
271 | search = Buffer.from(search, encoding)
|
---|
272 | } else if (this._isBufferList(search)) {
|
---|
273 | search = search.slice()
|
---|
274 | } else if (Array.isArray(search.buffer)) {
|
---|
275 | search = Buffer.from(search.buffer, search.byteOffset, search.byteLength)
|
---|
276 | } else if (!Buffer.isBuffer(search)) {
|
---|
277 | search = Buffer.from(search)
|
---|
278 | }
|
---|
279 |
|
---|
280 | offset = Number(offset || 0)
|
---|
281 |
|
---|
282 | if (isNaN(offset)) {
|
---|
283 | offset = 0
|
---|
284 | }
|
---|
285 |
|
---|
286 | if (offset < 0) {
|
---|
287 | offset = this.length + offset
|
---|
288 | }
|
---|
289 |
|
---|
290 | if (offset < 0) {
|
---|
291 | offset = 0
|
---|
292 | }
|
---|
293 |
|
---|
294 | if (search.length === 0) {
|
---|
295 | return offset > this.length ? this.length : offset
|
---|
296 | }
|
---|
297 |
|
---|
298 | const blOffset = this._offset(offset)
|
---|
299 | let blIndex = blOffset[0] // index of which internal buffer we're working on
|
---|
300 | let buffOffset = blOffset[1] // offset of the internal buffer we're working on
|
---|
301 |
|
---|
302 | // scan over each buffer
|
---|
303 | for (; blIndex < this._bufs.length; blIndex++) {
|
---|
304 | const buff = this._bufs[blIndex]
|
---|
305 |
|
---|
306 | while (buffOffset < buff.length) {
|
---|
307 | const availableWindow = buff.length - buffOffset
|
---|
308 |
|
---|
309 | if (availableWindow >= search.length) {
|
---|
310 | const nativeSearchResult = buff.indexOf(search, buffOffset)
|
---|
311 |
|
---|
312 | if (nativeSearchResult !== -1) {
|
---|
313 | return this._reverseOffset([blIndex, nativeSearchResult])
|
---|
314 | }
|
---|
315 |
|
---|
316 | buffOffset = buff.length - search.length + 1 // end of native search window
|
---|
317 | } else {
|
---|
318 | const revOffset = this._reverseOffset([blIndex, buffOffset])
|
---|
319 |
|
---|
320 | if (this._match(revOffset, search)) {
|
---|
321 | return revOffset
|
---|
322 | }
|
---|
323 |
|
---|
324 | buffOffset++
|
---|
325 | }
|
---|
326 | }
|
---|
327 |
|
---|
328 | buffOffset = 0
|
---|
329 | }
|
---|
330 |
|
---|
331 | return -1
|
---|
332 | }
|
---|
333 |
|
---|
334 | BufferList.prototype._match = function (offset, search) {
|
---|
335 | if (this.length - offset < search.length) {
|
---|
336 | return false
|
---|
337 | }
|
---|
338 |
|
---|
339 | for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
|
---|
340 | if (this.get(offset + searchOffset) !== search[searchOffset]) {
|
---|
341 | return false
|
---|
342 | }
|
---|
343 | }
|
---|
344 | return true
|
---|
345 | }
|
---|
346 |
|
---|
347 | ;(function () {
|
---|
348 | const methods = {
|
---|
349 | readDoubleBE: 8,
|
---|
350 | readDoubleLE: 8,
|
---|
351 | readFloatBE: 4,
|
---|
352 | readFloatLE: 4,
|
---|
353 | readInt32BE: 4,
|
---|
354 | readInt32LE: 4,
|
---|
355 | readUInt32BE: 4,
|
---|
356 | readUInt32LE: 4,
|
---|
357 | readInt16BE: 2,
|
---|
358 | readInt16LE: 2,
|
---|
359 | readUInt16BE: 2,
|
---|
360 | readUInt16LE: 2,
|
---|
361 | readInt8: 1,
|
---|
362 | readUInt8: 1,
|
---|
363 | readIntBE: null,
|
---|
364 | readIntLE: null,
|
---|
365 | readUIntBE: null,
|
---|
366 | readUIntLE: null
|
---|
367 | }
|
---|
368 |
|
---|
369 | for (const m in methods) {
|
---|
370 | (function (m) {
|
---|
371 | if (methods[m] === null) {
|
---|
372 | BufferList.prototype[m] = function (offset, byteLength) {
|
---|
373 | return this.slice(offset, offset + byteLength)[m](0, byteLength)
|
---|
374 | }
|
---|
375 | } else {
|
---|
376 | BufferList.prototype[m] = function (offset = 0) {
|
---|
377 | return this.slice(offset, offset + methods[m])[m](0)
|
---|
378 | }
|
---|
379 | }
|
---|
380 | }(m))
|
---|
381 | }
|
---|
382 | }())
|
---|
383 |
|
---|
384 | // Used internally by the class and also as an indicator of this object being
|
---|
385 | // a `BufferList`. It's not possible to use `instanceof BufferList` in a browser
|
---|
386 | // environment because there could be multiple different copies of the
|
---|
387 | // BufferList class and some `BufferList`s might be `BufferList`s.
|
---|
388 | BufferList.prototype._isBufferList = function _isBufferList (b) {
|
---|
389 | return b instanceof BufferList || BufferList.isBufferList(b)
|
---|
390 | }
|
---|
391 |
|
---|
392 | BufferList.isBufferList = function isBufferList (b) {
|
---|
393 | return b != null && b[symbol]
|
---|
394 | }
|
---|
395 |
|
---|
396 | module.exports = BufferList
|
---|