www.npmjs.com Open in urlscan Pro
2606:4700::6811:dfaf  Public Scan

Form analysis
1 forms found in the DOM

GET /search

<form id="search" method="GET" action="/search" class="_13c93d41 relative flex bg-transparent ph3 ph2 pv2 ph0-ns pv0-ns bt b--black-10 bn-ns">
  <div class="e82b10fd relative dde91b96">
    <div class="_2f299eeb nowrap flex"><span class="_705cdf4f db fl pl3 pr1"><svg width="15px" height="15px" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18" aria-hidden="true">
          <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
            <g stroke="#777777" stroke-width="1.3">
              <g>
                <path d="M13.4044,7.0274 C13.4044,10.5494 10.5494,13.4044 7.0274,13.4044 C3.5054,13.4044 0.6504,10.5494 0.6504,7.0274 C0.6504,3.5054 3.5054,0.6504 7.0274,0.6504 C10.5494,0.6504 13.4044,3.5054 13.4044,7.0274 Z"></path>
                <path d="M11.4913,11.4913 L17.8683,17.8683"></path>
              </g>
            </g>
          </g>
        </svg></span><input type="search" role="combobox" name="q" hotkeys="[object Object]" placeholder="Search packages" aria-label="Search packages" aria-controls="typeahead-list-128129" aria-expanded="false" aria-activedescendant=""
        inputref="[object Object]" autocomplete="off" class="_390acbc5 f5 fw3 black relative" value="" element="input"></div>
  </div><button type="submit" class="_0da775bb bn pv2 ph4 f6 white pointer bn pv2 ph4 f6 white pointer" aria-label="Search">Search</button><input type="hidden" name="csrftoken" value="mHS01rp-wf_WgUzVEkLQktyTI3hMWfmFi_WT3zeFbhj">
</form>

Text Content

skip to:contentpackage searchsign in
❤
 * Pro
 * Teams
 * Pricing
 * Documentation

npm


Search
Sign UpSign In


BL


6.0.16 • Public • Published 17 days ago
 * Readme
 * Code Beta
 * 4 Dependencies
 * 1,608 Dependents
 * 64 Versions


BL (BUFFERLIST)



A Node.js Buffer list collector, reader and streamer thingy.



bl is a storage object for collections of Node Buffers, exposing them with the
main Buffer readable API. Also works as a duplex stream so you can collect
buffers from a stream that emits them and emit buffers to a stream that consumes
them!

The original buffers are kept intact and copies are only done as necessary. Any
reads that require the use of a single original buffer will return a slice of
that buffer only (which references the same memory as the original buffer).
Reads that span buffers perform concatenation as required and return the results
transparently.

const { BufferList } = require('bl')

const bl = new BufferList()
bl.append(Buffer.from('abcd'))
bl.append(Buffer.from('efg'))
bl.append('hi')                     // bl will also accept & convert Strings
bl.append(Buffer.from('j'))
bl.append(Buffer.from([ 0x3, 0x4 ]))

console.log(bl.length) // 12

console.log(bl.slice(0, 10).toString('ascii')) // 'abcdefghij'
console.log(bl.slice(3, 10).toString('ascii')) // 'defghij'
console.log(bl.slice(3, 6).toString('ascii'))  // 'def'
console.log(bl.slice(3, 8).toString('ascii'))  // 'defgh'
console.log(bl.slice(5, 10).toString('ascii')) // 'fghij'

console.log(bl.indexOf('def')) // 3
console.log(bl.indexOf('asdf')) // -1

// or just use toString!
console.log(bl.toString())               // 'abcdefghij\u0003\u0004'
console.log(bl.toString('ascii', 3, 8))  // 'defgh'
console.log(bl.toString('ascii', 5, 10)) // 'fghij'

// other standard Buffer readables
console.log(bl.readUInt16BE(10)) // 0x0304
console.log(bl.readUInt16LE(10)) // 0x0403

Give it a callback in the constructor and use it just like concat-stream:

const { BufferListStream } = require('bl')
const fs = require('fs')

fs.createReadStream('README.md')
  .pipe(BufferListStream((err, data) => { // note 'new' isn't strictly required
    // `data` is a complete Buffer object containing the full data
    console.log(data.toString())
  }))

Note that when you use the callback method like this, the resulting data
parameter is a concatenation of all Buffer objects in the list. If you want to
avoid the overhead of this concatenation (in cases of extreme performance
consciousness), then avoid the callback method and just listen to 'end' instead,
like a standard Stream.

Or to fetch a URL using hyperquest (should work with request and even plain Node
http too!):

const hyperquest = require('hyperquest')
const { BufferListStream } = require('bl')

const url = 'https://raw.github.com/rvagg/bl/master/README.md'

hyperquest(url).pipe(BufferListStream((err, data) => {
  console.log(data.toString())
}))

Or, use it as a readable stream to recompose a list of Buffers to an output
source:

const { BufferListStream } = require('bl')
const fs = require('fs')

var bl = new BufferListStream()
bl.append(Buffer.from('abcd'))
bl.append(Buffer.from('efg'))
bl.append(Buffer.from('hi'))
bl.append(Buffer.from('j'))

bl.pipe(fs.createWriteStream('gibberish.txt'))


API

 * new BufferList([ buf ])
 * BufferList.isBufferList(obj)
 * bl.length
 * bl.append(buffer)
 * bl.get(index)
 * bl.indexOf(value[, byteOffset][, encoding])
 * bl.slice([ start[, end ] ])
 * bl.shallowSlice([ start[, end ] ])
 * bl.copy(dest, [ destStart, [ srcStart [, srcEnd ] ] ])
 * bl.duplicate()
 * bl.consume(bytes)
 * bl.toString([encoding, [ start, [ end ]]])
 * bl.readDoubleBE(), bl.readDoubleLE(), bl.readFloatBE(), bl.readFloatLE(),
   bl.readBigInt64BE(), bl.readBigInt64LE(), bl.readBigUInt64BE(),
   bl.readBigUInt64LE(), bl.readInt32BE(), bl.readInt32LE(), bl.readUInt32BE(),
   bl.readUInt32LE(), bl.readInt16BE(), bl.readInt16LE(), bl.readUInt16BE(),
   bl.readUInt16LE(), bl.readInt8(), bl.readUInt8()
 * new BufferListStream([ callback ])

--------------------------------------------------------------------------------




NEW BUFFERLIST([ BUFFER | BUFFER ARRAY | BUFFERLIST | BUFFERLIST ARRAY | STRING
])

No arguments are required for the constructor, but you can initialise the list
by passing in a single Buffer object or an array of Buffer objects.

new is not strictly required, if you don't instantiate a new object, it will be
done automatically for you so you can create a new instance simply with:

const { BufferList } = require('bl')
const bl = BufferList()

// equivalent to:

const { BufferList } = require('bl')
const bl = new BufferList()

--------------------------------------------------------------------------------




BUFFERLIST.ISBUFFERLIST(OBJ)

Determines if the passed object is a BufferList. It will return true if the
passed object is an instance of BufferList or BufferListStream and false
otherwise.

N.B. this won't return true for BufferList or BufferListStream instances created
by versions of this library before this static method was added.

--------------------------------------------------------------------------------




BL.LENGTH

Get the length of the list in bytes. This is the sum of the lengths of all of
the buffers contained in the list, minus any initial offset for a semi-consumed
buffer at the beginning. Should accurately represent the total number of bytes
that can be read from the list.

--------------------------------------------------------------------------------




BL.APPEND(BUFFER | BUFFER ARRAY | BUFFERLIST | BUFFERLIST ARRAY | STRING)

append(buffer) adds an additional buffer or BufferList to the internal list.
this is returned so it can be chained.

--------------------------------------------------------------------------------




BL.GET(INDEX)

get() will return the byte at the specified index.

--------------------------------------------------------------------------------




BL.INDEXOF(VALUE[, BYTEOFFSET][, ENCODING])

get() will return the byte at the specified index. indexOf() method returns the
first index at which a given element can be found in the BufferList, or -1 if it
is not present.

--------------------------------------------------------------------------------




BL.SLICE([ START, [ END ] ])

slice() returns a new Buffer object containing the bytes within the range
specified. Both start and end are optional and will default to the beginning and
end of the list respectively.

If the requested range spans a single internal buffer then a slice of that
buffer will be returned which shares the original memory range of that Buffer.
If the range spans multiple buffers then copy operations will likely occur to
give you a uniform Buffer.

--------------------------------------------------------------------------------




BL.SHALLOWSLICE([ START, [ END ] ])

shallowSlice() returns a new BufferList object containing the bytes within the
range specified. Both start and end are optional and will default to the
beginning and end of the list respectively.

No copies will be performed. All buffers in the result share memory with the
original list.

--------------------------------------------------------------------------------




BL.COPY(DEST, [ DESTSTART, [ SRCSTART [, SRCEND ] ] ])

copy() copies the content of the list in the dest buffer, starting from
destStart and containing the bytes within the range specified with srcStart to
srcEnd. destStart, start and end are optional and will default to the beginning
of the dest buffer, and the beginning and end of the list respectively.

--------------------------------------------------------------------------------




BL.DUPLICATE()

duplicate() performs a shallow-copy of the list. The internal Buffers remains
the same, so if you change the underlying Buffers, the change will be reflected
in both the original and the duplicate. This method is needed if you want to
call consume() or pipe() and still keep the original list.Example:

var bl = new BufferListStream()

bl.append('hello')
bl.append(' world')
bl.append('\n')

bl.duplicate().pipe(process.stdout, { end: false })

console.log(bl.toString())

--------------------------------------------------------------------------------




BL.CONSUME(BYTES)

consume() will shift bytes off the start of the list. The number of bytes
consumed don't need to line up with the sizes of the internal Buffers—initial
offsets will be calculated accordingly in order to give you a consistent view of
the data.

--------------------------------------------------------------------------------




BL.TOSTRING([ENCODING, [ START, [ END ]]])

toString() will return a string representation of the buffer. The optional start
and end arguments are passed on to slice(), while the encoding is passed on to
toString() of the resulting Buffer. See the Buffer#toString() documentation for
more information.

--------------------------------------------------------------------------------




BL.READDOUBLEBE(), BL.READDOUBLELE(), BL.READFLOATBE(), BL.READFLOATLE(),
BL.READBIGINT64BE(), BL.READBIGINT64LE(), BL.READBIGUINT64BE(),
BL.READBIGUINT64LE(), BL.READINT32BE(), BL.READINT32LE(), BL.READUINT32BE(),
BL.READUINT32LE(), BL.READINT16BE(), BL.READINT16LE(), BL.READUINT16BE(),
BL.READUINT16LE(), BL.READINT8(), BL.READUINT8()

All of the standard byte-reading methods of the Buffer interface are implemented
and will operate across internal Buffer boundaries transparently.

See the Buffer documentation for how these work.

--------------------------------------------------------------------------------




NEW BUFFERLISTSTREAM([ CALLBACK | BUFFER | BUFFER ARRAY | BUFFERLIST |
BUFFERLIST ARRAY | STRING ])

BufferListStream is a Node Duplex Stream, so it can be read from and written to
like a standard Node stream. You can also pipe() to and from a BufferListStream
instance.

The constructor takes an optional callback, if supplied, the callback will be
called with an error argument followed by a reference to the bl instance, when
bl.end() is called (i.e. from a piped stream). This is a convenient method of
collecting the entire contents of a stream, particularly when the stream is
chunky, such as a network stream.

Normally, no arguments are required for the constructor, but you can initialise
the list by passing in a single Buffer object or an array of Buffer object.

new is not strictly required, if you don't instantiate a new object, it will be
done automatically for you so you can create a new instance simply with:

const { BufferListStream } = require('bl')
const bl = BufferListStream()

// equivalent to:

const { BufferListStream } = require('bl')
const bl = new BufferListStream()

N.B. For backwards compatibility reasons, BufferListStream is the default export
when you require('bl'):

const { BufferListStream } = require('bl')
// equivalent to:
const BufferListStream = require('bl')

--------------------------------------------------------------------------------


CONTRIBUTORS

bl is brought to you by the following hackers:

 * Rod Vagg
 * Matteo Collina
 * Jarett Cruger




LICENSE & COPYRIGHT

Copyright (c) 2013-2019 bl contributors (listed above).

bl is licensed under the MIT license. All rights not explicitly granted in the
MIT license are reserved. See the included LICENSE.md file for more details.


README


KEYWORDS

 * buffer
 * buffers
 * stream
 * awesomesauce








PACKAGE SIDEBAR


INSTALL

npm i bl


REPOSITORY

Gitgithub.com/rvagg/bl


HOMEPAGE

github.com/rvagg/bl


DOWNLOADSWEEKLY DOWNLOADS

34,611,146


VERSION

6.0.16


LICENSE

MIT


UNPACKED SIZE

92.8 kB


TOTAL FILES

14


ISSUES

8


PULL REQUESTS

3


LAST PUBLISH

17 days ago


COLLABORATORS

 * 
 * 

Try on RunKit
Report malware


FOOTER


SUPPORT

 * Help
 * Advisories
 * Status
 * Contact npm


COMPANY

 * About
 * Blog
 * Press


TERMS & POLICIES

 * Policies
 * Terms of Use
 * Code of Conduct
 * Privacy