pax_global_header 0000666 0000000 0000000 00000000064 14414631765 0014525 g ustar 00root root 0000000 0000000 52 comment=3066600b811753bd9c85831a8ecd5c6ca248f2aa
isaacs-minipass-ffdbee1/ 0000775 0000000 0000000 00000000000 14414631765 0015447 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/.github/ 0000775 0000000 0000000 00000000000 14414631765 0017007 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/.github/FUNDING.yml 0000664 0000000 0000000 00000000100 14414631765 0020613 0 ustar 00root root 0000000 0000000 # These are supported funding model platforms
github: [isaacs]
isaacs-minipass-ffdbee1/.github/workflows/ 0000775 0000000 0000000 00000000000 14414631765 0021044 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/.github/workflows/ci.yml 0000664 0000000 0000000 00000001507 14414631765 0022165 0 ustar 00root root 0000000 0000000 name: CI
on: [push, pull_request]
jobs:
build:
strategy:
matrix:
node-version: [12.x, 14.x, 16.x, 17.x]
platform:
- os: ubuntu-latest
shell: bash
- os: macos-latest
shell: bash
- os: windows-latest
shell: bash
- os: windows-latest
shell: powershell
fail-fast: false
runs-on: ${{ matrix.platform.os }}
defaults:
run:
shell: ${{ matrix.platform.shell }}
steps:
- name: Checkout Repository
uses: actions/checkout@v1.1.0
- name: Use Nodejs ${{ matrix.node-version }}
uses: actions/setup-node@v1
with:
node-version: ${{ matrix.node-version }}
- name: Install dependencies
run: npm install
- name: Run Tests
run: npm test -- -c -t0
isaacs-minipass-ffdbee1/.github/workflows/commit-if-modified.sh 0000664 0000000 0000000 00000000432 14414631765 0025041 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
git config --global user.email "$1"
shift
git config --global user.name "$1"
shift
message="$1"
shift
if [ $(git status --porcelain "$@" | egrep '^ M' | wc -l) -gt 0 ]; then
git add "$@"
git commit -m "$message"
git push || git pull --rebase
git push
fi
isaacs-minipass-ffdbee1/.github/workflows/copyright-year.sh 0000664 0000000 0000000 00000001001 14414631765 0024336 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
dir=${1:-$PWD}
dates=($(git log --date=format:%Y --pretty=format:'%ad' --reverse | sort | uniq))
if [ "${#dates[@]}" -eq 1 ]; then
datestr="${dates}"
else
datestr="${dates}-${dates[${#dates[@]}-1]}"
fi
stripDate='s/^((.*)Copyright\b(.*?))((?:,\s*)?(([0-9]{4}\s*-\s*[0-9]{4})|(([0-9]{4},\s*)*[0-9]{4})))(?:,)?\s*(.*)\n$/$1$9\n/g'
addDate='s/^.*Copyright(?:\s*\(c\))? /Copyright \(c\) '$datestr' /g'
for l in $dir/LICENSE*; do
perl -pi -e "$stripDate" $l
perl -pi -e "$addDate" $l
done
isaacs-minipass-ffdbee1/.github/workflows/isaacs-makework.yml 0000664 0000000 0000000 00000002146 14414631765 0024653 0 ustar 00root root 0000000 0000000 name: "various tidying up tasks to silence nagging"
on:
push:
branches:
- main
workflow_dispatch:
jobs:
makework:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Use Node.js
uses: actions/setup-node@v2.1.4
with:
node-version: 16.x
- name: put repo in package.json
run: node .github/workflows/package-json-repo.js
- name: check in package.json if modified
run: |
bash -x .github/workflows/commit-if-modified.sh \
"package-json-repo-bot@example.com" \
"package.json Repo Bot" \
"chore: add repo to package.json" \
package.json package-lock.json
- name: put all dates in license copyright line
run: bash .github/workflows/copyright-year.sh
- name: check in licenses if modified
run: |
bash .github/workflows/commit-if-modified.sh \
"license-year-bot@example.com" \
"License Year Bot" \
"chore: add copyright year to license" \
LICENSE*
isaacs-minipass-ffdbee1/.github/workflows/package-json-repo.js 0000664 0000000 0000000 00000001056 14414631765 0024711 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const pf = require.resolve(`${process.cwd()}/package.json`)
const pj = require(pf)
if (!pj.repository && process.env.GITHUB_REPOSITORY) {
const fs = require('fs')
const server = process.env.GITHUB_SERVER_URL || 'https://github.com'
const repo = `${server}/${process.env.GITHUB_REPOSITORY}`
pj.repository = repo
const json = fs.readFileSync(pf, 'utf8')
const match = json.match(/^\s*\{[\r\n]+([ \t]*)"/)
const indent = match[1]
const output = JSON.stringify(pj, null, indent || 2) + '\n'
fs.writeFileSync(pf, output)
}
isaacs-minipass-ffdbee1/.github/workflows/static.yml 0000664 0000000 0000000 00000002413 14414631765 0023056 0 ustar 00root root 0000000 0000000 # Simple workflow for deploying static content to GitHub Pages
name: Deploy static content to Pages
on:
# Runs on pushes targeting the default branch
push:
branches: ["main"]
# Allows you to run this workflow manually from the Actions tab
workflow_dispatch:
# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
permissions:
contents: read
pages: write
id-token: write
# Allow one concurrent deployment
concurrency:
group: "pages"
cancel-in-progress: true
jobs:
# Single deploy job since we're just deploying
deploy:
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Use Nodejs ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: 18.x
- name: Install dependencies
run: npm install
- name: Generate typedocs
run: npm run typedoc
- name: Setup Pages
uses: actions/configure-pages@v3
- name: Upload artifact
uses: actions/upload-pages-artifact@v1
with:
path: './docs'
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v1
isaacs-minipass-ffdbee1/.gitignore 0000664 0000000 0000000 00000000066 14414631765 0017441 0 ustar 00root root 0000000 0000000 .*.swp
node_modules
.nyc_output/
coverage/
/index.mjs
isaacs-minipass-ffdbee1/.prettierignore 0000664 0000000 0000000 00000000157 14414631765 0020515 0 ustar 00root root 0000000 0000000 /node_modules
/example
/.github
/dist
.env
/tap-snapshots
/.nyc_output
/coverage
/benchmark
/bench
/LICENSE.md
isaacs-minipass-ffdbee1/CHANGELOG.md 0000664 0000000 0000000 00000004531 14414631765 0017263 0 ustar 00root root 0000000 0000000 # chernge lerg
## 5.0
- No default export, only a named export
## 4.2
- add AbortSignal support
- allow falsey values to be emitted in `objectMode`
## 4.1
- hybrid module
## 4.0
- make `.buffer` and `.pipes` private
## 3.3
- add type definitions
- add `pipe(dest, { proxyErrors: true })`
- add `unpipe(dest)` method
## 3.2
- add `{async: true}` option for async opt-in
- `'readable'` event emitted immediately when listened for
- use regular array instead of yallist
## 3.1
- re-emit 'error' event if missed and new listener added
- handle missing `process` object
- extend Stream instead of EventEmitter
## 3.0
- update yallist, drop safe-buffer
## 2.9
- treat ArrayBuffers and TypedArrays the same as Buffers
## 2.8
- remove undocumented 'ended' getter
- support setting objectMode implicitly or explicitly
- add several getters to mirror API of node core streams better
- add stream.destroy()
## 2.7
- only emit 'readable' when data is buffered
- add MiniPass.isStream() static method
## 2.6
- don't pause when a dest.write() returns a non-boolean falsey
- do not auto-end if explicitly paused
- piping from an ended stream ends the dest
- do not remove all endish listeners on endish events
- add `promise()` method
## 2.5
- guard against emitting other events while emitting end
- add stream.concat() to collect into one chunk
## 2.4
- stream.end() returns this
## 2.3
- harden against missed 'end' events
- not allow 'end' events to happen more than once
- add sync and async iteration
- add stream.collect()
## 2.2
- use Buffer.from to avoid DEP005.
- remove drain listener when done piping to dest
- add support for `pipe(dest, { end: false })`
- throw on illegal encoding change
## 2.1
- don't allow changing encoding in problematic cases
- fast-path strings
- add objectMode
## 2.0
- emit 'resume' on resume()
- add bufferLength property
- remove the baroque streams getters
## 1.2
- add baroque streams getters
## 1.1
- communicate backpressure immediately, including drain on resume
- defend against internal resume() being overwritten
- emit 'drain' when read() clears the buffer
- make stream.flowing read-only
- return full buffer if read() with no args
- add support for setEncoding
- mark as readable and writable
- pipe() returns destination stream
- don't try to end() stderr and stdout when piping
- end(chunk, encoding, cb) support
isaacs-minipass-ffdbee1/LICENSE 0000664 0000000 0000000 00000001423 14414631765 0016454 0 ustar 00root root 0000000 0000000 The ISC License
Copyright (c) 2017-2023 npm, Inc., Isaac Z. Schlueter, and Contributors
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
isaacs-minipass-ffdbee1/README.md 0000664 0000000 0000000 00000061716 14414631765 0016741 0 ustar 00root root 0000000 0000000 # minipass
A _very_ minimal implementation of a [PassThrough
stream](https://nodejs.org/api/stream.html#stream_class_stream_passthrough)
[It's very
fast](https://docs.google.com/spreadsheets/d/1K_HR5oh3r80b8WVMWCPPjfuWXUgfkmhlX7FGI6JJ8tY/edit?usp=sharing)
for objects, strings, and buffers.
Supports `pipe()`ing (including multi-`pipe()` and backpressure
transmission), buffering data until either a `data` event handler
or `pipe()` is added (so you don't lose the first chunk), and
most other cases where PassThrough is a good idea.
There is a `read()` method, but it's much more efficient to
consume data from this stream via `'data'` events or by calling
`pipe()` into some other stream. Calling `read()` requires the
buffer to be flattened in some cases, which requires copying
memory.
If you set `objectMode: true` in the options, then whatever is
written will be emitted. Otherwise, it'll do a minimal amount of
Buffer copying to ensure proper Streams semantics when `read(n)`
is called.
`objectMode` can also be set by doing `stream.objectMode = true`,
or by writing any non-string/non-buffer data. `objectMode` cannot
be set to false once it is set.
This is not a `through` or `through2` stream. It doesn't
transform the data, it just passes it right through. If you want
to transform the data, extend the class, and override the
`write()` method. Once you're done transforming the data however
you want, call `super.write()` with the transform output.
For some examples of streams that extend Minipass in various
ways, check out:
- [minizlib](http://npm.im/minizlib)
- [fs-minipass](http://npm.im/fs-minipass)
- [tar](http://npm.im/tar)
- [minipass-collect](http://npm.im/minipass-collect)
- [minipass-flush](http://npm.im/minipass-flush)
- [minipass-pipeline](http://npm.im/minipass-pipeline)
- [tap](http://npm.im/tap)
- [tap-parser](http://npm.im/tap-parser)
- [treport](http://npm.im/treport)
- [minipass-fetch](http://npm.im/minipass-fetch)
- [pacote](http://npm.im/pacote)
- [make-fetch-happen](http://npm.im/make-fetch-happen)
- [cacache](http://npm.im/cacache)
- [ssri](http://npm.im/ssri)
- [npm-registry-fetch](http://npm.im/npm-registry-fetch)
- [minipass-json-stream](http://npm.im/minipass-json-stream)
- [minipass-sized](http://npm.im/minipass-sized)
## Differences from Node.js Streams
There are several things that make Minipass streams different
from (and in some ways superior to) Node.js core streams.
Please read these caveats if you are familiar with node-core
streams and intend to use Minipass streams in your programs.
You can avoid most of these differences entirely (for a very
small performance penalty) by setting `{async: true}` in the
constructor options.
### Timing
Minipass streams are designed to support synchronous use-cases.
Thus, data is emitted as soon as it is available, always. It is
buffered until read, but no longer. Another way to look at it is
that Minipass streams are exactly as synchronous as the logic
that writes into them.
This can be surprising if your code relies on
`PassThrough.write()` always providing data on the next tick
rather than the current one, or being able to call `resume()` and
not have the entire buffer disappear immediately.
However, without this synchronicity guarantee, there would be no
way for Minipass to achieve the speeds it does, or support the
synchronous use cases that it does. Simply put, waiting takes
time.
This non-deferring approach makes Minipass streams much easier to
reason about, especially in the context of Promises and other
flow-control mechanisms.
Example:
```js
// hybrid module, either works
import { Minipass } from 'minipass'
// or:
const { Minipass } = require('minipass')
const stream = new Minipass()
stream.on('data', () => console.log('data event'))
console.log('before write')
stream.write('hello')
console.log('after write')
// output:
// before write
// data event
// after write
```
### Exception: Async Opt-In
If you wish to have a Minipass stream with behavior that more
closely mimics Node.js core streams, you can set the stream in
async mode either by setting `async: true` in the constructor
options, or by setting `stream.async = true` later on.
```js
// hybrid module, either works
import { Minipass } from 'minipass'
// or:
const { Minipass } = require('minipass')
const asyncStream = new Minipass({ async: true })
asyncStream.on('data', () => console.log('data event'))
console.log('before write')
asyncStream.write('hello')
console.log('after write')
// output:
// before write
// after write
// data event <-- this is deferred until the next tick
```
Switching _out_ of async mode is unsafe, as it could cause data
corruption, and so is not enabled. Example:
```js
import { Minipass } from 'minipass'
const stream = new Minipass({ encoding: 'utf8' })
stream.on('data', chunk => console.log(chunk))
stream.async = true
console.log('before writes')
stream.write('hello')
setStreamSyncAgainSomehow(stream) // <-- this doesn't actually exist!
stream.write('world')
console.log('after writes')
// hypothetical output would be:
// before writes
// world
// after writes
// hello
// NOT GOOD!
```
To avoid this problem, once set into async mode, any attempt to
make the stream sync again will be ignored.
```js
const { Minipass } = require('minipass')
const stream = new Minipass({ encoding: 'utf8' })
stream.on('data', chunk => console.log(chunk))
stream.async = true
console.log('before writes')
stream.write('hello')
stream.async = false // <-- no-op, stream already async
stream.write('world')
console.log('after writes')
// actual output:
// before writes
// after writes
// hello
// world
```
### No High/Low Water Marks
Node.js core streams will optimistically fill up a buffer,
returning `true` on all writes until the limit is hit, even if
the data has nowhere to go. Then, they will not attempt to draw
more data in until the buffer size dips below a minimum value.
Minipass streams are much simpler. The `write()` method will
return `true` if the data has somewhere to go (which is to say,
given the timing guarantees, that the data is already there by
the time `write()` returns).
If the data has nowhere to go, then `write()` returns false, and
the data sits in a buffer, to be drained out immediately as soon
as anyone consumes it.
Since nothing is ever buffered unnecessarily, there is much less
copying data, and less bookkeeping about buffer capacity levels.
### Hazards of Buffering (or: Why Minipass Is So Fast)
Since data written to a Minipass stream is immediately written
all the way through the pipeline, and `write()` always returns
true/false based on whether the data was fully flushed,
backpressure is communicated immediately to the upstream caller.
This minimizes buffering.
Consider this case:
```js
const { PassThrough } = require('stream')
const p1 = new PassThrough({ highWaterMark: 1024 })
const p2 = new PassThrough({ highWaterMark: 1024 })
const p3 = new PassThrough({ highWaterMark: 1024 })
const p4 = new PassThrough({ highWaterMark: 1024 })
p1.pipe(p2).pipe(p3).pipe(p4)
p4.on('data', () => console.log('made it through'))
// this returns false and buffers, then writes to p2 on next tick (1)
// p2 returns false and buffers, pausing p1, then writes to p3 on next tick (2)
// p3 returns false and buffers, pausing p2, then writes to p4 on next tick (3)
// p4 returns false and buffers, pausing p3, then emits 'data' and 'drain'
// on next tick (4)
// p3 sees p4's 'drain' event, and calls resume(), emitting 'resume' and
// 'drain' on next tick (5)
// p2 sees p3's 'drain', calls resume(), emits 'resume' and 'drain' on next tick (6)
// p1 sees p2's 'drain', calls resume(), emits 'resume' and 'drain' on next
// tick (7)
p1.write(Buffer.alloc(2048)) // returns false
```
Along the way, the data was buffered and deferred at each stage,
and multiple event deferrals happened, for an unblocked pipeline
where it was perfectly safe to write all the way through!
Furthermore, setting a `highWaterMark` of `1024` might lead
someone reading the code to think an advisory maximum of 1KiB is
being set for the pipeline. However, the actual advisory
buffering level is the _sum_ of `highWaterMark` values, since
each one has its own bucket.
Consider the Minipass case:
```js
const m1 = new Minipass()
const m2 = new Minipass()
const m3 = new Minipass()
const m4 = new Minipass()
m1.pipe(m2).pipe(m3).pipe(m4)
m4.on('data', () => console.log('made it through'))
// m1 is flowing, so it writes the data to m2 immediately
// m2 is flowing, so it writes the data to m3 immediately
// m3 is flowing, so it writes the data to m4 immediately
// m4 is flowing, so it fires the 'data' event immediately, returns true
// m4's write returned true, so m3 is still flowing, returns true
// m3's write returned true, so m2 is still flowing, returns true
// m2's write returned true, so m1 is still flowing, returns true
// No event deferrals or buffering along the way!
m1.write(Buffer.alloc(2048)) // returns true
```
It is extremely unlikely that you _don't_ want to buffer any data
written, or _ever_ buffer data that can be flushed all the way
through. Neither node-core streams nor Minipass ever fail to
buffer written data, but node-core streams do a lot of
unnecessary buffering and pausing.
As always, the faster implementation is the one that does less
stuff and waits less time to do it.
### Immediately emit `end` for empty streams (when not paused)
If a stream is not paused, and `end()` is called before writing
any data into it, then it will emit `end` immediately.
If you have logic that occurs on the `end` event which you don't
want to potentially happen immediately (for example, closing file
descriptors, moving on to the next entry in an archive parse
stream, etc.) then be sure to call `stream.pause()` on creation,
and then `stream.resume()` once you are ready to respond to the
`end` event.
However, this is _usually_ not a problem because:
### Emit `end` When Asked
One hazard of immediately emitting `'end'` is that you may not
yet have had a chance to add a listener. In order to avoid this
hazard, Minipass streams safely re-emit the `'end'` event if a
new listener is added after `'end'` has been emitted.
Ie, if you do `stream.on('end', someFunction)`, and the stream
has already emitted `end`, then it will call the handler right
away. (You can think of this somewhat like attaching a new
`.then(fn)` to a previously-resolved Promise.)
To prevent calling handlers multiple times who would not expect
multiple ends to occur, all listeners are removed from the
`'end'` event whenever it is emitted.
### Emit `error` When Asked
The most recent error object passed to the `'error'` event is
stored on the stream. If a new `'error'` event handler is added,
and an error was previously emitted, then the event handler will
be called immediately (or on `process.nextTick` in the case of
async streams).
This makes it much more difficult to end up trying to interact
with a broken stream, if the error handler is added after an
error was previously emitted.
### Impact of "immediate flow" on Tee-streams
A "tee stream" is a stream piping to multiple destinations:
```js
const tee = new Minipass()
t.pipe(dest1)
t.pipe(dest2)
t.write('foo') // goes to both destinations
```
Since Minipass streams _immediately_ process any pending data
through the pipeline when a new pipe destination is added, this
can have surprising effects, especially when a stream comes in
from some other function and may or may not have data in its
buffer.
```js
// WARNING! WILL LOSE DATA!
const src = new Minipass()
src.write('foo')
src.pipe(dest1) // 'foo' chunk flows to dest1 immediately, and is gone
src.pipe(dest2) // gets nothing!
```
One solution is to create a dedicated tee-stream junction that
pipes to both locations, and then pipe to _that_ instead.
```js
// Safe example: tee to both places
const src = new Minipass()
src.write('foo')
const tee = new Minipass()
tee.pipe(dest1)
tee.pipe(dest2)
src.pipe(tee) // tee gets 'foo', pipes to both locations
```
The same caveat applies to `on('data')` event listeners. The
first one added will _immediately_ receive all of the data,
leaving nothing for the second:
```js
// WARNING! WILL LOSE DATA!
const src = new Minipass()
src.write('foo')
src.on('data', handler1) // receives 'foo' right away
src.on('data', handler2) // nothing to see here!
```
Using a dedicated tee-stream can be used in this case as well:
```js
// Safe example: tee to both data handlers
const src = new Minipass()
src.write('foo')
const tee = new Minipass()
tee.on('data', handler1)
tee.on('data', handler2)
src.pipe(tee)
```
All of the hazards in this section are avoided by setting `{
async: true }` in the Minipass constructor, or by setting
`stream.async = true` afterwards. Note that this does add some
overhead, so should only be done in cases where you are willing
to lose a bit of performance in order to avoid having to refactor
program logic.
## USAGE
It's a stream! Use it like a stream and it'll most likely do what
you want.
```js
import { Minipass } from 'minipass'
const mp = new Minipass(options) // optional: { encoding, objectMode }
mp.write('foo')
mp.pipe(someOtherStream)
mp.end('bar')
```
### OPTIONS
- `encoding` How would you like the data coming _out_ of the
stream to be encoded? Accepts any values that can be passed to
`Buffer.toString()`.
- `objectMode` Emit data exactly as it comes in. This will be
flipped on by default if you write() something other than a
string or Buffer at any point. Setting `objectMode: true` will
prevent setting any encoding value.
- `async` Defaults to `false`. Set to `true` to defer data
emission until next tick. This reduces performance slightly,
but makes Minipass streams use timing behavior closer to Node
core streams. See [Timing](#timing) for more details.
- `signal` An `AbortSignal` that will cause the stream to unhook
itself from everything and become as inert as possible. Note
that providing a `signal` parameter will make `'error'` events
no longer throw if they are unhandled, but they will still be
emitted to handlers if any are attached.
### API
Implements the user-facing portions of Node.js's `Readable` and
`Writable` streams.
### Methods
- `write(chunk, [encoding], [callback])` - Put data in. (Note
that, in the base Minipass class, the same data will come out.)
Returns `false` if the stream will buffer the next write, or
true if it's still in "flowing" mode.
- `end([chunk, [encoding]], [callback])` - Signal that you have
no more data to write. This will queue an `end` event to be
fired when all the data has been consumed.
- `setEncoding(encoding)` - Set the encoding for data coming of
the stream. This can only be done once.
- `pause()` - No more data for a while, please. This also
prevents `end` from being emitted for empty streams until the
stream is resumed.
- `resume()` - Resume the stream. If there's data in the buffer,
it is all discarded. Any buffered events are immediately
emitted.
- `pipe(dest)` - Send all output to the stream provided. When
data is emitted, it is immediately written to any and all pipe
destinations. (Or written on next tick in `async` mode.)
- `unpipe(dest)` - Stop piping to the destination stream. This is
immediate, meaning that any asynchronously queued data will
_not_ make it to the destination when running in `async` mode.
- `options.end` - Boolean, end the destination stream when the
source stream ends. Default `true`.
- `options.proxyErrors` - Boolean, proxy `error` events from
the source stream to the destination stream. Note that errors
are _not_ proxied after the pipeline terminates, either due
to the source emitting `'end'` or manually unpiping with
`src.unpipe(dest)`. Default `false`.
- `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are
EventEmitters. Some events are given special treatment,
however. (See below under "events".)
- `promise()` - Returns a Promise that resolves when the stream
emits `end`, or rejects if the stream emits `error`.
- `collect()` - Return a Promise that resolves on `end` with an
array containing each chunk of data that was emitted, or
rejects if the stream emits `error`. Note that this consumes
the stream data.
- `concat()` - Same as `collect()`, but concatenates the data
into a single Buffer object. Will reject the returned promise
if the stream is in objectMode, or if it goes into objectMode
by the end of the data.
- `read(n)` - Consume `n` bytes of data out of the buffer. If `n`
is not provided, then consume all of it. If `n` bytes are not
available, then it returns null. **Note** consuming streams in
this way is less efficient, and can lead to unnecessary Buffer
copying.
- `destroy([er])` - Destroy the stream. If an error is provided,
then an `'error'` event is emitted. If the stream has a
`close()` method, and has not emitted a `'close'` event yet,
then `stream.close()` will be called. Any Promises returned by
`.promise()`, `.collect()` or `.concat()` will be rejected.
After being destroyed, writing to the stream will emit an
error. No more data will be emitted if the stream is destroyed,
even if it was previously buffered.
### Properties
- `bufferLength` Read-only. Total number of bytes buffered, or in
the case of objectMode, the total number of objects.
- `encoding` The encoding that has been set. (Setting this is
equivalent to calling `setEncoding(enc)` and has the same
prohibition against setting multiple times.)
- `flowing` Read-only. Boolean indicating whether a chunk written
to the stream will be immediately emitted.
- `emittedEnd` Read-only. Boolean indicating whether the end-ish
events (ie, `end`, `prefinish`, `finish`) have been emitted.
Note that listening on any end-ish event will immediateyl
re-emit it if it has already been emitted.
- `writable` Whether the stream is writable. Default `true`. Set
to `false` when `end()`
- `readable` Whether the stream is readable. Default `true`.
- `pipes` An array of Pipe objects referencing streams that this
stream is piping into.
- `destroyed` A getter that indicates whether the stream was
destroyed.
- `paused` True if the stream has been explicitly paused,
otherwise false.
- `objectMode` Indicates whether the stream is in `objectMode`.
Once set to `true`, it cannot be set to `false`.
- `aborted` Readonly property set when the `AbortSignal`
dispatches an `abort` event.
### Events
- `data` Emitted when there's data to read. Argument is the data
to read. This is never emitted while not flowing. If a listener
is attached, that will resume the stream.
- `end` Emitted when there's no more data to read. This will be
emitted immediately for empty streams when `end()` is called.
If a listener is attached, and `end` was already emitted, then
it will be emitted again. All listeners are removed when `end`
is emitted.
- `prefinish` An end-ish event that follows the same logic as
`end` and is emitted in the same conditions where `end` is
emitted. Emitted after `'end'`.
- `finish` An end-ish event that follows the same logic as `end`
and is emitted in the same conditions where `end` is emitted.
Emitted after `'prefinish'`.
- `close` An indication that an underlying resource has been
released. Minipass does not emit this event, but will defer it
until after `end` has been emitted, since it throws off some
stream libraries otherwise.
- `drain` Emitted when the internal buffer empties, and it is
again suitable to `write()` into the stream.
- `readable` Emitted when data is buffered and ready to be read
by a consumer.
- `resume` Emitted when stream changes state from buffering to
flowing mode. (Ie, when `resume` is called, `pipe` is called,
or a `data` event listener is added.)
### Static Methods
- `Minipass.isStream(stream)` Returns `true` if the argument is a
stream, and false otherwise. To be considered a stream, the
object must be either an instance of Minipass, or an
EventEmitter that has either a `pipe()` method, or both
`write()` and `end()` methods. (Pretty much any stream in
node-land will return `true` for this.)
## EXAMPLES
Here are some examples of things you can do with Minipass
streams.
### simple "are you done yet" promise
```js
mp.promise().then(
() => {
// stream is finished
},
er => {
// stream emitted an error
}
)
```
### collecting
```js
mp.collect().then(all => {
// all is an array of all the data emitted
// encoding is supported in this case, so
// so the result will be a collection of strings if
// an encoding is specified, or buffers/objects if not.
//
// In an async function, you may do
// const data = await stream.collect()
})
```
### collecting into a single blob
This is a bit slower because it concatenates the data into one
chunk for you, but if you're going to do it yourself anyway, it's
convenient this way:
```js
mp.concat().then(onebigchunk => {
// onebigchunk is a string if the stream
// had an encoding set, or a buffer otherwise.
})
```
### iteration
You can iterate over streams synchronously or asynchronously in
platforms that support it.
Synchronous iteration will end when the currently available data
is consumed, even if the `end` event has not been reached. In
string and buffer mode, the data is concatenated, so unless
multiple writes are occurring in the same tick as the `read()`,
sync iteration loops will generally only have a single iteration.
To consume chunks in this way exactly as they have been written,
with no flattening, create the stream with the `{ objectMode:
true }` option.
```js
const mp = new Minipass({ objectMode: true })
mp.write('a')
mp.write('b')
for (let letter of mp) {
console.log(letter) // a, b
}
mp.write('c')
mp.write('d')
for (let letter of mp) {
console.log(letter) // c, d
}
mp.write('e')
mp.end()
for (let letter of mp) {
console.log(letter) // e
}
for (let letter of mp) {
console.log(letter) // nothing
}
```
Asynchronous iteration will continue until the end event is reached,
consuming all of the data.
```js
const mp = new Minipass({ encoding: 'utf8' })
// some source of some data
let i = 5
const inter = setInterval(() => {
if (i-- > 0) mp.write(Buffer.from('foo\n', 'utf8'))
else {
mp.end()
clearInterval(inter)
}
}, 100)
// consume the data with asynchronous iteration
async function consume() {
for await (let chunk of mp) {
console.log(chunk)
}
return 'ok'
}
consume().then(res => console.log(res))
// logs `foo\n` 5 times, and then `ok`
```
### subclass that `console.log()`s everything written into it
```js
class Logger extends Minipass {
write(chunk, encoding, callback) {
console.log('WRITE', chunk, encoding)
return super.write(chunk, encoding, callback)
}
end(chunk, encoding, callback) {
console.log('END', chunk, encoding)
return super.end(chunk, encoding, callback)
}
}
someSource.pipe(new Logger()).pipe(someDest)
```
### same thing, but using an inline anonymous class
```js
// js classes are fun
someSource
.pipe(
new (class extends Minipass {
emit(ev, ...data) {
// let's also log events, because debugging some weird thing
console.log('EMIT', ev)
return super.emit(ev, ...data)
}
write(chunk, encoding, callback) {
console.log('WRITE', chunk, encoding)
return super.write(chunk, encoding, callback)
}
end(chunk, encoding, callback) {
console.log('END', chunk, encoding)
return super.end(chunk, encoding, callback)
}
})()
)
.pipe(someDest)
```
### subclass that defers 'end' for some reason
```js
class SlowEnd extends Minipass {
emit(ev, ...args) {
if (ev === 'end') {
console.log('going to end, hold on a sec')
setTimeout(() => {
console.log('ok, ready to end now')
super.emit('end', ...args)
}, 100)
} else {
return super.emit(ev, ...args)
}
}
}
```
### transform that creates newline-delimited JSON
```js
class NDJSONEncode extends Minipass {
write(obj, cb) {
try {
// JSON.stringify can throw, emit an error on that
return super.write(JSON.stringify(obj) + '\n', 'utf8', cb)
} catch (er) {
this.emit('error', er)
}
}
end(obj, cb) {
if (typeof obj === 'function') {
cb = obj
obj = undefined
}
if (obj !== undefined) {
this.write(obj)
}
return super.end(cb)
}
}
```
### transform that parses newline-delimited JSON
```js
class NDJSONDecode extends Minipass {
constructor (options) {
// always be in object mode, as far as Minipass is concerned
super({ objectMode: true })
this._jsonBuffer = ''
}
write (chunk, encoding, cb) {
if (typeof chunk === 'string' &&
typeof encoding === 'string' &&
encoding !== 'utf8') {
chunk = Buffer.from(chunk, encoding).toString()
} else if (Buffer.isBuffer(chunk)) {
chunk = chunk.toString()
}
if (typeof encoding === 'function') {
cb = encoding
}
const jsonData = (this._jsonBuffer + chunk).split('\n')
this._jsonBuffer = jsonData.pop()
for (let i = 0; i < jsonData.length; i++) {
try {
// JSON.parse can throw, emit an error on that
super.write(JSON.parse(jsonData[i]))
} catch (er) {
this.emit('error', er)
continue
}
}
if (cb)
cb()
}
}
```
isaacs-minipass-ffdbee1/bench/ 0000775 0000000 0000000 00000000000 14414631765 0016526 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/bench/README.md 0000664 0000000 0000000 00000002525 14414631765 0020011 0 ustar 00root root 0000000 0000000 Stream Benchmarks
Run `node index.js` to benchmark all the different stream implementations
with the following configurations:
- `implementation` One of the implementations in `./impls`
- `case` How is the data emitted and how is it consumed?
- `fast-fast` Source emits data as fast as possible, destination
consumes it immediately.
- `fast-slow` Source emits data as fast as possible, destination
consumes one chunk per Promise cycle.
- `slow-fast` Source emits one data per Promise cycle, destination
consumes it immediately.
- `slow-slow` Source emits one data per Promise cycle, destination
consumes one chunk per Promise cycle.
- `fast-mixed` Source emits data as fast as possible, data is piped to
one fast destination stream and one slow destination stream.
- `pipeline` How many instances of the tested implementation are piped
together between the source and destination? Tested with `1` and `20` by
default.
- `type` What kind of data is written?
- `defaults` a buffer
- `str` a string
- `obj` the object `{i: 'object'}`
Results are written to the `./results` folder for each test case, and to
`results.json` and `results.tab`.
See [this google
sheet](https://docs.google.com/spreadsheets/d/1K_HR5oh3r80b8WVMWCPPjfuWXUgfkmhlX7FGI6JJ8tY/edit?usp=sharing)
for analysis and comparisons.
isaacs-minipass-ffdbee1/bench/impls/ 0000775 0000000 0000000 00000000000 14414631765 0017652 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/bench/impls/README.md 0000664 0000000 0000000 00000001255 14414631765 0021134 0 ustar 00root root 0000000 0000000 To add a new stream type to test, create a file here that exports a
function or class that can be called with `s = new Class(options)`, where
`options` can include `{encoding: 'utf8'}` or `{objectMode: true}`.
The returned object must implement at minimum the following subset of the
stream interface:
* `on(event, fn)` call `fn` when `event` happens
* `write(data)` where `data` will be an object, string, or buffer. Return
`true` if more data should be written, `false` otherwise. Emit `drain`
when ready for more data if `false` is written.
* `end()` no further data will be written, emit `'finish'` when all data
processed
* `pipe(dest)` pipe all output to `dest` stream
isaacs-minipass-ffdbee1/bench/impls/baseline.js 0000664 0000000 0000000 00000000517 14414631765 0021775 0 ustar 00root root 0000000 0000000 // piping to /dev/null
module.exports = class BaselineNoOpStream {
constructor () {
this.pipeDests = []
}
write () { return true }
end () {
this.pipeDests.forEach(d => d.end())
return this
}
pipe (d) {
this.pipeDests.push(d)
return d
}
read () { return null }
on () { return this }
emit () {}
}
isaacs-minipass-ffdbee1/bench/impls/core-extend-transform.js 0000664 0000000 0000000 00000000331 14414631765 0024433 0 ustar 00root root 0000000 0000000 const stream = require('stream')
module.exports = class ExtendTransform extends stream.Transform {
constructor (opts) {
super(opts)
}
_transform (data, enc, done) {
this.push(data, enc)
done()
}
}
isaacs-minipass-ffdbee1/bench/impls/core-passthrough.js 0000664 0000000 0000000 00000000057 14414631765 0023507 0 ustar 00root root 0000000 0000000 module.exports = require('stream').PassThrough
isaacs-minipass-ffdbee1/bench/impls/extend-minipass-current.js 0000664 0000000 0000000 00000000317 14414631765 0025001 0 ustar 00root root 0000000 0000000 const Minipass = require('../..')
module.exports = class ExtendMinipass extends Minipass {
constructor (opts) {
super(opts)
}
write (data, encoding) {
return super.write(data, encoding)
}
}
isaacs-minipass-ffdbee1/bench/impls/extend-minipass.js 0000664 0000000 0000000 00000000322 14414631765 0023315 0 ustar 00root root 0000000 0000000 const Minipass = require('minipass')
module.exports = class ExtendMinipass extends Minipass {
constructor (opts) {
super(opts)
}
write (data, encoding) {
return super.write(data, encoding)
}
}
isaacs-minipass-ffdbee1/bench/impls/extend-through2.js 0000664 0000000 0000000 00000000450 14414631765 0023236 0 ustar 00root root 0000000 0000000 const through2 = require('through2')
module.exports = function (opts) {
if (opts.objectMode)
return through2.obj(func)
s = through2(func)
if (opts.encoding) {
s.setEncoding(opts.encoding)
}
return s
function func (data, enc, done) {
this.push(data, enc)
done()
}
}
isaacs-minipass-ffdbee1/bench/impls/minipass-current-async.js 0000664 0000000 0000000 00000000235 14414631765 0024626 0 ustar 00root root 0000000 0000000 const Minipass = require('../..')
module.exports = class extends Minipass {
constructor (options = {}) {
options.async = true
super(options)
}
}
isaacs-minipass-ffdbee1/bench/impls/minipass-current.js 0000664 0000000 0000000 00000000042 14414631765 0023507 0 ustar 00root root 0000000 0000000 module.exports = require('../..')
isaacs-minipass-ffdbee1/bench/impls/minipass-latest.js 0000664 0000000 0000000 00000000045 14414631765 0023324 0 ustar 00root root 0000000 0000000 module.exports = require('minipass')
isaacs-minipass-ffdbee1/bench/impls/minipass-v3.js 0000664 0000000 0000000 00000000046 14414631765 0022361 0 ustar 00root root 0000000 0000000 module.exports = require('minipass3')
isaacs-minipass-ffdbee1/bench/impls/push-through.js 0000664 0000000 0000000 00000004024 14414631765 0022645 0 ustar 00root root 0000000 0000000 // This is a minimal non-EE stream class inspired by push-stream
// It can support multiple outputs, but only one input.
class PushThrough {
constructor (opt) {
this.dests = []
this.paused = false
this.buffer = []
this.ended = false
this.ondrain = []
this.onfinish = []
}
on (ev, fn) {
switch (ev) {
case 'error': break
case 'finish':
this.onfinish.push(fn)
break
case 'drain':
this.ondrain.push(fn)
break
default:
throw new Error(`event ${ev} not supported`)
}
}
once (ev, fn) {
const f = () => {
fn()
this[`on${ev}`] = this[`on${ev}`].filter(fn => fn !== f)
}
this.on(ev, f)
}
emit (ev) {
switch (ev) {
case 'finish':
this.onfinish.forEach(f => f())
break
case 'drain':
this.ondrain.forEach(f => f())
break
default:
throw new Error(`event ${ev} not supported`)
}
}
pipe (dest) {
this.dests.push(dest)
dest.on('drain', () => this.resume())
this.resume()
}
resume () {
this.paused = false
if (this.buffer.length) {
const b = this.buffer.slice(0)
this.buffer.length = 0
for (const c of b) {
for (const dest of this.dests) {
const ret = dest.write(c)
this.paused = this.paused || ret === false
}
}
}
if (this.buffer.length === 0) this.emit('drain')
if (this.ended && this.buffer.length === 0) {
for (const d of this.dests) {
d.end()
}
this.emit('finish')
}
}
pause () {
this.paused = true
}
write (chunk) {
if (this.ended) {
throw new Error('write after end')
}
if (!this.dests.length || this.paused) {
this.buffer.push(chunk)
return false
}
for (const dest of this.dests) {
const ret = dest.write(chunk)
this.paused = this.paused || ret === false
}
return !this.paused
}
end () {
this.ended = true
this.resume()
}
}
module.exports = PushThrough
isaacs-minipass-ffdbee1/bench/impls/through2.js 0000664 0000000 0000000 00000000323 14414631765 0021750 0 ustar 00root root 0000000 0000000 const through2 = require('through2')
module.exports = function (opts) {
if (opts.objectMode)
return through2.obj()
s = through2()
if (opts.encoding) {
s.setEncoding(opts.encoding)
}
return s
}
isaacs-minipass-ffdbee1/bench/impls/web-std.js.REMOVED-GH-42157 0000664 0000000 0000000 00000000533 14414631765 0023632 0 ustar 00root root 0000000 0000000 const { TransformStream: WebTS } = require('stream/web')
const { Transform: NodeTS } = require('stream')
module.exports = function PassthroughFromWeb (opt) {
if (opt.objectMode) {
throw new Error('object mode not supported')
}
const s = NodeTS.fromWeb(new WebTS())
if (opt.encoding) {
s.setEncoding(opt.encoding)
}
return s
}
isaacs-minipass-ffdbee1/bench/index.js 0000664 0000000 0000000 00000016475 14414631765 0020210 0 ustar 00root root 0000000 0000000 // if you go much higher the core streams just choke and take forever lol
const N = Math.floor(128*1024 / Math.PI)
const fs = require('fs')
// const { basename } = require('path')
// const impls = fs.readdirSync(__dirname + '/impls')
// .filter(f => /\.js$/.test(f)).map(f => basename(f, '.js'))
const impls = [
'baseline',
'minipass-v3',
'minipass-latest',
'minipass-current',
'minipass-current-async',
'extend-minipass-current',
'core-extend-transform',
'core-passthrough',
]
const promiseSpawn = require('@npmcli/promise-spawn')
const main = async () => {
const [node, _, impl, cse, len, type] = process.argv
const opt = { stdioString: true, stdio: ['ignore', 'pipe', 'inherit'] }
const results = {}
if (impl === undefined) {
// run against all implementations
const a = [__filename]
for (const i of impls) {
const res = await promiseSpawn(process.execPath, [...a, i], opt)
.catch(e => e)
try {
results[i] = JSON.parse(res.stdout)
} catch (e) {
results[i] = e
}
}
} else if (cse === undefined) {
const a = [__filename, impl]
for (const c of cases) {
const res = await promiseSpawn(process.execPath, [...a, c], opt)
.catch(e => e)
try {
results[c] = JSON.parse(res.stdout)
} catch (e) {
results[c] = e
}
}
} else if (len === undefined) {
const a = [__filename, impl, cse]
for (const l of pipeLen) {
const res = await promiseSpawn(process.execPath, [...a, l], opt)
.catch(e => e)
try {
results[l] = JSON.parse(res.stdout)
} catch (e) {
results[l] = e
}
}
} else {
const fs = require('fs')
const dir = __dirname + '/results'
fs.mkdirSync(dir, { recursive: true })
// ok, actually run this one case and return the score
const opts = {
defaults: {},
str: {encoding:'utf8'},
obj: {objectMode: true},
}
const typeOpts = type ? [[type, opts[type]]] : Object.entries(opts)
for (const [name, opt] of typeOpts) {
await new Promise((res, rej) => {
process.stderr.write(`${impl} ${cse} ${len} ${name} ... `)
const { src, start, dest, dest2 } = setupPipeline(impl, len, cse, opt)
const end = () => {
const result = performance.now() - startTime
results[name] = result
console.error(result)
res()
}
let ended1 = false
let ended2 = !dest2
if (dest2) {
dest2.on('finish', () => {
if (ended2) throw new Error('emitted multiple dest2.finish')
ended2 = true
if (ended1) {
end()
}
})
}
dest.on('finish', () => {
if (ended1) throw new Error('emitted multiple dest1.finish')
ended1 = true
if (ended2) {
end()
}
})
// kick it off!
const startTime = performance.now()
src.pipe(start).on('error', rej)
}).catch(e => results[name] = e)
}
fs.writeFileSync(`${dir}/${impl}-${cse}-${len}.json`,
JSON.stringify(results, 0, 2))
}
console.log(JSON.stringify(results, 0, 2))
fs.writeFileSync('results.json', JSON.stringify(results, 0, 2) + '\n')
// write out the results.tab from the top level
if (impl === undefined) {
const header = ['impl', 'case', 'pipeline', 'type', 'time', 'score']
const rows = []
let max = -1
for (const [impl, iRes] of Object.entries(results)) {
for (const [cse, cRes] of Object.entries(iRes)) {
for (const [len, lRes] of Object.entries(cRes)) {
for (const [type, time] of Object.entries(lRes)) {
max = Math.max(max, time)
rows.push([impl, cse, len, type, time])
}
}
}
}
for (const row of rows) {
row.push(max / row[row.length - 1])
}
const output = [header].concat(rows.sort((a, b) => a[a.length-1] - b[b.length-1]))
.map(row => row.join('\t'))
.join('\n') + '\n'
fs.writeFileSync(__dirname + '/results.tab', output)
}
}
// is the src and dest fast or slow?
const cases = [
'fast-fast',
'fast-slow',
'slow-fast',
'slow-slow',
'fast-mixed', // two dests: 1 fast, 1 slow
]
// how many of the stream under test piped together?
const pipeLen = [ 1, 20 ]
const EE = require('events')
const setupPipeline = (impl, len, cse, opt) => {
const Cls = require(`./impls/${impl}.js`)
let s = new Cls(opt)
let start = s
while (len > 1) {
s = s.pipe(new Cls(opt))
len --
}
let src
let dest
let dest2
switch (cse) {
case 'fast-fast':
src = new FastSrc(opt)
dest = new FastDest(opt)
break
case 'fast-slow':
src = new FastSrc(opt)
dest = new SlowDest(opt)
break
case 'slow-fast':
src = new SlowSrc(opt)
dest = new FastDest(opt)
break
case 'slow-slow':
src = new SlowSrc(opt)
dest = new SlowDest(opt)
break
case 'fast-mixed':
src = new FastSrc(opt)
dest = new FastDest(opt)
dest2 = new SlowDest(opt)
break
default:
throw new Error('unknown case: ' + cse)
}
s.pipe(dest)
if (dest2) {
s.pipe(dest2)
}
return { src, start, dest, dest2 }
}
class Src extends EE {
constructor (options) {
super()
this.chunk = options.objectMode ? { i: 'object' }
: options.encoding ? 'x'.repeat(N)
: Buffer.from('x'.repeat(N))
this.n = N
this.flowing = false
this.readable = true
this.writable = false
}
pipe (dest) {
dest.on('drain', () => this.resume())
this.on('data', c => dest.write(c) === false ? this.pause() : true)
this.on('end', () => dest.end())
this.resume()
return dest
}
pause () {
this.flowing = false
}
}
class FastSrc extends Src {
resume () {
if (this.flowing) {
return
}
this.flowing = true
while (this.n > 0 && this.flowing) {
this.emit('data', this.chunk)
this.n --
}
if (this.flowing && this.n === 0) {
this.emit('end')
}
}
}
class SlowSrc extends Src {
resume () {
if (this.flowing) {
return
}
this.flowing = true
const doResume = () => {
if (!this.flowing ) {
return
}
if (this.flowing && this.n > 0) {
this.emit('data', this.chunk)
this.n --
return Promise.resolve().then(doResume)
}
if (this.flowing && this.n <= 0) {
this.emit('end')
return
}
}
Promise.resolve().then(doResume)
}
}
class Dest extends EE {
constructor () {
super()
this.writable = true
this.readable = false
this.ended = false
this.buffering = false
}
}
class FastDest extends Dest {
write (c) {
if (this.ended) {
throw new Error('write after end in '+this.constructor.name)
}
return true
}
end () {
this.ended = true
return this.emit('finish')
}
}
class SlowDest extends Dest {
write (c) {
if (this.ended) {
throw new Error('write after end in '+this.constructor.name)
}
this.buffering = true
Promise.resolve().then(() => {
this.buffering = false
this.emit('drain')
})
return false
}
end () {
this.ended = true
if (this.buffering) {
this.once('drain', () => this.end())
} else {
Promise.resolve().then(() => this.emit('finish'))
}
return this
}
}
main()
isaacs-minipass-ffdbee1/bench/package-lock.json 0000664 0000000 0000000 00000017346 14414631765 0021755 0 ustar 00root root 0000000 0000000 {
"name": "bench",
"lockfileVersion": 2,
"requires": true,
"packages": {
"": {
"dependencies": {
"@npmcli/promise-spawn": "^2.0.0",
"@web-std/stream": "^1.0.1",
"minipass": "^4.0.1",
"minipass3": "npm:minipass@^3.3.6",
"through2": "^4.0.2"
}
},
"node_modules/@npmcli/promise-spawn": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-2.0.1.tgz",
"integrity": "sha512-7b5KiY/LEpUPqslzOA3v8aZrFmn2z7sLRw3aRDEgRipx0b7vZtQlb9FiMg6azzGuLyLTKuyvwgKPfixuV1tqKA=="
},
"node_modules/@web-std/stream": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/@web-std/stream/-/stream-1.0.1.tgz",
"integrity": "sha512-tsz4Y0WNDgFA5jwLSeV7/UV5rfMIlj0cPsSLVfTihjaVW0OJPd5NxJ3le1B3yLyqqzRpeG5OAfJAADLc4VoGTA==",
"dependencies": {
"web-streams-polyfill": "^3.1.1"
}
},
"node_modules/inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
},
"node_modules/minipass": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-4.0.1.tgz",
"integrity": "sha512-V9esFpNbK0arbN3fm2sxDKqMYgIp7XtVdE4Esj+PE4Qaaxdg1wIw48ITQIOn1sc8xXSmUviVL3cyjMqPlrVkiA==",
"engines": {
"node": ">=8"
}
},
"node_modules/minipass3": {
"name": "minipass",
"version": "3.3.6",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
"dependencies": {
"yallist": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/readable-stream": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
"integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
"dependencies": {
"inherits": "^2.0.3",
"string_decoder": "^1.1.1",
"util-deprecate": "^1.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/safe-buffer": {
"version": "5.2.1",
"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
]
},
"node_modules/string_decoder": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
"integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
"dependencies": {
"safe-buffer": "~5.2.0"
}
},
"node_modules/through2": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/through2/-/through2-4.0.2.tgz",
"integrity": "sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==",
"dependencies": {
"readable-stream": "3"
}
},
"node_modules/util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
},
"node_modules/web-streams-polyfill": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz",
"integrity": "sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==",
"engines": {
"node": ">= 8"
}
},
"node_modules/yallist": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
}
},
"dependencies": {
"@npmcli/promise-spawn": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-2.0.1.tgz",
"integrity": "sha512-7b5KiY/LEpUPqslzOA3v8aZrFmn2z7sLRw3aRDEgRipx0b7vZtQlb9FiMg6azzGuLyLTKuyvwgKPfixuV1tqKA=="
},
"@web-std/stream": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/@web-std/stream/-/stream-1.0.1.tgz",
"integrity": "sha512-tsz4Y0WNDgFA5jwLSeV7/UV5rfMIlj0cPsSLVfTihjaVW0OJPd5NxJ3le1B3yLyqqzRpeG5OAfJAADLc4VoGTA==",
"requires": {
"web-streams-polyfill": "^3.1.1"
}
},
"inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
},
"minipass": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-4.0.1.tgz",
"integrity": "sha512-V9esFpNbK0arbN3fm2sxDKqMYgIp7XtVdE4Esj+PE4Qaaxdg1wIw48ITQIOn1sc8xXSmUviVL3cyjMqPlrVkiA=="
},
"minipass3": {
"version": "npm:minipass@3.3.6",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
"requires": {
"yallist": "^4.0.0"
}
},
"readable-stream": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
"integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
"requires": {
"inherits": "^2.0.3",
"string_decoder": "^1.1.1",
"util-deprecate": "^1.0.1"
}
},
"safe-buffer": {
"version": "5.2.1",
"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
"integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="
},
"string_decoder": {
"version": "1.3.0",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
"integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
"requires": {
"safe-buffer": "~5.2.0"
}
},
"through2": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/through2/-/through2-4.0.2.tgz",
"integrity": "sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==",
"requires": {
"readable-stream": "3"
}
},
"util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
},
"web-streams-polyfill": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz",
"integrity": "sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q=="
},
"yallist": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
}
}
}
isaacs-minipass-ffdbee1/bench/package.json 0000664 0000000 0000000 00000000277 14414631765 0021022 0 ustar 00root root 0000000 0000000 {
"dependencies": {
"@npmcli/promise-spawn": "^2.0.0",
"@web-std/stream": "^1.0.1",
"minipass": "^4.0.1",
"minipass3": "npm:minipass@^3.3.6",
"through2": "^4.0.2"
}
}
isaacs-minipass-ffdbee1/bench/results.json 0000664 0000000 0000000 00000023712 14414631765 0021127 0 ustar 00root root 0000000 0000000 {
"baseline": {
"fast-fast": {
"1": {
"defaults": 3.457208037376404,
"str": 2.72504198551178,
"obj": 1.7911659479141235
},
"20": {
"defaults": 3.5216659903526306,
"str": 2.8304580450057983,
"obj": 1.9337499737739563
}
},
"fast-slow": {
"1": {
"defaults": 3.6649169921875,
"str": 2.8227500319480896,
"obj": 1.837041974067688
},
"20": {
"defaults": 3.6867499947547913,
"str": 2.8203750252723694,
"obj": 1.843874990940094
}
},
"slow-fast": {
"1": {
"defaults": 7.720750033855438,
"str": 7.912416994571686,
"obj": 5.735207974910736
},
"20": {
"defaults": 7.73691600561142,
"str": 8.121457993984222,
"obj": 5.824541985988617
}
},
"slow-slow": {
"1": {
"defaults": 7.953875005245209,
"str": 8.130957961082458,
"obj": 5.873834013938904
},
"20": {
"defaults": 7.795333981513977,
"str": 7.965125024318695,
"obj": 5.926332950592041
}
},
"fast-mixed": {
"1": {
"defaults": 3.6032909750938416,
"str": 2.813916027545929,
"obj": 1.8696250319480896
},
"20": {
"defaults": 3.658999979496002,
"str": 2.7814170122146606,
"obj": 1.925583004951477
}
}
},
"minipass-latest": {
"fast-fast": {
"1": {
"defaults": 9.077916979789734,
"str": 8.231584012508392,
"obj": 5.161791026592255
},
"20": {
"defaults": 57.50104200839996,
"str": 60.6759170293808,
"obj": 29.335416972637177
}
},
"fast-slow": {
"1": {
"defaults": 13.243917047977448,
"str": 12.528708040714264,
"obj": 8.301416993141174
},
"20": {
"defaults": 113.22704195976257,
"str": 122.90191704034805,
"obj": 90.93325001001358
}
},
"slow-fast": {
"1": {
"defaults": 13.003084003925323,
"str": 14.938166975975037,
"obj": 11.414333999156952
},
"20": {
"defaults": 61.18066602945328,
"str": 64.10562497377396,
"obj": 38.920458018779755
}
},
"slow-slow": {
"1": {
"defaults": 20.05416601896286,
"str": 20.129875004291534,
"obj": 17.764832973480225
},
"20": {
"defaults": 118.02620899677277,
"str": 127.68024998903275,
"obj": 98.06762498617172
}
},
"fast-mixed": {
"1": {
"defaults": 13.320167005062103,
"str": 12.768875002861023,
"obj": 8.059417009353638
},
"20": {
"defaults": 112.5936250090599,
"str": 124.21129196882248,
"obj": 90.38358396291733
}
}
},
"minipass-current": {
"fast-fast": {
"1": {
"defaults": 9.264708042144775,
"str": 8.450334012508392,
"obj": 5.452292025089264
},
"20": {
"defaults": 57.367415964603424,
"str": 60.789124965667725,
"obj": 29.535582959651947
}
},
"fast-slow": {
"1": {
"defaults": 13.249125003814697,
"str": 12.391292035579681,
"obj": 8.129916965961456
},
"20": {
"defaults": 113.26587498188019,
"str": 123.52566701173782,
"obj": 91.86566597223282
}
},
"slow-fast": {
"1": {
"defaults": 12.694042026996613,
"str": 14.096707999706268,
"obj": 10.068250000476837
},
"20": {
"defaults": 60.757250010967255,
"str": 63.12616699934006,
"obj": 38.10695803165436
}
},
"slow-slow": {
"1": {
"defaults": 19.248166978359222,
"str": 20.619584023952484,
"obj": 16.414041996002197
},
"20": {
"defaults": 117.51670801639557,
"str": 126.54970902204514,
"obj": 98.01254099607468
}
},
"fast-mixed": {
"1": {
"defaults": 13.076165974140167,
"str": 12.720084011554718,
"obj": 8.123374998569489
},
"20": {
"defaults": 112.91670799255371,
"str": 123.48570799827576,
"obj": 90.44579201936722
}
}
},
"minipass-current-async": {
"fast-fast": {
"1": {
"defaults": 16.43250000476837,
"str": 13.871165990829468,
"obj": 8.61458295583725
},
"20": {
"defaults": 139.22874999046326,
"str": 144.9063749909401,
"obj": 111.47304201126099
}
},
"fast-slow": {
"1": {
"defaults": 31.088625013828278,
"str": 18.790041029453278,
"obj": 11.654124975204468
},
"20": {
"defaults": 153.96329098939896,
"str": 156.56633299589157,
"obj": 118.7431669831276
}
},
"slow-fast": {
"1": {
"defaults": 17.829834043979645,
"str": 16.3703750371933,
"obj": 14.972292006015778
},
"20": {
"defaults": 86.52820897102356,
"str": 87.42279201745987,
"obj": 60.282999992370605
}
},
"slow-slow": {
"1": {
"defaults": 23.863667011260986,
"str": 19.92370903491974,
"obj": 15.069416999816895
},
"20": {
"defaults": 179.31625002622604,
"str": 167.64295798540115,
"obj": 129.6021250486374
}
},
"fast-mixed": {
"1": {
"defaults": 29.05858302116394,
"str": 18.754333972930908,
"obj": 11.174665987491608
},
"20": {
"defaults": 149.65920799970627,
"str": 150.33704203367233,
"obj": 114.88804197311401
}
}
},
"extend-minipass-current": {
"fast-fast": {
"1": {
"defaults": 9.460875034332275,
"str": 8.47537499666214,
"obj": 5.5935840010643005
},
"20": {
"defaults": 57.8164159655571,
"str": 61.474416971206665,
"obj": 30.73370897769928
}
},
"fast-slow": {
"1": {
"defaults": 13.275917053222656,
"str": 12.327417016029358,
"obj": 7.907708048820496
},
"20": {
"defaults": 113.44329100847244,
"str": 123.8350830078125,
"obj": 92.41808301210403
}
},
"slow-fast": {
"1": {
"defaults": 13.410959005355835,
"str": 13.837417006492615,
"obj": 9.979166984558105
},
"20": {
"defaults": 60.897374987602234,
"str": 63.74041599035263,
"obj": 37.77120804786682
}
},
"slow-slow": {
"1": {
"defaults": 19.971417009830475,
"str": 19.92570799589157,
"obj": 16.344209015369415
},
"20": {
"defaults": 116.82750004529953,
"str": 126.22837501764297,
"obj": 97.8376669883728
}
},
"fast-mixed": {
"1": {
"defaults": 13.323291003704071,
"str": 12.51858401298523,
"obj": 8.0310840010643
},
"20": {
"defaults": 113.98325002193451,
"str": 123.57979202270508,
"obj": 91.32770800590515
}
}
},
"core-extend-transform": {
"fast-fast": {
"1": {
"defaults": 24.68624997138977,
"str": 1461.3786249756813,
"obj": 7.051041960716248
},
"20": {
"defaults": 244.83049994707108,
"str": 31516.505042016506,
"obj": 76.24062496423721
}
},
"fast-slow": {
"1": {
"defaults": 32.79583305120468,
"str": 1518.0459590554237,
"obj": 24.080249965190887
},
"20": {
"defaults": 298.33200001716614,
"str": 31888.678416967392,
"obj": 128.65862500667572
}
},
"slow-fast": {
"1": {
"defaults": 31.67483299970627,
"str": 1501.8846249580383,
"obj": 12.088041007518768
},
"20": {
"defaults": 276.8985829949379,
"str": 31534.576792001724,
"obj": 67.52387499809265
}
},
"slow-slow": {
"1": {
"defaults": 39.409457981586456,
"str": 1539.8568329811096,
"obj": 15.961416006088257
},
"20": {
"defaults": 276.86370903253555,
"str": 31828.757624983788,
"obj": 97.51183301210403
}
},
"fast-mixed": {
"1": {
"defaults": 37.11745899915695,
"str": 1512.8160420060158,
"obj": 27.186334013938904
},
"20": {
"defaults": 296.3993339538574,
"str": 32647.16916704178,
"obj": 207.83216696977615
}
}
},
"core-passthrough": {
"fast-fast": {
"1": {
"defaults": 24.925791025161743,
"str": 1474.9310419559479,
"obj": 6.691209018230438
},
"20": {
"defaults": 252.81008398532867,
"str": 31575.084083020687,
"obj": 81.65970802307129
}
},
"fast-slow": {
"1": {
"defaults": 34.01629102230072,
"str": 1567.4065000414848,
"obj": 23.487917006015778
},
"20": {
"defaults": 285.5125409960747,
"str": 31842.6266669631,
"obj": 128.6995000243187
}
},
"slow-fast": {
"1": {
"defaults": 32.36895805597305,
"str": 1499.1462910175323,
"obj": 12.182208955287933
},
"20": {
"defaults": 276.0324159860611,
"str": 31503.869249999523,
"obj": 82.04808300733566
}
},
"slow-slow": {
"1": {
"defaults": 39.12145799398422,
"str": 1487.9831669926643,
"obj": 16.853332996368408
},
"20": {
"defaults": 277.2908329963684,
"str": 32294.136624991894,
"obj": 100.64666700363159
}
},
"fast-mixed": {
"1": {
"defaults": 38.8653330206871,
"str": 1617.7248749732971,
"obj": 27.316959023475647
},
"20": {
"defaults": 308.9617500305176,
"str": 33798.968957960606,
"obj": 139.475791990757
}
}
}
}
isaacs-minipass-ffdbee1/bench/results.tab 0000664 0000000 0000000 00000042122 14414631765 0020720 0 ustar 00root root 0000000 0000000 impl case pipeline type time score
core-passthrough fast-mixed 20 str 32194.21895802021 1
core-extend-transform fast-mixed 20 str 31662.917167007923 1.0167799381279339
core-extend-transform fast-fast 20 str 31438.616124987602 1.0240342268892697
core-extend-transform slow-fast 20 str 31434.417541980743 1.0241710034876501
core-passthrough fast-slow 20 str 31379.71829199791 1.0259562771865294
core-extend-transform fast-slow 20 str 31293.62929201126 1.0287786903080256
core-passthrough fast-fast 20 str 31256.311416983604 1.0300069809429586
core-extend-transform slow-slow 20 str 31088.125959038734 1.035579275522714
core-passthrough slow-fast 20 str 31030.64262497425 1.0374976550472559
core-passthrough slow-slow 20 str 30932.92258399725 1.0407752086986917
core-extend-transform fast-mixed 1 str 1536.4794580340385 20.953237473941545
core-passthrough fast-mixed 1 str 1529.571458041668 21.04786853125445
core-extend-transform fast-slow 1 str 1506.1100000143051 21.375742115592107
core-passthrough fast-slow 1 str 1500.9538750052452 21.449172752165822
core-passthrough slow-slow 1 str 1494.3747920393944 21.543604141022954
core-extend-transform slow-slow 1 str 1489.5767920017242 21.612997148510182
core-extend-transform fast-fast 1 str 1480.325041949749 21.748074271321467
core-extend-transform slow-fast 1 str 1479.3482499718666 21.76243420616644
core-passthrough slow-fast 1 str 1478.332457959652 21.777387613104064
core-passthrough fast-fast 1 str 1464.0363330245018 21.99004097904544
core-extend-transform fast-mixed 20 defaults 300.4728749990463 107.14517561068496
core-passthrough fast-mixed 20 defaults 297.1557089686394 108.34124328204598
core-extend-transform fast-slow 20 defaults 287.9106249809265 111.82018364259051
core-passthrough slow-slow 20 defaults 286.05125004053116 112.5470311822044
core-passthrough fast-slow 20 defaults 285.84004098176956 112.6301929129429
core-extend-transform slow-slow 20 defaults 279.1723749637604 115.32021734671767
core-passthrough slow-fast 20 defaults 278.5909160375595 115.56090706733525
core-extend-transform slow-fast 20 defaults 265.43387496471405 121.28903653424044
core-extend-transform fast-fast 20 defaults 254.3630409836769 126.56799051276553
core-passthrough fast-fast 20 defaults 244.94245797395706 131.4358450728178
core-passthrough fast-mixed 20 obj 208.2157090306282 154.6195486781667
minipass-current-async slow-slow 20 defaults 178.65487498044968 180.20341712781834
minipass-current-async slow-slow 20 str 166.86449998617172 192.9362983779545
minipass-current-async fast-mixed 20 str 148.47591596841812 216.83125339242324
minipass-current-async fast-slow 20 str 148.36312502622604 216.99609624918094
minipass-current-async fast-mixed 20 defaults 146.7203330397606 219.42574891304065
minipass-current-async fast-slow 20 defaults 145.10608303546906 221.8667769438088
minipass-current-async fast-fast 20 str 141.90308398008347 226.87469542620207
minipass-current-async fast-fast 20 defaults 139.32095801830292 231.07951176872314
minipass-current-async slow-slow 20 obj 130.19733399152756 247.27248992759877
core-extend-transform fast-mixed 20 obj 130.17666602134705 247.31174904065244
minipass-v3 fast-mixed 20 str 129.18783402442932 249.20472737341743
core-extend-transform fast-slow 20 obj 128.8274160027504 249.90192271909638
core-passthrough fast-slow 20 obj 128.63429099321365 250.2771128090462
minipass-v3 fast-slow 20 str 128.30966699123383 250.9103149665234
extend-minipass-current slow-slow 20 str 127.44670897722244 252.60926089330428
minipass-current slow-slow 20 str 125.09641599655151 257.35524636379427
minipass-latest slow-slow 20 str 124.78712499141693 257.9931139549419
extend-minipass-current fast-mixed 20 str 123.72312504053116 260.21181527279987
minipass-current fast-mixed 20 str 123.22929102182388 261.25459857038874
minipass-latest fast-slow 20 str 123.11825001239777 261.49022549279505
extend-minipass-current fast-slow 20 str 122.84945797920227 262.0623606126981
minipass-v3 slow-slow 20 str 122.67037498950958 262.44493799561116
minipass-current fast-slow 20 str 122.3718329668045 263.0852065994096
minipass-latest fast-mixed 20 str 122.23299998044968 263.3840203804983
extend-minipass-current slow-slow 20 defaults 118.21458297967911 272.3371190469313
minipass-v3 fast-mixed 20 defaults 116.30437499284744 276.81004227055183
minipass-v3 fast-slow 20 defaults 115.99166697263718 277.55630898566994
minipass-latest slow-slow 20 defaults 115.9765830039978 277.5924080890575
minipass-current slow-slow 20 defaults 115.59104204177856 278.51828644631576
minipass-current-async fast-mixed 20 obj 114.99945896863937 279.9510471331839
extend-minipass-current fast-mixed 20 defaults 114.66458302736282 280.76863934818994
extend-minipass-current fast-slow 20 defaults 113.52045798301697 283.59838860795094
minipass-latest fast-slow 20 defaults 113.0157499909401 284.8648879523523
minipass-current fast-mixed 20 defaults 112.53495800495148 286.0819387039153
minipass-current-async fast-slow 20 obj 112.49658298492432 286.179527446932
minipass-current fast-slow 20 defaults 112.14308398962021 287.0816265495254
minipass-latest fast-mixed 20 defaults 112.09566700458527 287.2030634038986
minipass-v3 slow-slow 20 defaults 111.40716600418091 288.9779904895168
minipass-current-async fast-fast 20 obj 107.51195901632309 299.44779401826634
core-extend-transform slow-slow 20 obj 102.80712503194809 313.15163173773817
minipass-latest slow-slow 20 obj 100.68733298778534 319.7444802905424
extend-minipass-current slow-slow 20 obj 98.42250001430511 327.1022271669687
minipass-current slow-slow 20 obj 97.22012501955032 331.14768111588177
minipass-v3 fast-mixed 20 obj 96.91087502241135 332.20439863508676
minipass-v3 fast-slow 20 obj 95.9580420255661 335.50308320633206
minipass-v3 slow-slow 20 obj 93.60766696929932 343.92715896422254
minipass-current fast-slow 20 obj 92.39629197120667 348.43626590613457
extend-minipass-current fast-mixed 20 obj 92.14691698551178 349.37923059414015
extend-minipass-current fast-slow 20 obj 91.31158298254013 352.5754116449403
minipass-latest fast-slow 20 obj 91.26908296346664 352.7395905895863
minipass-current fast-mixed 20 obj 90.61699998378754 355.2779165474485
minipass-latest fast-mixed 20 obj 90.01541703939438 357.6522779862334
minipass-current-async slow-fast 20 str 87.13433396816254 369.4779944009608
minipass-current-async slow-fast 20 defaults 84.68783301115036 380.1516441420975
core-passthrough slow-slow 20 obj 82.41066700220108 390.6559688099642
core-extend-transform slow-fast 20 obj 81.58758401870728 394.59703759138614
core-extend-transform fast-fast 20 obj 77.12849998474121 417.41015272421197
core-passthrough fast-fast 20 obj 75.07454198598862 428.83004153430215
core-passthrough slow-fast 20 obj 67.46312499046326 477.2120912360828
minipass-v3 slow-fast 20 str 64.24833297729492 501.0903390971639
extend-minipass-current slow-fast 20 str 63.395416021347046 507.8319692259689
minipass-latest slow-fast 20 str 63.34337502717972 508.2491885569113
minipass-current slow-fast 20 str 61.93591696023941 519.7988588541882
extend-minipass-current slow-fast 20 defaults 61.072625041007996 527.1464741592979
minipass-v3 slow-fast 20 defaults 61.014499962329865 527.6486569241214
extend-minipass-current fast-fast 20 str 60.99250000715256 527.8389794523066
minipass-v3 fast-fast 20 str 60.624458968639374 531.0434023778104
minipass-latest slow-fast 20 defaults 60.432124972343445 532.7335249712596
minipass-current-async slow-fast 20 obj 60.39887499809265 533.0267982480945
minipass-current fast-fast 20 str 60.32475000619888 533.681763367639
minipass-latest fast-fast 20 str 59.831041038036346 538.0855555823173
minipass-current slow-fast 20 defaults 59.585207998752594 540.3055563503981
minipass-v3 fast-fast 20 defaults 57.91070902347565 555.9285924986591
minipass-current fast-fast 20 defaults 57.41624999046326 560.7161555024512
extend-minipass-current fast-fast 20 defaults 57.24487501382828 562.3947811964523
minipass-latest fast-fast 20 defaults 57.19783401489258 562.8573094155596
core-extend-transform slow-slow 1 defaults 39.295709013938904 819.2807755829099
core-passthrough fast-mixed 1 defaults 39.00841599702835 825.3146951794391
core-passthrough slow-slow 1 defaults 38.971583008766174 826.094720113846
core-extend-transform fast-mixed 1 defaults 38.514332950115204 835.9022860325538
extend-minipass-current slow-fast 20 obj 37.77045798301697 852.3650672304782
minipass-latest slow-fast 20 obj 37.68408399820328 854.3187346561266
minipass-v3 slow-fast 20 obj 37.54316699504852 857.5253910323077
minipass-current slow-fast 20 obj 35.97454100847244 894.9167398810753
core-passthrough fast-slow 1 defaults 33.410207986831665 963.6042664178946
core-extend-transform fast-slow 1 defaults 33.0645409822464 973.6780853938515
core-passthrough slow-fast 1 defaults 32.13895797729492 1001.7194390920928
core-extend-transform slow-fast 1 defaults 31.692166030406952 1015.8415466816489
minipass-current-async fast-mixed 1 defaults 30.16175001859665 1067.385643676856
extend-minipass-current fast-fast 20 obj 30.03591698408127 1071.857369131857
minipass-v3 fast-fast 20 obj 29.65308302640915 1085.695505231207
minipass-current fast-fast 20 obj 29.545875012874603 1089.6349809911399
minipass-latest fast-fast 20 obj 29.262917041778564 1100.1712136919446
minipass-current-async fast-slow 1 defaults 27.98837500810623 1150.2711017947931
core-passthrough fast-mixed 1 obj 27.366249978542328 1176.4205539035659
core-extend-transform fast-mixed 1 obj 27.35904198884964 1176.730492651796
core-passthrough fast-fast 1 defaults 25.10208296775818 1282.5317723382307
core-extend-transform fast-fast 1 defaults 24.934708952903748 1291.1407555960689
core-extend-transform fast-slow 1 obj 23.59537500143051 1364.429213609378
core-passthrough fast-slow 1 obj 23.252583026885986 1384.543769644662
minipass-current-async slow-slow 1 defaults 21.74616700410843 1480.4548751942293
minipass-current slow-slow 1 defaults 20.05220800638199 1605.5198982463078
minipass-v3 slow-slow 1 defaults 19.803040981292725 1625.720968230739
minipass-current slow-slow 1 str 19.6290420293808 1640.1319488659622
minipass-current-async fast-mixed 1 str 19.623667001724243 1640.5811898047114
extend-minipass-current slow-slow 1 defaults 19.4930419921875 1651.5749040566957
minipass-v3 slow-slow 1 str 19.487249970436096 1652.065786956175
minipass-latest slow-slow 1 str 19.38154101371765 1661.0763269666816
extend-minipass-current slow-slow 1 str 19.182792007923126 1678.2864008911183
minipass-latest slow-slow 1 defaults 19.147916972637177 1681.3431457858578
minipass-current-async slow-slow 1 str 18.65733301639557 1725.5531071739344
minipass-current-async fast-slow 1 str 17.754124999046326 1813.3374052367853
minipass-v3 slow-slow 1 obj 16.86175000667572 1909.304724911366
extend-minipass-current slow-slow 1 obj 16.5867919921875 1940.9551270181673
minipass-latest slow-slow 1 obj 16.095083951950073 2000.2516951220732
minipass-current slow-slow 1 obj 15.730000019073486 2046.676345771326
core-extend-transform slow-slow 1 obj 15.700709044933319 2050.4945901414185
core-passthrough slow-slow 1 obj 15.394749999046326 2091.2466236875935
minipass-current-async fast-fast 1 defaults 15.126042008399963 2128.3967702946848
extend-minipass-current fast-slow 1 defaults 14.671917021274567 2194.2748797814193
minipass-current-async slow-slow 1 obj 14.652042031288147 2197.2513380232112
minipass-current-async slow-fast 1 defaults 14.532292008399963 2215.3572842749986
minipass-current-async slow-fast 1 str 14.49212497472763 2221.497469429964
minipass-latest slow-fast 1 str 14.473416030406952 2224.3690701893684
minipass-current-async fast-fast 1 str 14.437624990940094 2229.883306861256
extend-minipass-current slow-fast 1 str 14.416042029857635 2233.2217741417157
minipass-current-async slow-fast 1 obj 14.286958992481232 2253.3989895934465
minipass-v3 fast-mixed 1 defaults 14.111000001430511 2281.4980479594997
minipass-v3 fast-mixed 1 str 13.970665991306305 2304.415478693292
minipass-current slow-fast 1 str 13.831874966621399 2327.538315355668
extend-minipass-current fast-slow 1 str 13.739666998386383 2343.1586050667147
minipass-v3 slow-fast 1 str 13.598625004291534 2367.4613387647773
minipass-current fast-mixed 1 defaults 13.566124975681305 2373.1330070843155
minipass-v3 slow-fast 1 defaults 13.550792038440704 2375.818244918237
extend-minipass-current fast-mixed 1 defaults 13.512374997138977 2382.5729351677114
minipass-latest fast-mixed 1 defaults 13.397624969482422 2402.9795602842537
minipass-current slow-fast 1 defaults 13.379290997982025 2406.2724222737966
extend-minipass-current slow-fast 1 defaults 13.307500004768372 2419.253725078663
minipass-v3 fast-slow 1 defaults 13.282292008399963 2423.8451419122543
minipass-latest fast-slow 1 defaults 13.002458989620209 2476.0100365416015
minipass-current fast-slow 1 defaults 12.99433296918869 2477.5584121445117
minipass-latest slow-fast 1 defaults 12.991750001907349 2478.0509903049015
minipass-v3 fast-slow 1 str 12.831542015075684 2508.990651333679
minipass-current fast-slow 1 str 12.603249967098236 2554.4378665872473
extend-minipass-current fast-mixed 1 str 12.540499985218048 2567.2197277595574
core-extend-transform slow-fast 1 obj 12.53549998998642 2568.2437065723366
minipass-latest fast-mixed 1 str 12.475832998752594 2580.5266038138834
core-passthrough slow-fast 1 obj 12.470874965190887 2581.552541251657
minipass-current-async fast-mixed 1 obj 12.403167009353638 2595.6450424106592
minipass-latest fast-slow 1 str 12.386833012104034 2599.0678106793725
minipass-current fast-mixed 1 str 12.383000016212463 2599.872318167639
minipass-current-async fast-slow 1 obj 11.067457973957062 2908.9081732929753
minipass-current slow-fast 1 obj 10.078208029270172 3194.4388193335994
minipass-latest slow-fast 1 obj 9.93445897102356 3240.661524892603
extend-minipass-current slow-fast 1 obj 9.894125044345856 3253.872253860191
minipass-v3 fast-fast 1 defaults 9.453750014305115 3405.444284998539
extend-minipass-current fast-fast 1 defaults 9.391750037670135 3427.92544828065
minipass-current fast-fast 1 defaults 9.214917004108429 3493.706882402366
minipass-latest fast-fast 1 defaults 9.20908397436142 3495.9197948081082
extend-minipass-current fast-slow 1 obj 8.62345802783966 3733.3305101138726
minipass-current-async fast-fast 1 obj 8.553624987602234 3763.8099641594113
minipass-v3 fast-fast 1 str 8.397374987602234 3833.8431957071466
minipass-v3 fast-mixed 1 obj 8.385917007923126 3839.0815133995106
extend-minipass-current fast-fast 1 str 8.311500012874603 3873.454720345427
minipass-latest fast-fast 1 str 8.295958995819092 3880.7109550860973
minipass-v3 fast-slow 1 obj 8.239207983016968 3907.440985150564
minipass-current fast-fast 1 str 8.199416995048523 3926.40342325091
baseline slow-fast 1 str 8.131583988666534 3959.1571584197104
extend-minipass-current fast-mixed 1 obj 8.06879198551178 3989.967645197415
minipass-latest fast-mixed 1 obj 8.041584014892578 4003.46733907129
baseline slow-fast 20 str 8.019291043281555 4014.596650035798
minipass-current fast-mixed 1 obj 7.925790965557098 4061.9566044481594
baseline slow-fast 20 defaults 7.852207958698273 4100.021182240482
minipass-current fast-slow 1 obj 7.787625014781952 4134.02274723183
baseline slow-slow 20 str 7.757792055606842 4149.920328781211
baseline slow-slow 1 defaults 7.7466660141944885 4155.880594184597
baseline slow-slow 1 str 7.729292035102844 4165.222223692554
minipass-latest fast-slow 1 obj 7.695333003997803 4183.60309310786
baseline slow-fast 1 defaults 7.692415952682495 4185.189562817837
baseline slow-slow 20 defaults 7.534042000770569 4273.166907581274
minipass-v3 slow-fast 1 obj 7.527709007263184 4276.761884254201
core-extend-transform fast-fast 1 obj 6.816040992736816 4723.301839341403
core-passthrough fast-fast 1 obj 6.7474170327186584 4771.339729248744
baseline slow-fast 20 obj 5.8379170298576355 5514.675661432842
baseline slow-slow 20 obj 5.7709580063819885 5578.661103133528
baseline slow-fast 1 obj 5.750458002090454 5598.548662787677
baseline slow-slow 1 obj 5.734125018119812 5614.495473378521
minipass-v3 fast-fast 1 obj 5.251791000366211 6130.1409282614795
minipass-latest fast-fast 1 obj 5.196291983127594 6195.613922880993
extend-minipass-current fast-fast 1 obj 5.157707989215851 6241.962326160082
minipass-current fast-fast 1 obj 5.105875015258789 6305.328442589866
baseline fast-mixed 20 defaults 3.7309159636497498 8629.038893314117
baseline fast-mixed 1 defaults 3.710582971572876 8676.323694864968
baseline fast-slow 20 defaults 3.6982919573783875 8705.158848746427
baseline fast-slow 1 defaults 3.5882920026779175 8972.01758775314
baseline fast-fast 20 defaults 3.4377079606056213 9365.024407817513
baseline fast-fast 1 defaults 3.407458007335663 9448.163084830883
baseline fast-slow 1 str 2.9291670322418213 10990.91263955014
baseline fast-slow 20 str 2.8588340282440186 11261.310954030747
baseline fast-fast 20 str 2.8121660351753235 11448.19280061217
baseline fast-fast 1 str 2.7500839829444885 11706.631200240718
baseline fast-mixed 20 str 2.734583020210266 11772.99014880329
baseline fast-mixed 1 str 2.706125020980835 11896.796603414656
baseline fast-fast 1 obj 2.019791007041931 15939.381275476613
baseline fast-slow 20 obj 2.010374963283539 16014.03695628874
baseline fast-fast 20 obj 1.9334579706192017 16651.10876328479
baseline fast-mixed 1 obj 1.8798329830169678 17126.106015201043
baseline fast-slow 1 obj 1.868624985218048 17228.8282628649
baseline fast-mixed 20 obj 1.8174999952316284 17713.46302199977
isaacs-minipass-ffdbee1/bench/results/ 0000775 0000000 0000000 00000000000 14414631765 0020227 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/bench/results/baseline-fast-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0024726 0 ustar 00root root 0000000 0000000 {
"defaults": 3.407458007335663,
"str": 2.7500839829444885,
"obj": 2.019791007041931
} isaacs-minipass-ffdbee1/bench/results/baseline-fast-fast-20.json 0000664 0000000 0000000 00000000136 14414631765 0025011 0 ustar 00root root 0000000 0000000 {
"defaults": 3.4377079606056213,
"str": 2.8121660351753235,
"obj": 1.9334579706192017
} isaacs-minipass-ffdbee1/bench/results/baseline-fast-mixed-1.json 0000664 0000000 0000000 00000000134 14414631765 0025077 0 ustar 00root root 0000000 0000000 {
"defaults": 3.710582971572876,
"str": 2.706125020980835,
"obj": 1.8798329830169678
} isaacs-minipass-ffdbee1/bench/results/baseline-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0025161 0 ustar 00root root 0000000 0000000 {
"defaults": 3.7309159636497498,
"str": 2.734583020210266,
"obj": 1.8174999952316284
} isaacs-minipass-ffdbee1/bench/results/baseline-fast-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0024756 0 ustar 00root root 0000000 0000000 {
"defaults": 3.5882920026779175,
"str": 2.9291670322418213,
"obj": 1.868624985218048
} isaacs-minipass-ffdbee1/bench/results/baseline-fast-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0025037 0 ustar 00root root 0000000 0000000 {
"defaults": 3.6982919573783875,
"str": 2.8588340282440186,
"obj": 2.010374963283539
} isaacs-minipass-ffdbee1/bench/results/baseline-slow-fast-1.json 0000664 0000000 0000000 00000000133 14414631765 0024754 0 ustar 00root root 0000000 0000000 {
"defaults": 7.692415952682495,
"str": 8.131583988666534,
"obj": 5.750458002090454
} isaacs-minipass-ffdbee1/bench/results/baseline-slow-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0025036 0 ustar 00root root 0000000 0000000 {
"defaults": 7.852207958698273,
"str": 8.019291043281555,
"obj": 5.8379170298576355
} isaacs-minipass-ffdbee1/bench/results/baseline-slow-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0025004 0 ustar 00root root 0000000 0000000 {
"defaults": 7.7466660141944885,
"str": 7.729292035102844,
"obj": 5.734125018119812
} isaacs-minipass-ffdbee1/bench/results/baseline-slow-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0025065 0 ustar 00root root 0000000 0000000 {
"defaults": 7.534042000770569,
"str": 7.757792055606842,
"obj": 5.7709580063819885
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0027372 0 ustar 00root root 0000000 0000000 {
"defaults": 24.934708952903748,
"str": 1480.325041949749,
"obj": 6.816040992736816
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0027453 0 ustar 00root root 0000000 0000000 {
"defaults": 254.3630409836769,
"str": 31438.616124987602,
"obj": 77.12849998474121
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-mixed-1.json 0000664 0000000 0000000 00000000135 14414631765 0027544 0 ustar 00root root 0000000 0000000 {
"defaults": 38.514332950115204,
"str": 1536.4794580340385,
"obj": 27.35904198884964
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0027625 0 ustar 00root root 0000000 0000000 {
"defaults": 300.4728749990463,
"str": 31662.917167007923,
"obj": 130.17666602134705
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-slow-1.json 0000664 0000000 0000000 00000000133 14414631765 0027420 0 ustar 00root root 0000000 0000000 {
"defaults": 33.0645409822464,
"str": 1506.1100000143051,
"obj": 23.59537500143051
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-slow-20.json 0000664 0000000 0000000 00000000133 14414631765 0027501 0 ustar 00root root 0000000 0000000 {
"defaults": 287.9106249809265,
"str": 31293.62929201126,
"obj": 128.8274160027504
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0027422 0 ustar 00root root 0000000 0000000 {
"defaults": 31.692166030406952,
"str": 1479.3482499718666,
"obj": 12.53549998998642
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-fast-20.json 0000664 0000000 0000000 00000000135 14414631765 0027503 0 ustar 00root root 0000000 0000000 {
"defaults": 265.43387496471405,
"str": 31434.417541980743,
"obj": 81.58758401870728
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-slow-1.json 0000664 0000000 0000000 00000000136 14414631765 0027452 0 ustar 00root root 0000000 0000000 {
"defaults": 39.295709013938904,
"str": 1489.5767920017242,
"obj": 15.700709044933319
} isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0027532 0 ustar 00root root 0000000 0000000 {
"defaults": 279.1723749637604,
"str": 31088.125959038734,
"obj": 102.80712503194809
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0026442 0 ustar 00root root 0000000 0000000 {
"defaults": 25.10208296775818,
"str": 1464.0363330245018,
"obj": 6.7474170327186584
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-100.json 0000664 0000000 0000000 00000000035 14414631765 0026601 0 ustar 00root root 0000000 0000000 {
"obj": 407.321750164032
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-20.json 0000664 0000000 0000000 00000000135 14414631765 0026523 0 ustar 00root root 0000000 0000000 {
"defaults": 244.94245797395706,
"str": 31256.311416983604,
"obj": 75.07454198598862
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-1.json 0000664 0000000 0000000 00000000134 14414631765 0026612 0 ustar 00root root 0000000 0000000 {
"defaults": 39.00841599702835,
"str": 1529.571458041668,
"obj": 27.366249978542328
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-100.json 0000664 0000000 0000000 00000000036 14414631765 0026753 0 ustar 00root root 0000000 0000000 {
"obj": 722.3131666183472
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-20.json 0000664 0000000 0000000 00000000133 14414631765 0026672 0 ustar 00root root 0000000 0000000 {
"defaults": 297.1557089686394,
"str": 32194.21895802021,
"obj": 208.2157090306282
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-1.json 0000664 0000000 0000000 00000000136 14414631765 0026472 0 ustar 00root root 0000000 0000000 {
"defaults": 33.410207986831665,
"str": 1500.9538750052452,
"obj": 23.252583026885986
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-100.json 0000664 0000000 0000000 00000000036 14414631765 0026631 0 ustar 00root root 0000000 0000000 {
"obj": 713.4662504196167
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0026552 0 ustar 00root root 0000000 0000000 {
"defaults": 285.84004098176956,
"str": 31379.71829199791,
"obj": 128.63429099321365
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-mixed-1.json 0000664 0000000 0000000 00000000017 14414631765 0025657 0 ustar 00root root 0000000 0000000 {
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0026470 0 ustar 00root root 0000000 0000000 {
"defaults": 32.13895797729492,
"str": 1478.332457959652,
"obj": 12.470874965190887
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-fast-20.json 0000664 0000000 0000000 00000000133 14414631765 0026550 0 ustar 00root root 0000000 0000000 {
"defaults": 278.5909160375595,
"str": 31030.64262497425,
"obj": 67.46312499046326
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-1.json 0000664 0000000 0000000 00000000136 14414631765 0026521 0 ustar 00root root 0000000 0000000 {
"defaults": 38.971583008766174,
"str": 1494.3747920393944,
"obj": 15.394749999046326
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-100.json 0000664 0000000 0000000 00000000037 14414631765 0026661 0 ustar 00root root 0000000 0000000 {
"obj": 423.62200021743774
} isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0026600 0 ustar 00root root 0000000 0000000 {
"defaults": 286.05125004053116,
"str": 30932.92258399725,
"obj": 82.41066700220108
} isaacs-minipass-ffdbee1/bench/results/core-transform-fast-fast-20.json 0000664 0000000 0000000 00000000207 14414631765 0026167 0 ustar 00root root 0000000 0000000 {
"obj": {
"code": "MODULE_NOT_FOUND",
"requireStack": [
"/Users/isaacs/dev/isaacs/minipass/bench/index.js"
]
}
} isaacs-minipass-ffdbee1/bench/results/extend-core-passthroughfast-fast-20-obj.json 0000664 0000000 0000000 00000000626 14414631765 0030510 0 ustar 00root root 0000000 0000000 {
"defaults": {
"code": "MODULE_NOT_FOUND",
"requireStack": [
"/Users/isaacs/dev/isaacs/minipass/bench/index.js"
]
},
"str": {
"code": "MODULE_NOT_FOUND",
"requireStack": [
"/Users/isaacs/dev/isaacs/minipass/bench/index.js"
]
},
"obj": {
"code": "MODULE_NOT_FOUND",
"requireStack": [
"/Users/isaacs/dev/isaacs/minipass/bench/index.js"
]
}
} isaacs-minipass-ffdbee1/bench/results/extend-core-transform-fast-fast-20.json 0000664 0000000 0000000 00000000207 14414631765 0027454 0 ustar 00root root 0000000 0000000 {
"obj": {
"code": "MODULE_NOT_FOUND",
"requireStack": [
"/Users/isaacs/dev/isaacs/minipass/bench/index.js"
]
}
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-fast-1.json 0000664 0000000 0000000 00000000133 14414631765 0027733 0 ustar 00root root 0000000 0000000 {
"defaults": 9.391750037670135,
"str": 8.311500012874603,
"obj": 5.157707989215851
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-fast-20.json 0000664 0000000 0000000 00000000133 14414631765 0030014 0 ustar 00root root 0000000 0000000 {
"defaults": 57.24487501382828,
"str": 60.99250000715256,
"obj": 30.03591698408127
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-mixed-1.json 0000664 0000000 0000000 00000000134 14414631765 0030105 0 ustar 00root root 0000000 0000000 {
"defaults": 13.512374997138977,
"str": 12.540499985218048,
"obj": 8.06879198551178
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0030167 0 ustar 00root root 0000000 0000000 {
"defaults": 114.66458302736282,
"str": 123.72312504053116,
"obj": 92.14691698551178
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0027763 0 ustar 00root root 0000000 0000000 {
"defaults": 14.671917021274567,
"str": 13.739666998386383,
"obj": 8.62345802783966
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0030045 0 ustar 00root root 0000000 0000000 {
"defaults": 113.52045798301697,
"str": 122.84945797920227,
"obj": 91.31158298254013
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0027764 0 ustar 00root root 0000000 0000000 {
"defaults": 13.307500004768372,
"str": 14.416042029857635,
"obj": 9.894125044345856
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-fast-20.json 0000664 0000000 0000000 00000000135 14414631765 0030045 0 ustar 00root root 0000000 0000000 {
"defaults": 61.072625041007996,
"str": 63.395416021347046,
"obj": 37.77045798301697
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-slow-1.json 0000664 0000000 0000000 00000000132 14414631765 0030010 0 ustar 00root root 0000000 0000000 {
"defaults": 19.4930419921875,
"str": 19.182792007923126,
"obj": 16.5867919921875
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0030074 0 ustar 00root root 0000000 0000000 {
"defaults": 118.21458297967911,
"str": 127.44670897722244,
"obj": 98.42250001430511
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0026254 0 ustar 00root root 0000000 0000000 {
"defaults": 12.583540916442871,
"str": 12.105957984924316,
"obj": 9.06024980545044
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-fast-20.json 0000664 0000000 0000000 00000000136 14414631765 0026337 0 ustar 00root root 0000000 0000000 {
"defaults": 126.18258285522461,
"str": 128.73254108428955,
"obj": 105.26249980926514
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-mixed-1.json 0000664 0000000 0000000 00000000134 14414631765 0026425 0 ustar 00root root 0000000 0000000 {
"defaults": 21.804834365844727,
"str": 20.67766571044922,
"obj": 18.17937469482422
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-mixed-20.json 0000664 0000000 0000000 00000000134 14414631765 0026506 0 ustar 00root root 0000000 0000000 {
"defaults": 284.1690001487732,
"str": 296.5096673965454,
"obj": 267.44170808792114
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0026303 0 ustar 00root root 0000000 0000000 {
"defaults": 20.50854206085205,
"str": 20.54229211807251,
"obj": 17.428500175476074
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0026364 0 ustar 00root root 0000000 0000000 {
"defaults": 276.1806254386902,
"str": 293.58387517929077,
"obj": 276.8616247177124
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0026304 0 ustar 00root root 0000000 0000000 {
"defaults": 16.363709449768066,
"str": 15.237417221069336,
"obj": 12.49150037765503
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-fast-20.json 0000664 0000000 0000000 00000000136 14414631765 0026366 0 ustar 00root root 0000000 0000000 {
"defaults": 125.16524982452393,
"str": 128.87895822525024,
"obj": 110.46454191207886
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0026333 0 ustar 00root root 0000000 0000000 {
"defaults": 27.080874919891357,
"str": 26.84391689300537,
"obj": 26.955999851226807
} isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-slow-20.json 0000664 0000000 0000000 00000000133 14414631765 0026412 0 ustar 00root root 0000000 0000000 {
"defaults": 274.1978340148926,
"str": 294.1859998703003,
"obj": 277.8759160041809
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0026174 0 ustar 00root root 0000000 0000000 {
"defaults": 24.68295907974243,
"str": 1409.8773746490479,
"obj": 21.667250156402588
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0026254 0 ustar 00root root 0000000 0000000 {
"defaults": 289.5474581718445,
"str": 1649.342541694641,
"obj": 235.78379201889038
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-mixed-1.json 0000664 0000000 0000000 00000000136 14414631765 0026346 0 ustar 00root root 0000000 0000000 {
"defaults": 26.036499977111816,
"str": 1378.7794170379639,
"obj": 16.916458129882812
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-mixed-20.json 0000664 0000000 0000000 00000000133 14414631765 0026424 0 ustar 00root root 0000000 0000000 {
"defaults": 242.00229215621948,
"str": 1575.54691696167,
"obj": 149.2092089653015
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-slow-1.json 0000664 0000000 0000000 00000000136 14414631765 0026224 0 ustar 00root root 0000000 0000000 {
"defaults": 24.177124977111816,
"str": 1384.6977500915527,
"obj": 16.081832885742188
} isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-slow-20.json 0000664 0000000 0000000 00000000136 14414631765 0026305 0 ustar 00root root 0000000 0000000 {
"defaults": 239.68829202651978,
"str": 1595.5013337135315,
"obj": 154.00483322143555
} isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0026223 0 ustar 00root root 0000000 0000000 {
"defaults": 30.115875244140625,
"str": 1383.3513751029968,
"obj": 32.43433332443237
} isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-fast-20.json 0000664 0000000 0000000 00000000133 14414631765 0026302 0 ustar 00root root 0000000 0000000 {
"defaults": 312.4208331108093,
"str": 1739.513334274292,
"obj": 239.5954999923706
} isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0026251 0 ustar 00root root 0000000 0000000 {
"defaults": 35.7008752822876,
"str": 1406.1673340797424,
"obj": 37.660542011260986
} isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-slow-20.json 0000664 0000000 0000000 00000000136 14414631765 0026334 0 ustar 00root root 0000000 0000000 {
"defaults": 298.22725009918213,
"str": 1673.6373329162598,
"obj": 248.40116691589355
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0027563 0 ustar 00root root 0000000 0000000 {
"defaults": 15.126042008399963,
"str": 14.437624990940094,
"obj": 8.553624987602234
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-fast-20.json 0000664 0000000 0000000 00000000136 14414631765 0027645 0 ustar 00root root 0000000 0000000 {
"defaults": 139.32095801830292,
"str": 141.90308398008347,
"obj": 107.51195901632309
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-mixed-1.json 0000664 0000000 0000000 00000000135 14414631765 0027734 0 ustar 00root root 0000000 0000000 {
"defaults": 30.16175001859665,
"str": 19.623667001724243,
"obj": 12.403167009353638
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0030015 0 ustar 00root root 0000000 0000000 {
"defaults": 146.7203330397606,
"str": 148.47591596841812,
"obj": 114.99945896863937
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0027612 0 ustar 00root root 0000000 0000000 {
"defaults": 27.98837500810623,
"str": 17.754124999046326,
"obj": 11.067457973957062
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-slow-20.json 0000664 0000000 0000000 00000000136 14414631765 0027674 0 ustar 00root root 0000000 0000000 {
"defaults": 145.10608303546906,
"str": 148.36312502622604,
"obj": 112.49658298492432
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0027612 0 ustar 00root root 0000000 0000000 {
"defaults": 14.532292008399963,
"str": 14.49212497472763,
"obj": 14.286958992481232
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-fast-20.json 0000664 0000000 0000000 00000000133 14414631765 0027671 0 ustar 00root root 0000000 0000000 {
"defaults": 84.68783301115036,
"str": 87.13433396816254,
"obj": 60.39887499809265
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0027640 0 ustar 00root root 0000000 0000000 {
"defaults": 21.74616700410843,
"str": 18.65733301639557,
"obj": 14.652042031288147
} isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-slow-20.json 0000664 0000000 0000000 00000000136 14414631765 0027723 0 ustar 00root root 0000000 0000000 {
"defaults": 178.65487498044968,
"str": 166.86449998617172,
"obj": 130.19733399152756
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-fast-1.json 0000664 0000000 0000000 00000000133 14414631765 0026446 0 ustar 00root root 0000000 0000000 {
"defaults": 9.214917004108429,
"str": 8.199416995048523,
"obj": 5.105875015258789
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0026530 0 ustar 00root root 0000000 0000000 {
"defaults": 57.41624999046326,
"str": 60.32475000619888,
"obj": 29.545875012874603
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-1.json 0000664 0000000 0000000 00000000135 14414631765 0026621 0 ustar 00root root 0000000 0000000 {
"defaults": 13.566124975681305,
"str": 12.383000016212463,
"obj": 7.925790965557098
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-100.json 0000664 0000000 0000000 00000000036 14414631765 0026761 0 ustar 00root root 0000000 0000000 {
"obj": 676.8444590568542
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0026702 0 ustar 00root root 0000000 0000000 {
"defaults": 112.53495800495148,
"str": 123.22929102182388,
"obj": 90.61699998378754
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0026476 0 ustar 00root root 0000000 0000000 {
"defaults": 12.99433296918869,
"str": 12.603249967098236,
"obj": 7.787625014781952
} isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0026557 0 ustar 00root root 0000000 0000000 {
"defaults": 112.14308398962021,
"str": 122.3718329668045,
"obj": 92.39629197120667
} isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-fast-1.json 0000664 0000000 0000000 00000000136 14414631765 0026500 0 ustar 00root root 0000000 0000000 {
"defaults": 13.379290997982025,
"str": 13.831874966621399,
"obj": 10.078208029270172
} isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0026557 0 ustar 00root root 0000000 0000000 {
"defaults": 59.585207998752594,
"str": 61.93591696023941,
"obj": 35.97454100847244
} isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-slow-1.json 0000664 0000000 0000000 00000000133 14414631765 0026524 0 ustar 00root root 0000000 0000000 {
"defaults": 20.05220800638199,
"str": 19.6290420293808,
"obj": 15.730000019073486
} isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0026607 0 ustar 00root root 0000000 0000000 {
"defaults": 115.59104204177856,
"str": 125.09641599655151,
"obj": 97.22012501955032
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-fast-1.json 0000664 0000000 0000000 00000000132 14414631765 0026257 0 ustar 00root root 0000000 0000000 {
"defaults": 9.20908397436142,
"str": 8.295958995819092,
"obj": 5.196291983127594
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-fast-20.json 0000664 0000000 0000000 00000000135 14414631765 0026343 0 ustar 00root root 0000000 0000000 {
"defaults": 57.19783401489258,
"str": 59.831041038036346,
"obj": 29.262917041778564
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-mixed-1.json 0000664 0000000 0000000 00000000135 14414631765 0026433 0 ustar 00root root 0000000 0000000 {
"defaults": 13.397624969482422,
"str": 12.475832998752594,
"obj": 8.041584014892578
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0026514 0 ustar 00root root 0000000 0000000 {
"defaults": 112.09566700458527,
"str": 122.23299998044968,
"obj": 90.01541703939438
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0026311 0 ustar 00root root 0000000 0000000 {
"defaults": 13.002458989620209,
"str": 12.386833012104034,
"obj": 7.695333003997803
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0026371 0 ustar 00root root 0000000 0000000 {
"defaults": 113.0157499909401,
"str": 123.11825001239777,
"obj": 91.26908296346664
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0026310 0 ustar 00root root 0000000 0000000 {
"defaults": 12.991750001907349,
"str": 14.473416030406952,
"obj": 9.93445897102356
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0026371 0 ustar 00root root 0000000 0000000 {
"defaults": 60.432124972343445,
"str": 63.34337502717972,
"obj": 37.68408399820328
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0026340 0 ustar 00root root 0000000 0000000 {
"defaults": 19.147916972637177,
"str": 19.38154101371765,
"obj": 16.095083951950073
} isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0026421 0 ustar 00root root 0000000 0000000 {
"defaults": 115.9765830039978,
"str": 124.78712499141693,
"obj": 100.68733298778534
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-fast-1.json 0000664 0000000 0000000 00000000133 14414631765 0025314 0 ustar 00root root 0000000 0000000 {
"defaults": 9.453750014305115,
"str": 8.397374987602234,
"obj": 5.251791000366211
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0025376 0 ustar 00root root 0000000 0000000 {
"defaults": 57.91070902347565,
"str": 60.624458968639374,
"obj": 29.65308302640915
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-mixed-1.json 0000664 0000000 0000000 00000000135 14414631765 0025467 0 ustar 00root root 0000000 0000000 {
"defaults": 14.111000001430511,
"str": 13.970665991306305,
"obj": 8.385917007923126
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-mixed-20.json 0000664 0000000 0000000 00000000135 14414631765 0025550 0 ustar 00root root 0000000 0000000 {
"defaults": 116.30437499284744,
"str": 129.18783402442932,
"obj": 96.91087502241135
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0025345 0 ustar 00root root 0000000 0000000 {
"defaults": 13.282292008399963,
"str": 12.831542015075684,
"obj": 8.239207983016968
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-slow-20.json 0000664 0000000 0000000 00000000134 14414631765 0025425 0 ustar 00root root 0000000 0000000 {
"defaults": 115.99166697263718,
"str": 128.30966699123383,
"obj": 95.9580420255661
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-fast-1.json 0000664 0000000 0000000 00000000135 14414631765 0025345 0 ustar 00root root 0000000 0000000 {
"defaults": 13.550792038440704,
"str": 13.598625004291534,
"obj": 7.527709007263184
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0025425 0 ustar 00root root 0000000 0000000 {
"defaults": 61.014499962329865,
"str": 64.24833297729492,
"obj": 37.54316699504852
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0025374 0 ustar 00root root 0000000 0000000 {
"defaults": 19.803040981292725,
"str": 19.487249970436096,
"obj": 16.86175000667572
} isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0025455 0 ustar 00root root 0000000 0000000 {
"defaults": 111.40716600418091,
"str": 122.67037498950958,
"obj": 93.60766696929932
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0025601 0 ustar 00root root 0000000 0000000 {
"defaults": 4.571958065032959,
"str": 4.329500198364258,
"obj": 0.9436254501342773
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-fast-20.json 0000664 0000000 0000000 00000000056 14414631765 0025665 0 ustar 00root root 0000000 0000000 {
"defaults": {},
"str": {},
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-mixed-1.json 0000664 0000000 0000000 00000000132 14414631765 0025750 0 ustar 00root root 0000000 0000000 {
"defaults": 8.806500434875488,
"str": 7.162916660308838,
"obj": 3.48104190826416
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-mixed-20.json 0000664 0000000 0000000 00000000056 14414631765 0026036 0 ustar 00root root 0000000 0000000 {
"defaults": {},
"str": {},
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0025630 0 ustar 00root root 0000000 0000000 {
"defaults": 8.510458946228027,
"str": 6.624207973480225,
"obj": 3.3635826110839844
} isaacs-minipass-ffdbee1/bench/results/push-through-fast-slow-20.json 0000664 0000000 0000000 00000000056 14414631765 0025714 0 ustar 00root root 0000000 0000000 {
"defaults": {},
"str": {},
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/push-through-slow-fast-1.json 0000664 0000000 0000000 00000000133 14414631765 0025627 0 ustar 00root root 0000000 0000000 {
"defaults": 8.911791801452637,
"str": 9.212250232696533,
"obj": 6.082250118255615
} isaacs-minipass-ffdbee1/bench/results/push-through-slow-fast-20.json 0000664 0000000 0000000 00000000056 14414631765 0025714 0 ustar 00root root 0000000 0000000 {
"defaults": {},
"str": {},
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/push-through-slow-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0025657 0 ustar 00root root 0000000 0000000 {
"defaults": 16.439791202545166,
"str": 14.342957973480225,
"obj": 11.8979172706604
} isaacs-minipass-ffdbee1/bench/results/push-through-slow-slow-20.json 0000664 0000000 0000000 00000000056 14414631765 0025743 0 ustar 00root root 0000000 0000000 {
"defaults": {},
"str": {},
"obj": {}
} isaacs-minipass-ffdbee1/bench/results/through2-fast-fast-1.json 0000664 0000000 0000000 00000000136 14414631765 0024710 0 ustar 00root root 0000000 0000000 {
"defaults": 23.358792304992676,
"str": 1519.4609580039978,
"obj": 18.863791942596436
} isaacs-minipass-ffdbee1/bench/results/through2-fast-fast-20.json 0000664 0000000 0000000 00000000134 14414631765 0024767 0 ustar 00root root 0000000 0000000 {
"defaults": 269.9025411605835,
"str": 30722.50658416748,
"obj": 237.11420822143555
} isaacs-minipass-ffdbee1/bench/results/through2-fast-mixed-1.json 0000664 0000000 0000000 00000000136 14414631765 0025061 0 ustar 00root root 0000000 0000000 {
"defaults": 25.791290760040283,
"str": 1463.4079580307007,
"obj": 16.932791233062744
} isaacs-minipass-ffdbee1/bench/results/through2-fast-mixed-20.json 0000664 0000000 0000000 00000000136 14414631765 0025142 0 ustar 00root root 0000000 0000000 {
"defaults": 237.30966711044312,
"str": 36814.678584098816,
"obj": 142.29699993133545
} isaacs-minipass-ffdbee1/bench/results/through2-fast-slow-1.json 0000664 0000000 0000000 00000000135 14414631765 0024736 0 ustar 00root root 0000000 0000000 {
"defaults": 23.46716594696045,
"str": 1448.8229160308838,
"obj": 14.695291996002197
} isaacs-minipass-ffdbee1/bench/results/through2-fast-slow-20.json 0000664 0000000 0000000 00000000135 14414631765 0025017 0 ustar 00root root 0000000 0000000 {
"defaults": 235.12229204177856,
"str": 36618.73558282852,
"obj": 148.23050022125244
} isaacs-minipass-ffdbee1/bench/results/through2-slow-fast-1.json 0000664 0000000 0000000 00000000134 14414631765 0024735 0 ustar 00root root 0000000 0000000 {
"defaults": 30.843832969665527,
"str": 1474.772541999817,
"obj": 30.43804121017456
} isaacs-minipass-ffdbee1/bench/results/through2-slow-fast-20.json 0000664 0000000 0000000 00000000135 14414631765 0025017 0 ustar 00root root 0000000 0000000 {
"defaults": 284.6131248474121,
"str": 29469.896290779114,
"obj": 238.76466703414917
} isaacs-minipass-ffdbee1/bench/results/through2-slow-slow-1.json 0000664 0000000 0000000 00000000134 14414631765 0024764 0 ustar 00root root 0000000 0000000 {
"defaults": 34.66804075241089,
"str": 1452.2015419006348,
"obj": 37.72975015640259
} isaacs-minipass-ffdbee1/bench/results/through2-slow-slow-20.json 0000664 0000000 0000000 00000000136 14414631765 0025047 0 ustar 00root root 0000000 0000000 {
"defaults": 294.61695766448975,
"str": 29603.270833015442,
"obj": 264.94858407974243
} isaacs-minipass-ffdbee1/bench/test.js 0000664 0000000 0000000 00000010302 14414631765 0020037 0 ustar 00root root 0000000 0000000 'use strict'
const iterations = +process.env.BENCH_TEST_ITERATION || 100
const testCount = +process.env.BENCH_TEST_COUNT || 20
const tests = [
'baseline',
'minipass',
'extend-minipass',
'through2',
'extend-through2',
'passthrough',
'extend-transform'
]
const manyOpts = [ 'many', 'single' ]
const typeOpts = [ 'buffer', 'string', 'object' ]
const main = () => {
const spawn = require('child_process').spawn
const node = process.execPath
const results = {}
const testSet = []
tests.forEach(t =>
manyOpts.forEach(many =>
typeOpts.forEach(type =>
new Array(testCount).join(',').split(',').forEach(() =>
t !== 'baseline' || (many === 'single' && type === 'object')
? testSet.push([t, many, type]) : null))))
let didFirst = false
const mainRunTest = t => {
if (!t)
return afterMain(results)
const k = t.join('\t')
if (!results[k]) {
results[k] = []
if (!didFirst)
didFirst = true
else
process.stderr.write('\n')
process.stderr.write(k + ' #')
} else {
process.stderr.write('#')
}
const c = spawn(node, [__filename].concat(t), {
stdio: [ 'ignore', 'pipe', 2 ]
})
let out = ''
c.stdout.on('data', c => out += c)
c.on('close', (code, signal) => {
if (code || signal)
throw new Error('failed: ' + code + ' ' + signal)
results[k].push(+out)
mainRunTest(testSet.shift())
})
}
mainRunTest(testSet.shift())
}
const afterMain = results => {
console.log('test\tmany\ttype\tops/s\tmean\tmedian\tmax\tmin' +
'\tstdev\trange\traw')
// get the mean, median, stddev, and range of each test
Object.keys(results).forEach(test => {
const k = results[test].sort((a, b) => a - b)
const min = k[0]
const max = k[ k.length - 1 ]
const range = max - min
const sum = k.reduce((a,b) => a + b, 0)
const mean = sum / k.length
const ops = iterations / mean * 1000
const devs = k.map(n => n - mean).map(n => n * n)
const avgdev = devs.reduce((a,b) => a + b, 0) / k.length
const stdev = Math.pow(avgdev, 0.5)
const median = k.length % 2 ? k[Math.floor(k.length / 2)] :
(k[k.length/2] + k[k.length/2+1])/2
console.log(
'%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%s', test, round(ops),
round(mean), round(median),
max, min, round(stdev), round(range),
k.join('\t'))
})
}
const round = num => Math.round(num * 1000)/1000
const test = (testname, many, type) => {
const timer = require('./lib/timer.js')
const Class = getClass(testname)
const done = timer()
runTest(Class, many, type, iterations, done)
}
// don't blow up the stack! loop unless deferred
const runTest = (Class, many, type, iterations, done) => {
const Nullsink = require('./lib/nullsink.js')
const Numbers = require('./lib/numbers.js')
const opt = {}
if (type === 'string')
opt.encoding = 'utf8'
else if (type === 'object')
opt.objectMode = true
while (iterations--) {
let finished = false
let inloop = true
const after = iterations === 0 ? done
: () => {
if (iterations === 0)
done()
else if (inloop)
finished = true
else
runTest(Class, many, type, iterations, done)
}
const out = new Nullsink().on('finish', after)
let sink = Class ? new Class(opt) : out
if (many && Class)
sink = sink
.pipe(new Class(opt))
.pipe(new Class(opt))
.pipe(new Class(opt))
.pipe(new Class(opt))
if (sink !== out)
sink.pipe(out)
new Numbers(opt).pipe(sink)
// keep tight-looping if the stream is done already
if (!finished) {
inloop = false
break
}
}
}
const getClass = testname =>
testname === 'through2' ? require('through2').obj
: testname === 'extend-through2' ? require('./lib/extend-through2.js')
: testname === 'minipass' ? require('../')
: testname === 'extend-minipass' ? require('./lib/extend-minipass.js')
: testname === 'passthrough' ? require('stream').PassThrough
: testname === 'extend-transform' ? require('./lib/extend-transform.js')
: null
if (!process.argv[2])
main()
else
test(process.argv[2], process.argv[3] === 'many', process.argv[4])
isaacs-minipass-ffdbee1/index.d.ts 0000664 0000000 0000000 00000010346 14414631765 0017354 0 ustar 00root root 0000000 0000000 ///
// Note: marking anything protected or private in the exported
// class will limit Minipass's ability to be used as the base
// for mixin classes.
import { EventEmitter } from 'events'
import { Stream } from 'stream'
export namespace Minipass {
export type Encoding = BufferEncoding | 'buffer' | null
export interface Writable extends EventEmitter {
end(): any
write(chunk: any, ...args: any[]): any
}
export interface Readable extends EventEmitter {
pause(): any
resume(): any
pipe(): any
}
export type DualIterable = Iterable & AsyncIterable
export type ContiguousData =
| Buffer
| ArrayBufferLike
| ArrayBufferView
| string
export type BufferOrString = Buffer | string
export interface SharedOptions {
async?: boolean
signal?: AbortSignal
}
export interface StringOptions extends SharedOptions {
encoding: BufferEncoding
objectMode?: boolean
}
export interface BufferOptions extends SharedOptions {
encoding?: null | 'buffer'
objectMode?: boolean
}
export interface ObjectModeOptions extends SharedOptions {
objectMode: true
}
export interface PipeOptions {
end?: boolean
proxyErrors?: boolean
}
export type Options = T extends string
? StringOptions
: T extends Buffer
? BufferOptions
: ObjectModeOptions
}
export class Minipass<
RType extends any = Buffer,
WType extends any = RType extends Minipass.BufferOrString
? Minipass.ContiguousData
: RType
>
extends Stream
implements Minipass.DualIterable
{
static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
readonly bufferLength: number
readonly flowing: boolean
readonly writable: boolean
readonly readable: boolean
readonly aborted: boolean
readonly paused: boolean
readonly emittedEnd: boolean
readonly destroyed: boolean
/**
* Technically writable, but mutating it can change the type,
* so is not safe to do in TypeScript.
*/
readonly objectMode: boolean
async: boolean
/**
* Note: encoding is not actually read-only, and setEncoding(enc)
* exists. However, this type definition will insist that TypeScript
* programs declare the type of a Minipass stream up front, and if
* that type is string, then an encoding MUST be set in the ctor. If
* the type is Buffer, then the encoding must be missing, or set to
* 'buffer' or null. If the type is anything else, then objectMode
* must be set in the constructor options. So there is effectively
* no allowed way that a TS program can set the encoding after
* construction, as doing so will destroy any hope of type safety.
* TypeScript does not provide many options for changing the type of
* an object at run-time, which is what changing the encoding does.
*/
readonly encoding: Minipass.Encoding
// setEncoding(encoding: Encoding): void
// Options required if not reading buffers
constructor(
...args: RType extends Buffer
? [] | [Minipass.Options]
: [Minipass.Options]
)
write(chunk: WType, cb?: () => void): boolean
write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
read(size?: number): RType
end(cb?: () => void): this
end(chunk: any, cb?: () => void): this
end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
pause(): void
resume(): void
promise(): Promise
collect(): Promise
concat(): RType extends Minipass.BufferOrString ? Promise : never
destroy(er?: any): void
pipe(dest: W, opts?: Minipass.PipeOptions): W
unpipe(dest: W): void
/**
* alias for on()
*/
addEventHandler(event: string, listener: (...args: any[]) => any): this
on(event: string, listener: (...args: any[]) => any): this
on(event: 'data', listener: (chunk: RType) => any): this
on(event: 'error', listener: (error: any) => any): this
on(
event:
| 'readable'
| 'drain'
| 'resume'
| 'end'
| 'prefinish'
| 'finish'
| 'close',
listener: () => any
): this
[Symbol.iterator](): Generator
[Symbol.asyncIterator](): AsyncGenerator
}
isaacs-minipass-ffdbee1/index.js 0000664 0000000 0000000 00000044167 14414631765 0017130 0 ustar 00root root 0000000 0000000 'use strict'
const proc =
typeof process === 'object' && process
? process
: {
stdout: null,
stderr: null,
}
const EE = require('events')
const Stream = require('stream')
const stringdecoder = require('string_decoder')
const SD = stringdecoder.StringDecoder
const EOF = Symbol('EOF')
const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
const EMITTED_END = Symbol('emittedEnd')
const EMITTING_END = Symbol('emittingEnd')
const EMITTED_ERROR = Symbol('emittedError')
const CLOSED = Symbol('closed')
const READ = Symbol('read')
const FLUSH = Symbol('flush')
const FLUSHCHUNK = Symbol('flushChunk')
const ENCODING = Symbol('encoding')
const DECODER = Symbol('decoder')
const FLOWING = Symbol('flowing')
const PAUSED = Symbol('paused')
const RESUME = Symbol('resume')
const BUFFER = Symbol('buffer')
const PIPES = Symbol('pipes')
const BUFFERLENGTH = Symbol('bufferLength')
const BUFFERPUSH = Symbol('bufferPush')
const BUFFERSHIFT = Symbol('bufferShift')
const OBJECTMODE = Symbol('objectMode')
// internal event when stream is destroyed
const DESTROYED = Symbol('destroyed')
// internal event when stream has an error
const ERROR = Symbol('error')
const EMITDATA = Symbol('emitData')
const EMITEND = Symbol('emitEnd')
const EMITEND2 = Symbol('emitEnd2')
const ASYNC = Symbol('async')
const ABORT = Symbol('abort')
const ABORTED = Symbol('aborted')
const SIGNAL = Symbol('signal')
const defer = fn => Promise.resolve().then(fn)
// TODO remove when Node v8 support drops
const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
const ASYNCITERATOR =
(doIter && Symbol.asyncIterator) || Symbol('asyncIterator not implemented')
const ITERATOR =
(doIter && Symbol.iterator) || Symbol('iterator not implemented')
// events that mean 'the stream is over'
// these are treated specially, and re-emitted
// if they are listened for after emitting.
const isEndish = ev => ev === 'end' || ev === 'finish' || ev === 'prefinish'
const isArrayBuffer = b =>
b instanceof ArrayBuffer ||
(typeof b === 'object' &&
b.constructor &&
b.constructor.name === 'ArrayBuffer' &&
b.byteLength >= 0)
const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
class Pipe {
constructor(src, dest, opts) {
this.src = src
this.dest = dest
this.opts = opts
this.ondrain = () => src[RESUME]()
dest.on('drain', this.ondrain)
}
unpipe() {
this.dest.removeListener('drain', this.ondrain)
}
// istanbul ignore next - only here for the prototype
proxyErrors() {}
end() {
this.unpipe()
if (this.opts.end) this.dest.end()
}
}
class PipeProxyErrors extends Pipe {
unpipe() {
this.src.removeListener('error', this.proxyErrors)
super.unpipe()
}
constructor(src, dest, opts) {
super(src, dest, opts)
this.proxyErrors = er => dest.emit('error', er)
src.on('error', this.proxyErrors)
}
}
class Minipass extends Stream {
constructor(options) {
super()
this[FLOWING] = false
// whether we're explicitly paused
this[PAUSED] = false
this[PIPES] = []
this[BUFFER] = []
this[OBJECTMODE] = (options && options.objectMode) || false
if (this[OBJECTMODE]) this[ENCODING] = null
else this[ENCODING] = (options && options.encoding) || null
if (this[ENCODING] === 'buffer') this[ENCODING] = null
this[ASYNC] = (options && !!options.async) || false
this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
this[EOF] = false
this[EMITTED_END] = false
this[EMITTING_END] = false
this[CLOSED] = false
this[EMITTED_ERROR] = null
this.writable = true
this.readable = true
this[BUFFERLENGTH] = 0
this[DESTROYED] = false
if (options && options.debugExposeBuffer === true) {
Object.defineProperty(this, 'buffer', { get: () => this[BUFFER] })
}
if (options && options.debugExposePipes === true) {
Object.defineProperty(this, 'pipes', { get: () => this[PIPES] })
}
this[SIGNAL] = options && options.signal
this[ABORTED] = false
if (this[SIGNAL]) {
this[SIGNAL].addEventListener('abort', () => this[ABORT]())
if (this[SIGNAL].aborted) {
this[ABORT]()
}
}
}
get bufferLength() {
return this[BUFFERLENGTH]
}
get encoding() {
return this[ENCODING]
}
set encoding(enc) {
if (this[OBJECTMODE]) throw new Error('cannot set encoding in objectMode')
if (
this[ENCODING] &&
enc !== this[ENCODING] &&
((this[DECODER] && this[DECODER].lastNeed) || this[BUFFERLENGTH])
)
throw new Error('cannot change encoding')
if (this[ENCODING] !== enc) {
this[DECODER] = enc ? new SD(enc) : null
if (this[BUFFER].length)
this[BUFFER] = this[BUFFER].map(chunk => this[DECODER].write(chunk))
}
this[ENCODING] = enc
}
setEncoding(enc) {
this.encoding = enc
}
get objectMode() {
return this[OBJECTMODE]
}
set objectMode(om) {
this[OBJECTMODE] = this[OBJECTMODE] || !!om
}
get ['async']() {
return this[ASYNC]
}
set ['async'](a) {
this[ASYNC] = this[ASYNC] || !!a
}
// drop everything and get out of the flow completely
[ABORT]() {
this[ABORTED] = true
this.emit('abort', this[SIGNAL].reason)
this.destroy(this[SIGNAL].reason)
}
get aborted() {
return this[ABORTED]
}
set aborted(_) {}
write(chunk, encoding, cb) {
if (this[ABORTED]) return false
if (this[EOF]) throw new Error('write after end')
if (this[DESTROYED]) {
this.emit(
'error',
Object.assign(
new Error('Cannot call write after a stream was destroyed'),
{ code: 'ERR_STREAM_DESTROYED' }
)
)
return true
}
if (typeof encoding === 'function') (cb = encoding), (encoding = 'utf8')
if (!encoding) encoding = 'utf8'
const fn = this[ASYNC] ? defer : f => f()
// convert array buffers and typed array views into buffers
// at some point in the future, we may want to do the opposite!
// leave strings and buffers as-is
// anything else switches us into object mode
if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
if (isArrayBufferView(chunk))
chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
else if (isArrayBuffer(chunk)) chunk = Buffer.from(chunk)
else if (typeof chunk !== 'string')
// use the setter so we throw if we have encoding set
this.objectMode = true
}
// handle object mode up front, since it's simpler
// this yields better performance, fewer checks later.
if (this[OBJECTMODE]) {
/* istanbul ignore if - maybe impossible? */
if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true)
if (this.flowing) this.emit('data', chunk)
else this[BUFFERPUSH](chunk)
if (this[BUFFERLENGTH] !== 0) this.emit('readable')
if (cb) fn(cb)
return this.flowing
}
// at this point the chunk is a buffer or string
// don't buffer it up or send it to the decoder
if (!chunk.length) {
if (this[BUFFERLENGTH] !== 0) this.emit('readable')
if (cb) fn(cb)
return this.flowing
}
// fast-path writing strings of same encoding to a stream with
// an empty buffer, skipping the buffer/decoder dance
if (
typeof chunk === 'string' &&
// unless it is a string already ready for us to use
!(encoding === this[ENCODING] && !this[DECODER].lastNeed)
) {
chunk = Buffer.from(chunk, encoding)
}
if (Buffer.isBuffer(chunk) && this[ENCODING])
chunk = this[DECODER].write(chunk)
// Note: flushing CAN potentially switch us into not-flowing mode
if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true)
if (this.flowing) this.emit('data', chunk)
else this[BUFFERPUSH](chunk)
if (this[BUFFERLENGTH] !== 0) this.emit('readable')
if (cb) fn(cb)
return this.flowing
}
read(n) {
if (this[DESTROYED]) return null
if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
this[MAYBE_EMIT_END]()
return null
}
if (this[OBJECTMODE]) n = null
if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
if (this.encoding) this[BUFFER] = [this[BUFFER].join('')]
else this[BUFFER] = [Buffer.concat(this[BUFFER], this[BUFFERLENGTH])]
}
const ret = this[READ](n || null, this[BUFFER][0])
this[MAYBE_EMIT_END]()
return ret
}
[READ](n, chunk) {
if (n === chunk.length || n === null) this[BUFFERSHIFT]()
else {
this[BUFFER][0] = chunk.slice(n)
chunk = chunk.slice(0, n)
this[BUFFERLENGTH] -= n
}
this.emit('data', chunk)
if (!this[BUFFER].length && !this[EOF]) this.emit('drain')
return chunk
}
end(chunk, encoding, cb) {
if (typeof chunk === 'function') (cb = chunk), (chunk = null)
if (typeof encoding === 'function') (cb = encoding), (encoding = 'utf8')
if (chunk) this.write(chunk, encoding)
if (cb) this.once('end', cb)
this[EOF] = true
this.writable = false
// if we haven't written anything, then go ahead and emit,
// even if we're not reading.
// we'll re-emit if a new 'end' listener is added anyway.
// This makes MP more suitable to write-only use cases.
if (this.flowing || !this[PAUSED]) this[MAYBE_EMIT_END]()
return this
}
// don't let the internal resume be overwritten
[RESUME]() {
if (this[DESTROYED]) return
this[PAUSED] = false
this[FLOWING] = true
this.emit('resume')
if (this[BUFFER].length) this[FLUSH]()
else if (this[EOF]) this[MAYBE_EMIT_END]()
else this.emit('drain')
}
resume() {
return this[RESUME]()
}
pause() {
this[FLOWING] = false
this[PAUSED] = true
}
get destroyed() {
return this[DESTROYED]
}
get flowing() {
return this[FLOWING]
}
get paused() {
return this[PAUSED]
}
[BUFFERPUSH](chunk) {
if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1
else this[BUFFERLENGTH] += chunk.length
this[BUFFER].push(chunk)
}
[BUFFERSHIFT]() {
if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1
else this[BUFFERLENGTH] -= this[BUFFER][0].length
return this[BUFFER].shift()
}
[FLUSH](noDrain) {
do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length)
if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit('drain')
}
[FLUSHCHUNK](chunk) {
this.emit('data', chunk)
return this.flowing
}
pipe(dest, opts) {
if (this[DESTROYED]) return
const ended = this[EMITTED_END]
opts = opts || {}
if (dest === proc.stdout || dest === proc.stderr) opts.end = false
else opts.end = opts.end !== false
opts.proxyErrors = !!opts.proxyErrors
// piping an ended stream ends immediately
if (ended) {
if (opts.end) dest.end()
} else {
this[PIPES].push(
!opts.proxyErrors
? new Pipe(this, dest, opts)
: new PipeProxyErrors(this, dest, opts)
)
if (this[ASYNC]) defer(() => this[RESUME]())
else this[RESUME]()
}
return dest
}
unpipe(dest) {
const p = this[PIPES].find(p => p.dest === dest)
if (p) {
this[PIPES].splice(this[PIPES].indexOf(p), 1)
p.unpipe()
}
}
addListener(ev, fn) {
return this.on(ev, fn)
}
on(ev, fn) {
const ret = super.on(ev, fn)
if (ev === 'data' && !this[PIPES].length && !this.flowing) this[RESUME]()
else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
super.emit('readable')
else if (isEndish(ev) && this[EMITTED_END]) {
super.emit(ev)
this.removeAllListeners(ev)
} else if (ev === 'error' && this[EMITTED_ERROR]) {
if (this[ASYNC]) defer(() => fn.call(this, this[EMITTED_ERROR]))
else fn.call(this, this[EMITTED_ERROR])
}
return ret
}
get emittedEnd() {
return this[EMITTED_END]
}
[MAYBE_EMIT_END]() {
if (
!this[EMITTING_END] &&
!this[EMITTED_END] &&
!this[DESTROYED] &&
this[BUFFER].length === 0 &&
this[EOF]
) {
this[EMITTING_END] = true
this.emit('end')
this.emit('prefinish')
this.emit('finish')
if (this[CLOSED]) this.emit('close')
this[EMITTING_END] = false
}
}
emit(ev, data, ...extra) {
// error and close are only events allowed after calling destroy()
if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
return
else if (ev === 'data') {
return !this[OBJECTMODE] && !data
? false
: this[ASYNC]
? defer(() => this[EMITDATA](data))
: this[EMITDATA](data)
} else if (ev === 'end') {
return this[EMITEND]()
} else if (ev === 'close') {
this[CLOSED] = true
// don't emit close before 'end' and 'finish'
if (!this[EMITTED_END] && !this[DESTROYED]) return
const ret = super.emit('close')
this.removeAllListeners('close')
return ret
} else if (ev === 'error') {
this[EMITTED_ERROR] = data
super.emit(ERROR, data)
const ret =
!this[SIGNAL] || this.listeners('error').length
? super.emit('error', data)
: false
this[MAYBE_EMIT_END]()
return ret
} else if (ev === 'resume') {
const ret = super.emit('resume')
this[MAYBE_EMIT_END]()
return ret
} else if (ev === 'finish' || ev === 'prefinish') {
const ret = super.emit(ev)
this.removeAllListeners(ev)
return ret
}
// Some other unknown event
const ret = super.emit(ev, data, ...extra)
this[MAYBE_EMIT_END]()
return ret
}
[EMITDATA](data) {
for (const p of this[PIPES]) {
if (p.dest.write(data) === false) this.pause()
}
const ret = super.emit('data', data)
this[MAYBE_EMIT_END]()
return ret
}
[EMITEND]() {
if (this[EMITTED_END]) return
this[EMITTED_END] = true
this.readable = false
if (this[ASYNC]) defer(() => this[EMITEND2]())
else this[EMITEND2]()
}
[EMITEND2]() {
if (this[DECODER]) {
const data = this[DECODER].end()
if (data) {
for (const p of this[PIPES]) {
p.dest.write(data)
}
super.emit('data', data)
}
}
for (const p of this[PIPES]) {
p.end()
}
const ret = super.emit('end')
this.removeAllListeners('end')
return ret
}
// const all = await stream.collect()
collect() {
const buf = []
if (!this[OBJECTMODE]) buf.dataLength = 0
// set the promise first, in case an error is raised
// by triggering the flow here.
const p = this.promise()
this.on('data', c => {
buf.push(c)
if (!this[OBJECTMODE]) buf.dataLength += c.length
})
return p.then(() => buf)
}
// const data = await stream.concat()
concat() {
return this[OBJECTMODE]
? Promise.reject(new Error('cannot concat in objectMode'))
: this.collect().then(buf =>
this[OBJECTMODE]
? Promise.reject(new Error('cannot concat in objectMode'))
: this[ENCODING]
? buf.join('')
: Buffer.concat(buf, buf.dataLength)
)
}
// stream.promise().then(() => done, er => emitted error)
promise() {
return new Promise((resolve, reject) => {
this.on(DESTROYED, () => reject(new Error('stream destroyed')))
this.on('error', er => reject(er))
this.on('end', () => resolve())
})
}
// for await (let chunk of stream)
[ASYNCITERATOR]() {
let stopped = false
const stop = () => {
this.pause()
stopped = true
return Promise.resolve({ done: true })
}
const next = () => {
if (stopped) return stop()
const res = this.read()
if (res !== null) return Promise.resolve({ done: false, value: res })
if (this[EOF]) return stop()
let resolve = null
let reject = null
const onerr = er => {
this.removeListener('data', ondata)
this.removeListener('end', onend)
this.removeListener(DESTROYED, ondestroy)
stop()
reject(er)
}
const ondata = value => {
this.removeListener('error', onerr)
this.removeListener('end', onend)
this.removeListener(DESTROYED, ondestroy)
this.pause()
resolve({ value: value, done: !!this[EOF] })
}
const onend = () => {
this.removeListener('error', onerr)
this.removeListener('data', ondata)
this.removeListener(DESTROYED, ondestroy)
stop()
resolve({ done: true })
}
const ondestroy = () => onerr(new Error('stream destroyed'))
return new Promise((res, rej) => {
reject = rej
resolve = res
this.once(DESTROYED, ondestroy)
this.once('error', onerr)
this.once('end', onend)
this.once('data', ondata)
})
}
return {
next,
throw: stop,
return: stop,
[ASYNCITERATOR]() {
return this
},
}
}
// for (let chunk of stream)
[ITERATOR]() {
let stopped = false
const stop = () => {
this.pause()
this.removeListener(ERROR, stop)
this.removeListener(DESTROYED, stop)
this.removeListener('end', stop)
stopped = true
return { done: true }
}
const next = () => {
if (stopped) return stop()
const value = this.read()
return value === null ? stop() : { value }
}
this.once('end', stop)
this.once(ERROR, stop)
this.once(DESTROYED, stop)
return {
next,
throw: stop,
return: stop,
[ITERATOR]() {
return this
},
}
}
destroy(er) {
if (this[DESTROYED]) {
if (er) this.emit('error', er)
else this.emit(DESTROYED)
return this
}
this[DESTROYED] = true
// throw away all buffered data, it's never coming out
this[BUFFER].length = 0
this[BUFFERLENGTH] = 0
if (typeof this.close === 'function' && !this[CLOSED]) this.close()
if (er) this.emit('error', er)
// if no error to emit, still reject pending promises
else this.emit(DESTROYED)
return this
}
static isStream(s) {
return (
!!s &&
(s instanceof Minipass ||
s instanceof Stream ||
(s instanceof EE &&
// readable
(typeof s.pipe === 'function' ||
// writable
(typeof s.write === 'function' && typeof s.end === 'function'))))
)
}
}
exports.Minipass = Minipass
isaacs-minipass-ffdbee1/package-lock.json 0000664 0000000 0000000 00000434514 14414631765 0020676 0 ustar 00root root 0000000 0000000 {
"name": "minipass",
"version": "5.0.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "minipass",
"version": "5.0.0",
"license": "ISC",
"devDependencies": {
"@types/node": "^17.0.41",
"end-of-stream": "^1.4.0",
"node-abort-controller": "^3.1.1",
"prettier": "^2.6.2",
"tap": "^16.2.0",
"through2": "^2.0.3",
"ts-node": "^10.8.1",
"typedoc": "^0.23.24",
"typescript": "^4.7.3"
},
"engines": {
"node": ">=8"
}
},
"node_modules/@ampproject/remapping": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.0.tgz",
"integrity": "sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==",
"dev": true,
"dependencies": {
"@jridgewell/gen-mapping": "^0.1.0",
"@jridgewell/trace-mapping": "^0.3.9"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@babel/code-frame": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz",
"integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==",
"dev": true,
"dependencies": {
"@babel/highlight": "^7.18.6"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/compat-data": {
"version": "7.20.14",
"resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.20.14.tgz",
"integrity": "sha512-0YpKHD6ImkWMEINCyDAD0HLLUH/lPCefG8ld9it8DJB2wnApraKuhgYTvTY1z7UFIfBTGy5LwncZ+5HWWGbhFw==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/core": {
"version": "7.20.12",
"resolved": "https://registry.npmjs.org/@babel/core/-/core-7.20.12.tgz",
"integrity": "sha512-XsMfHovsUYHFMdrIHkZphTN/2Hzzi78R08NuHfDBehym2VsPDL6Zn/JAD/JQdnRvbSsbQc4mVaU1m6JgtTEElg==",
"dev": true,
"dependencies": {
"@ampproject/remapping": "^2.1.0",
"@babel/code-frame": "^7.18.6",
"@babel/generator": "^7.20.7",
"@babel/helper-compilation-targets": "^7.20.7",
"@babel/helper-module-transforms": "^7.20.11",
"@babel/helpers": "^7.20.7",
"@babel/parser": "^7.20.7",
"@babel/template": "^7.20.7",
"@babel/traverse": "^7.20.12",
"@babel/types": "^7.20.7",
"convert-source-map": "^1.7.0",
"debug": "^4.1.0",
"gensync": "^1.0.0-beta.2",
"json5": "^2.2.2",
"semver": "^6.3.0"
},
"engines": {
"node": ">=6.9.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/babel"
}
},
"node_modules/@babel/generator": {
"version": "7.20.14",
"resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.20.14.tgz",
"integrity": "sha512-AEmuXHdcD3A52HHXxaTmYlb8q/xMEhoRP67B3T4Oq7lbmSoqroMZzjnGj3+i1io3pdnF8iBYVu4Ilj+c4hBxYg==",
"dev": true,
"dependencies": {
"@babel/types": "^7.20.7",
"@jridgewell/gen-mapping": "^0.3.2",
"jsesc": "^2.5.1"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/generator/node_modules/@jridgewell/gen-mapping": {
"version": "0.3.2",
"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
"integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
"dev": true,
"dependencies": {
"@jridgewell/set-array": "^1.0.1",
"@jridgewell/sourcemap-codec": "^1.4.10",
"@jridgewell/trace-mapping": "^0.3.9"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@babel/helper-compilation-targets": {
"version": "7.20.7",
"resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.7.tgz",
"integrity": "sha512-4tGORmfQcrc+bvrjb5y3dG9Mx1IOZjsHqQVUz7XCNHO+iTmqxWnVg3KRygjGmpRLJGdQSKuvFinbIb0CnZwHAQ==",
"dev": true,
"dependencies": {
"@babel/compat-data": "^7.20.5",
"@babel/helper-validator-option": "^7.18.6",
"browserslist": "^4.21.3",
"lru-cache": "^5.1.1",
"semver": "^6.3.0"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0"
}
},
"node_modules/@babel/helper-environment-visitor": {
"version": "7.18.9",
"resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz",
"integrity": "sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-function-name": {
"version": "7.19.0",
"resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz",
"integrity": "sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w==",
"dev": true,
"dependencies": {
"@babel/template": "^7.18.10",
"@babel/types": "^7.19.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-hoist-variables": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz",
"integrity": "sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q==",
"dev": true,
"dependencies": {
"@babel/types": "^7.18.6"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-module-imports": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz",
"integrity": "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA==",
"dev": true,
"dependencies": {
"@babel/types": "^7.18.6"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-module-transforms": {
"version": "7.20.11",
"resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.20.11.tgz",
"integrity": "sha512-uRy78kN4psmji1s2QtbtcCSaj/LILFDp0f/ymhpQH5QY3nljUZCaNWz9X1dEj/8MBdBEFECs7yRhKn8i7NjZgg==",
"dev": true,
"dependencies": {
"@babel/helper-environment-visitor": "^7.18.9",
"@babel/helper-module-imports": "^7.18.6",
"@babel/helper-simple-access": "^7.20.2",
"@babel/helper-split-export-declaration": "^7.18.6",
"@babel/helper-validator-identifier": "^7.19.1",
"@babel/template": "^7.20.7",
"@babel/traverse": "^7.20.10",
"@babel/types": "^7.20.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-simple-access": {
"version": "7.20.2",
"resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz",
"integrity": "sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA==",
"dev": true,
"dependencies": {
"@babel/types": "^7.20.2"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-split-export-declaration": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz",
"integrity": "sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA==",
"dev": true,
"dependencies": {
"@babel/types": "^7.18.6"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-string-parser": {
"version": "7.19.4",
"resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz",
"integrity": "sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-validator-identifier": {
"version": "7.19.1",
"resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz",
"integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helper-validator-option": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz",
"integrity": "sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/helpers": {
"version": "7.20.13",
"resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.20.13.tgz",
"integrity": "sha512-nzJ0DWCL3gB5RCXbUO3KIMMsBY2Eqbx8mBpKGE/02PgyRQFcPQLbkQ1vyy596mZLaP+dAfD+R4ckASzNVmW3jg==",
"dev": true,
"dependencies": {
"@babel/template": "^7.20.7",
"@babel/traverse": "^7.20.13",
"@babel/types": "^7.20.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/highlight": {
"version": "7.18.6",
"resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz",
"integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==",
"dev": true,
"dependencies": {
"@babel/helper-validator-identifier": "^7.18.6",
"chalk": "^2.0.0",
"js-tokens": "^4.0.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/parser": {
"version": "7.20.13",
"resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.20.13.tgz",
"integrity": "sha512-gFDLKMfpiXCsjt4za2JA9oTMn70CeseCehb11kRZgvd7+F67Hih3OHOK24cRrWECJ/ljfPGac6ygXAs/C8kIvw==",
"dev": true,
"bin": {
"parser": "bin/babel-parser.js"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@babel/template": {
"version": "7.20.7",
"resolved": "https://registry.npmjs.org/@babel/template/-/template-7.20.7.tgz",
"integrity": "sha512-8SegXApWe6VoNw0r9JHpSteLKTpTiLZ4rMlGIm9JQ18KiCtyQiAMEazujAHrUS5flrcqYZa75ukev3P6QmUwUw==",
"dev": true,
"dependencies": {
"@babel/code-frame": "^7.18.6",
"@babel/parser": "^7.20.7",
"@babel/types": "^7.20.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/traverse": {
"version": "7.20.13",
"resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.20.13.tgz",
"integrity": "sha512-kMJXfF0T6DIS9E8cgdLCSAL+cuCK+YEZHWiLK0SXpTo8YRj5lpJu3CDNKiIBCne4m9hhTIqUg6SYTAI39tAiVQ==",
"dev": true,
"dependencies": {
"@babel/code-frame": "^7.18.6",
"@babel/generator": "^7.20.7",
"@babel/helper-environment-visitor": "^7.18.9",
"@babel/helper-function-name": "^7.19.0",
"@babel/helper-hoist-variables": "^7.18.6",
"@babel/helper-split-export-declaration": "^7.18.6",
"@babel/parser": "^7.20.13",
"@babel/types": "^7.20.7",
"debug": "^4.1.0",
"globals": "^11.1.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@babel/types": {
"version": "7.20.7",
"resolved": "https://registry.npmjs.org/@babel/types/-/types-7.20.7.tgz",
"integrity": "sha512-69OnhBxSSgK0OzTJai4kyPDiKTIe3j+ctaHdIGVbRahTLAT7L3R9oeXHC2aVSuGYt3cVnoAMDmOCgJ2yaiLMvg==",
"dev": true,
"dependencies": {
"@babel/helper-string-parser": "^7.19.4",
"@babel/helper-validator-identifier": "^7.19.1",
"to-fast-properties": "^2.0.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/@cspotcode/source-map-support": {
"version": "0.8.1",
"resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
"integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
"dev": true,
"dependencies": {
"@jridgewell/trace-mapping": "0.3.9"
},
"engines": {
"node": ">=12"
}
},
"node_modules/@cspotcode/source-map-support/node_modules/@jridgewell/trace-mapping": {
"version": "0.3.9",
"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
"integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
"dev": true,
"dependencies": {
"@jridgewell/resolve-uri": "^3.0.3",
"@jridgewell/sourcemap-codec": "^1.4.10"
}
},
"node_modules/@istanbuljs/load-nyc-config": {
"version": "1.1.0",
"resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz",
"integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==",
"dev": true,
"dependencies": {
"camelcase": "^5.3.1",
"find-up": "^4.1.0",
"get-package-type": "^0.1.0",
"js-yaml": "^3.13.1",
"resolve-from": "^5.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/@istanbuljs/schema": {
"version": "0.1.3",
"resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz",
"integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/@jridgewell/gen-mapping": {
"version": "0.1.1",
"resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz",
"integrity": "sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==",
"dev": true,
"dependencies": {
"@jridgewell/set-array": "^1.0.0",
"@jridgewell/sourcemap-codec": "^1.4.10"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/resolve-uri": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
"integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
"dev": true,
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/set-array": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
"integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
"dev": true,
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/sourcemap-codec": {
"version": "1.4.14",
"resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
"integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
"dev": true
},
"node_modules/@jridgewell/trace-mapping": {
"version": "0.3.17",
"resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz",
"integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==",
"dev": true,
"dependencies": {
"@jridgewell/resolve-uri": "3.1.0",
"@jridgewell/sourcemap-codec": "1.4.14"
}
},
"node_modules/@tsconfig/node10": {
"version": "1.0.9",
"resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz",
"integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==",
"dev": true
},
"node_modules/@tsconfig/node12": {
"version": "1.0.11",
"resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
"integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
"dev": true
},
"node_modules/@tsconfig/node14": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
"integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
"dev": true
},
"node_modules/@tsconfig/node16": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz",
"integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==",
"dev": true
},
"node_modules/@types/node": {
"version": "17.0.45",
"resolved": "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz",
"integrity": "sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==",
"dev": true
},
"node_modules/acorn": {
"version": "8.8.2",
"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
"integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==",
"dev": true,
"bin": {
"acorn": "bin/acorn"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/acorn-walk": {
"version": "8.2.0",
"resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz",
"integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==",
"dev": true,
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/aggregate-error": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz",
"integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==",
"dev": true,
"dependencies": {
"clean-stack": "^2.0.0",
"indent-string": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/ansi-regex": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
"integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/ansi-styles": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
"integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
"dev": true,
"dependencies": {
"color-convert": "^1.9.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/anymatch": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
"integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
"dev": true,
"dependencies": {
"normalize-path": "^3.0.0",
"picomatch": "^2.0.4"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/append-transform": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/append-transform/-/append-transform-2.0.0.tgz",
"integrity": "sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==",
"dev": true,
"dependencies": {
"default-require-extensions": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/archy": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz",
"integrity": "sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==",
"dev": true
},
"node_modules/arg": {
"version": "4.1.3",
"resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
"integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
"dev": true
},
"node_modules/argparse": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
"integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
"dev": true,
"dependencies": {
"sprintf-js": "~1.0.2"
}
},
"node_modules/async-hook-domain": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/async-hook-domain/-/async-hook-domain-2.0.4.tgz",
"integrity": "sha512-14LjCmlK1PK8eDtTezR6WX8TMaYNIzBIsd2D1sGoGjgx0BuNMMoSdk7i/drlbtamy0AWv9yv2tkB+ASdmeqFIw==",
"dev": true,
"engines": {
"node": ">=10"
}
},
"node_modules/balanced-match": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
"dev": true
},
"node_modules/binary-extensions": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
"integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/bind-obj-methods": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/bind-obj-methods/-/bind-obj-methods-3.0.0.tgz",
"integrity": "sha512-nLEaaz3/sEzNSyPWRsN9HNsqwk1AUyECtGj+XwGdIi3xABnEqecvXtIJ0wehQXuuER5uZ/5fTs2usONgYjG+iw==",
"dev": true,
"engines": {
"node": ">=10"
}
},
"node_modules/brace-expansion": {
"version": "1.1.11",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
"integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
"dev": true,
"dependencies": {
"balanced-match": "^1.0.0",
"concat-map": "0.0.1"
}
},
"node_modules/braces": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
"integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
"dev": true,
"dependencies": {
"fill-range": "^7.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/browserslist": {
"version": "4.21.5",
"resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.21.5.tgz",
"integrity": "sha512-tUkiguQGW7S3IhB7N+c2MV/HZPSCPAAiYBZXLsBhFB/PCy6ZKKsZrmBayHV9fdGV/ARIfJ14NkxKzRDjvp7L6w==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/browserslist"
}
],
"dependencies": {
"caniuse-lite": "^1.0.30001449",
"electron-to-chromium": "^1.4.284",
"node-releases": "^2.0.8",
"update-browserslist-db": "^1.0.10"
},
"bin": {
"browserslist": "cli.js"
},
"engines": {
"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
}
},
"node_modules/buffer-from": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
"integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
"dev": true
},
"node_modules/caching-transform": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/caching-transform/-/caching-transform-4.0.0.tgz",
"integrity": "sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==",
"dev": true,
"dependencies": {
"hasha": "^5.0.0",
"make-dir": "^3.0.0",
"package-hash": "^4.0.0",
"write-file-atomic": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/camelcase": {
"version": "5.3.1",
"resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
"integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/caniuse-lite": {
"version": "1.0.30001449",
"resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001449.tgz",
"integrity": "sha512-CPB+UL9XMT/Av+pJxCKGhdx+yg1hzplvFJQlJ2n68PyQGMz9L/E2zCyLdOL8uasbouTUgnPl+y0tccI/se+BEw==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
}
]
},
"node_modules/chalk": {
"version": "2.4.2",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
"integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
"dev": true,
"dependencies": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/chokidar": {
"version": "3.5.3",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
"integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
"dev": true,
"funding": [
{
"type": "individual",
"url": "https://paulmillr.com/funding/"
}
],
"dependencies": {
"anymatch": "~3.1.2",
"braces": "~3.0.2",
"glob-parent": "~5.1.2",
"is-binary-path": "~2.1.0",
"is-glob": "~4.0.1",
"normalize-path": "~3.0.0",
"readdirp": "~3.6.0"
},
"engines": {
"node": ">= 8.10.0"
},
"optionalDependencies": {
"fsevents": "~2.3.2"
}
},
"node_modules/clean-stack": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz",
"integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/cliui": {
"version": "7.0.4",
"resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
"integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
"dev": true,
"dependencies": {
"string-width": "^4.2.0",
"strip-ansi": "^6.0.0",
"wrap-ansi": "^7.0.0"
}
},
"node_modules/color-convert": {
"version": "1.9.3",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
"integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
"dev": true,
"dependencies": {
"color-name": "1.1.3"
}
},
"node_modules/color-name": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
"integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
"dev": true
},
"node_modules/color-support": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
"integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
"dev": true,
"bin": {
"color-support": "bin.js"
}
},
"node_modules/commondir": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
"integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==",
"dev": true
},
"node_modules/concat-map": {
"version": "0.0.1",
"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
"integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
"dev": true
},
"node_modules/convert-source-map": {
"version": "1.9.0",
"resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz",
"integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==",
"dev": true
},
"node_modules/core-util-is": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
"integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
"dev": true
},
"node_modules/create-require": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
"integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
"dev": true
},
"node_modules/cross-spawn": {
"version": "7.0.3",
"resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
"integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
"dev": true,
"dependencies": {
"path-key": "^3.1.0",
"shebang-command": "^2.0.0",
"which": "^2.0.1"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/debug": {
"version": "4.3.4",
"resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
"integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
"dev": true,
"dependencies": {
"ms": "2.1.2"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/decamelize": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
"integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/default-require-extensions": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/default-require-extensions/-/default-require-extensions-3.0.1.tgz",
"integrity": "sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==",
"dev": true,
"dependencies": {
"strip-bom": "^4.0.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/diff": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz",
"integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
"dev": true,
"engines": {
"node": ">=0.3.1"
}
},
"node_modules/electron-to-chromium": {
"version": "1.4.284",
"resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz",
"integrity": "sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA==",
"dev": true
},
"node_modules/emoji-regex": {
"version": "8.0.0",
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
"dev": true
},
"node_modules/end-of-stream": {
"version": "1.4.4",
"resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
"integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
"dev": true,
"dependencies": {
"once": "^1.4.0"
}
},
"node_modules/es6-error": {
"version": "4.1.1",
"resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
"integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
"dev": true
},
"node_modules/escalade": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
"integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/escape-string-regexp": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
"integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
"dev": true,
"engines": {
"node": ">=0.8.0"
}
},
"node_modules/esprima": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
"integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
"dev": true,
"bin": {
"esparse": "bin/esparse.js",
"esvalidate": "bin/esvalidate.js"
},
"engines": {
"node": ">=4"
}
},
"node_modules/events-to-array": {
"version": "1.1.2",
"resolved": "https://registry.npmjs.org/events-to-array/-/events-to-array-1.1.2.tgz",
"integrity": "sha512-inRWzRY7nG+aXZxBzEqYKB3HPgwflZRopAjDCHv0whhRx+MTUr1ei0ICZUypdyE0HRm4L2d5VEcIqLD6yl+BFA==",
"dev": true
},
"node_modules/fill-range": {
"version": "7.0.1",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
"integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
"dev": true,
"dependencies": {
"to-regex-range": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/find-cache-dir": {
"version": "3.3.2",
"resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.2.tgz",
"integrity": "sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==",
"dev": true,
"dependencies": {
"commondir": "^1.0.1",
"make-dir": "^3.0.2",
"pkg-dir": "^4.1.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/avajs/find-cache-dir?sponsor=1"
}
},
"node_modules/find-up": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
"integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
"dev": true,
"dependencies": {
"locate-path": "^5.0.0",
"path-exists": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/findit": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/findit/-/findit-2.0.0.tgz",
"integrity": "sha512-ENZS237/Hr8bjczn5eKuBohLgaD0JyUd0arxretR1f9RO46vZHA1b2y0VorgGV3WaOT3c+78P8h7v4JGJ1i/rg==",
"dev": true
},
"node_modules/foreground-child": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-2.0.0.tgz",
"integrity": "sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==",
"dev": true,
"dependencies": {
"cross-spawn": "^7.0.0",
"signal-exit": "^3.0.2"
},
"engines": {
"node": ">=8.0.0"
}
},
"node_modules/fromentries": {
"version": "1.3.2",
"resolved": "https://registry.npmjs.org/fromentries/-/fromentries-1.3.2.tgz",
"integrity": "sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==",
"dev": true,
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
]
},
"node_modules/fs-exists-cached": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/fs-exists-cached/-/fs-exists-cached-1.0.0.tgz",
"integrity": "sha512-kSxoARUDn4F2RPXX48UXnaFKwVU7Ivd/6qpzZL29MCDmr9sTvybv4gFCp+qaI4fM9m0z9fgz/yJvi56GAz+BZg==",
"dev": true
},
"node_modules/fs.realpath": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
"integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
"dev": true
},
"node_modules/fsevents": {
"version": "2.3.2",
"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
"integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
"dev": true,
"hasInstallScript": true,
"optional": true,
"os": [
"darwin"
],
"engines": {
"node": "^8.16.0 || ^10.6.0 || >=11.0.0"
}
},
"node_modules/function-loop": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/function-loop/-/function-loop-2.0.1.tgz",
"integrity": "sha512-ktIR+O6i/4h+j/ZhZJNdzeI4i9lEPeEK6UPR2EVyTVBqOwcU3Za9xYKLH64ZR9HmcROyRrOkizNyjjtWJzDDkQ==",
"dev": true
},
"node_modules/gensync": {
"version": "1.0.0-beta.2",
"resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
"integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
"dev": true,
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/get-caller-file": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
"integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
"dev": true,
"engines": {
"node": "6.* || 8.* || >= 10.*"
}
},
"node_modules/get-package-type": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
"integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
"dev": true,
"engines": {
"node": ">=8.0.0"
}
},
"node_modules/glob": {
"version": "7.2.3",
"resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
"integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
"dev": true,
"dependencies": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.1.1",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
},
"engines": {
"node": "*"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dev": true,
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/globals": {
"version": "11.12.0",
"resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
"integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/graceful-fs": {
"version": "4.2.10",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz",
"integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==",
"dev": true
},
"node_modules/has-flag": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
"integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/hasha": {
"version": "5.2.2",
"resolved": "https://registry.npmjs.org/hasha/-/hasha-5.2.2.tgz",
"integrity": "sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==",
"dev": true,
"dependencies": {
"is-stream": "^2.0.0",
"type-fest": "^0.8.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/html-escaper": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
"integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
"dev": true
},
"node_modules/imurmurhash": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
"integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
"dev": true,
"engines": {
"node": ">=0.8.19"
}
},
"node_modules/indent-string": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
"integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/inflight": {
"version": "1.0.6",
"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
"integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
"dev": true,
"dependencies": {
"once": "^1.3.0",
"wrappy": "1"
}
},
"node_modules/inherits": {
"version": "2.0.4",
"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
"dev": true
},
"node_modules/is-binary-path": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
"dev": true,
"dependencies": {
"binary-extensions": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/is-extglob": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
"integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-fullwidth-code-point": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
"integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/is-glob": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
"integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
"dev": true,
"dependencies": {
"is-extglob": "^2.1.1"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-number": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
"dev": true,
"engines": {
"node": ">=0.12.0"
}
},
"node_modules/is-stream": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
"integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
"dev": true,
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/is-typedarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz",
"integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==",
"dev": true
},
"node_modules/is-windows": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
"integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/isarray": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
"integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
"dev": true
},
"node_modules/isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
"integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
"dev": true
},
"node_modules/istanbul-lib-coverage": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz",
"integrity": "sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-hook": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/istanbul-lib-hook/-/istanbul-lib-hook-3.0.0.tgz",
"integrity": "sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==",
"dev": true,
"dependencies": {
"append-transform": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-instrument": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz",
"integrity": "sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==",
"dev": true,
"dependencies": {
"@babel/core": "^7.7.5",
"@istanbuljs/schema": "^0.1.2",
"istanbul-lib-coverage": "^3.0.0",
"semver": "^6.3.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-processinfo": {
"version": "2.0.3",
"resolved": "https://registry.npmjs.org/istanbul-lib-processinfo/-/istanbul-lib-processinfo-2.0.3.tgz",
"integrity": "sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==",
"dev": true,
"dependencies": {
"archy": "^1.0.0",
"cross-spawn": "^7.0.3",
"istanbul-lib-coverage": "^3.2.0",
"p-map": "^3.0.0",
"rimraf": "^3.0.0",
"uuid": "^8.3.2"
},
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-report": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz",
"integrity": "sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==",
"dev": true,
"dependencies": {
"istanbul-lib-coverage": "^3.0.0",
"make-dir": "^3.0.0",
"supports-color": "^7.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-report/node_modules/has-flag": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-report/node_modules/supports-color": {
"version": "7.2.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
"dev": true,
"dependencies": {
"has-flag": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/istanbul-lib-source-maps": {
"version": "4.0.1",
"resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz",
"integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==",
"dev": true,
"dependencies": {
"debug": "^4.1.1",
"istanbul-lib-coverage": "^3.0.0",
"source-map": "^0.6.1"
},
"engines": {
"node": ">=10"
}
},
"node_modules/istanbul-reports": {
"version": "3.1.5",
"resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.5.tgz",
"integrity": "sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==",
"dev": true,
"dependencies": {
"html-escaper": "^2.0.0",
"istanbul-lib-report": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/jackspeak": {
"version": "1.4.2",
"resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-1.4.2.tgz",
"integrity": "sha512-GHeGTmnuaHnvS+ZctRB01bfxARuu9wW83ENbuiweu07SFcVlZrJpcshSre/keGT7YGBhLHg/+rXCNSrsEHKU4Q==",
"dev": true,
"dependencies": {
"cliui": "^7.0.4"
},
"engines": {
"node": ">=8"
}
},
"node_modules/js-tokens": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
"integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
"dev": true
},
"node_modules/js-yaml": {
"version": "3.14.1",
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
"integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
"dev": true,
"dependencies": {
"argparse": "^1.0.7",
"esprima": "^4.0.0"
},
"bin": {
"js-yaml": "bin/js-yaml.js"
}
},
"node_modules/jsesc": {
"version": "2.5.2",
"resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
"integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
"dev": true,
"bin": {
"jsesc": "bin/jsesc"
},
"engines": {
"node": ">=4"
}
},
"node_modules/json5": {
"version": "2.2.3",
"resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
"integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
"dev": true,
"bin": {
"json5": "lib/cli.js"
},
"engines": {
"node": ">=6"
}
},
"node_modules/jsonc-parser": {
"version": "3.2.0",
"resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
"integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==",
"dev": true
},
"node_modules/libtap": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/libtap/-/libtap-1.4.0.tgz",
"integrity": "sha512-STLFynswQ2A6W14JkabgGetBNk6INL1REgJ9UeNKw5llXroC2cGLgKTqavv0sl8OLVztLLipVKMcQ7yeUcqpmg==",
"dev": true,
"dependencies": {
"async-hook-domain": "^2.0.4",
"bind-obj-methods": "^3.0.0",
"diff": "^4.0.2",
"function-loop": "^2.0.1",
"minipass": "^3.1.5",
"own-or": "^1.0.0",
"own-or-env": "^1.0.2",
"signal-exit": "^3.0.4",
"stack-utils": "^2.0.4",
"tap-parser": "^11.0.0",
"tap-yaml": "^1.0.0",
"tcompare": "^5.0.6",
"trivial-deferred": "^1.0.1"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/locate-path": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
"integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
"dev": true,
"dependencies": {
"p-locate": "^4.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/lodash.flattendeep": {
"version": "4.4.0",
"resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz",
"integrity": "sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==",
"dev": true
},
"node_modules/lru-cache": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
"integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
"dev": true,
"dependencies": {
"yallist": "^3.0.2"
}
},
"node_modules/lru-cache/node_modules/yallist": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
"integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
"dev": true
},
"node_modules/lunr": {
"version": "2.3.9",
"resolved": "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz",
"integrity": "sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==",
"dev": true
},
"node_modules/make-dir": {
"version": "3.1.0",
"resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
"integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
"dev": true,
"dependencies": {
"semver": "^6.0.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/make-error": {
"version": "1.3.6",
"resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
"integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
"dev": true
},
"node_modules/marked": {
"version": "4.2.12",
"resolved": "https://registry.npmjs.org/marked/-/marked-4.2.12.tgz",
"integrity": "sha512-yr8hSKa3Fv4D3jdZmtMMPghgVt6TWbk86WQaWhDloQjRSQhMMYCAro7jP7VDJrjjdV8pxVxMssXS8B8Y5DZ5aw==",
"dev": true,
"bin": {
"marked": "bin/marked.js"
},
"engines": {
"node": ">= 12"
}
},
"node_modules/minimatch": {
"version": "3.1.2",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
"dev": true,
"dependencies": {
"brace-expansion": "^1.1.7"
},
"engines": {
"node": "*"
}
},
"node_modules/minipass": {
"version": "3.3.6",
"resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
"integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
"dev": true,
"dependencies": {
"yallist": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/mkdirp": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
"integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
"dev": true,
"bin": {
"mkdirp": "bin/cmd.js"
},
"engines": {
"node": ">=10"
}
},
"node_modules/ms": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
"integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
"dev": true
},
"node_modules/node-abort-controller": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/node-abort-controller/-/node-abort-controller-3.1.1.tgz",
"integrity": "sha512-AGK2yQKIjRuqnc6VkX2Xj5d+QW8xZ87pa1UK6yA6ouUyuxfHuMP6umE5QK7UmTeOAymo+Zx1Fxiuw9rVx8taHQ==",
"dev": true
},
"node_modules/node-preload": {
"version": "0.2.1",
"resolved": "https://registry.npmjs.org/node-preload/-/node-preload-0.2.1.tgz",
"integrity": "sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==",
"dev": true,
"dependencies": {
"process-on-spawn": "^1.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/node-releases": {
"version": "2.0.8",
"resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.8.tgz",
"integrity": "sha512-dFSmB8fFHEH/s81Xi+Y/15DQY6VHW81nXRj86EMSL3lmuTmK1e+aT4wrFCkTbm+gSwkw4KpX+rT/pMM2c1mF+A==",
"dev": true
},
"node_modules/normalize-path": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
"integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/nyc": {
"version": "15.1.0",
"resolved": "https://registry.npmjs.org/nyc/-/nyc-15.1.0.tgz",
"integrity": "sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==",
"dev": true,
"dependencies": {
"@istanbuljs/load-nyc-config": "^1.0.0",
"@istanbuljs/schema": "^0.1.2",
"caching-transform": "^4.0.0",
"convert-source-map": "^1.7.0",
"decamelize": "^1.2.0",
"find-cache-dir": "^3.2.0",
"find-up": "^4.1.0",
"foreground-child": "^2.0.0",
"get-package-type": "^0.1.0",
"glob": "^7.1.6",
"istanbul-lib-coverage": "^3.0.0",
"istanbul-lib-hook": "^3.0.0",
"istanbul-lib-instrument": "^4.0.0",
"istanbul-lib-processinfo": "^2.0.2",
"istanbul-lib-report": "^3.0.0",
"istanbul-lib-source-maps": "^4.0.0",
"istanbul-reports": "^3.0.2",
"make-dir": "^3.0.0",
"node-preload": "^0.2.1",
"p-map": "^3.0.0",
"process-on-spawn": "^1.0.0",
"resolve-from": "^5.0.0",
"rimraf": "^3.0.0",
"signal-exit": "^3.0.2",
"spawn-wrap": "^2.0.0",
"test-exclude": "^6.0.0",
"yargs": "^15.0.2"
},
"bin": {
"nyc": "bin/nyc.js"
},
"engines": {
"node": ">=8.9"
}
},
"node_modules/once": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
"dev": true,
"dependencies": {
"wrappy": "1"
}
},
"node_modules/opener": {
"version": "1.5.2",
"resolved": "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz",
"integrity": "sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==",
"dev": true,
"bin": {
"opener": "bin/opener-bin.js"
}
},
"node_modules/own-or": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/own-or/-/own-or-1.0.0.tgz",
"integrity": "sha512-NfZr5+Tdf6MB8UI9GLvKRs4cXY8/yB0w3xtt84xFdWy8hkGjn+JFc60VhzS/hFRfbyxFcGYMTjnF4Me+RbbqrA==",
"dev": true
},
"node_modules/own-or-env": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/own-or-env/-/own-or-env-1.0.2.tgz",
"integrity": "sha512-NQ7v0fliWtK7Lkb+WdFqe6ky9XAzYmlkXthQrBbzlYbmFKoAYbDDcwmOm6q8kOuwSRXW8bdL5ORksploUJmWgw==",
"dev": true,
"dependencies": {
"own-or": "^1.0.0"
}
},
"node_modules/p-limit": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
"integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
"dev": true,
"dependencies": {
"p-try": "^2.0.0"
},
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/p-locate": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
"integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
"dev": true,
"dependencies": {
"p-limit": "^2.2.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/p-map": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/p-map/-/p-map-3.0.0.tgz",
"integrity": "sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==",
"dev": true,
"dependencies": {
"aggregate-error": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/p-try": {
"version": "2.2.0",
"resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
"integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/package-hash": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/package-hash/-/package-hash-4.0.0.tgz",
"integrity": "sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==",
"dev": true,
"dependencies": {
"graceful-fs": "^4.1.15",
"hasha": "^5.0.0",
"lodash.flattendeep": "^4.4.0",
"release-zalgo": "^1.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/path-exists": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
"integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/path-is-absolute": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
"integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/path-key": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
"integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/picocolors": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
"integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
"dev": true
},
"node_modules/picomatch": {
"version": "2.3.1",
"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
"integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
"dev": true,
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/pkg-dir": {
"version": "4.2.0",
"resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz",
"integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==",
"dev": true,
"dependencies": {
"find-up": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/prettier": {
"version": "2.8.3",
"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.3.tgz",
"integrity": "sha512-tJ/oJ4amDihPoufT5sM0Z1SKEuKay8LfVAMlbbhnnkvt6BUserZylqo2PN+p9KeljLr0OHa2rXHU1T8reeoTrw==",
"dev": true,
"bin": {
"prettier": "bin-prettier.js"
},
"engines": {
"node": ">=10.13.0"
},
"funding": {
"url": "https://github.com/prettier/prettier?sponsor=1"
}
},
"node_modules/process-nextick-args": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
"integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
"dev": true
},
"node_modules/process-on-spawn": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/process-on-spawn/-/process-on-spawn-1.0.0.tgz",
"integrity": "sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==",
"dev": true,
"dependencies": {
"fromentries": "^1.2.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/punycode": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz",
"integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==",
"dev": true,
"engines": {
"node": ">=6"
}
},
"node_modules/readable-stream": {
"version": "2.3.7",
"resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
"integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
"dev": true,
"dependencies": {
"core-util-is": "~1.0.0",
"inherits": "~2.0.3",
"isarray": "~1.0.0",
"process-nextick-args": "~2.0.0",
"safe-buffer": "~5.1.1",
"string_decoder": "~1.1.1",
"util-deprecate": "~1.0.1"
}
},
"node_modules/readdirp": {
"version": "3.6.0",
"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
"integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
"dev": true,
"dependencies": {
"picomatch": "^2.2.1"
},
"engines": {
"node": ">=8.10.0"
}
},
"node_modules/release-zalgo": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/release-zalgo/-/release-zalgo-1.0.0.tgz",
"integrity": "sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==",
"dev": true,
"dependencies": {
"es6-error": "^4.0.1"
},
"engines": {
"node": ">=4"
}
},
"node_modules/require-directory": {
"version": "2.1.1",
"resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
"integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/require-main-filename": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
"integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
"dev": true
},
"node_modules/resolve-from": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
"integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/rimraf": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
"integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
"dev": true,
"dependencies": {
"glob": "^7.1.3"
},
"bin": {
"rimraf": "bin.js"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/safe-buffer": {
"version": "5.1.2",
"resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
"integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
"dev": true
},
"node_modules/semver": {
"version": "6.3.0",
"resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
"integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
"dev": true,
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/set-blocking": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
"integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
"dev": true
},
"node_modules/shebang-command": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
"integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
"dev": true,
"dependencies": {
"shebang-regex": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/shebang-regex": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
"integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/shiki": {
"version": "0.12.1",
"resolved": "https://registry.npmjs.org/shiki/-/shiki-0.12.1.tgz",
"integrity": "sha512-aieaV1m349rZINEBkjxh2QbBvFFQOlgqYTNtCal82hHj4dDZ76oMlQIX+C7ryerBTDiga3e5NfH6smjdJ02BbQ==",
"dev": true,
"dependencies": {
"jsonc-parser": "^3.2.0",
"vscode-oniguruma": "^1.7.0",
"vscode-textmate": "^8.0.0"
}
},
"node_modules/signal-exit": {
"version": "3.0.7",
"resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
"integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
"dev": true
},
"node_modules/source-map": {
"version": "0.6.1",
"resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
"integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/source-map-support": {
"version": "0.5.21",
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
"integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
"dev": true,
"dependencies": {
"buffer-from": "^1.0.0",
"source-map": "^0.6.0"
}
},
"node_modules/spawn-wrap": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/spawn-wrap/-/spawn-wrap-2.0.0.tgz",
"integrity": "sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==",
"dev": true,
"dependencies": {
"foreground-child": "^2.0.0",
"is-windows": "^1.0.2",
"make-dir": "^3.0.0",
"rimraf": "^3.0.0",
"signal-exit": "^3.0.2",
"which": "^2.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/sprintf-js": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
"integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
"dev": true
},
"node_modules/stack-utils": {
"version": "2.0.6",
"resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
"integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
"dev": true,
"dependencies": {
"escape-string-regexp": "^2.0.0"
},
"engines": {
"node": ">=10"
}
},
"node_modules/stack-utils/node_modules/escape-string-regexp": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
"integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/string_decoder": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
"integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
"dev": true,
"dependencies": {
"safe-buffer": "~5.1.0"
}
},
"node_modules/string-width": {
"version": "4.2.3",
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
"dev": true,
"dependencies": {
"emoji-regex": "^8.0.0",
"is-fullwidth-code-point": "^3.0.0",
"strip-ansi": "^6.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-ansi": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
"dev": true,
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/strip-bom": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz",
"integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/supports-color": {
"version": "5.5.0",
"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
"integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
"dev": true,
"dependencies": {
"has-flag": "^3.0.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap": {
"version": "16.3.4",
"resolved": "https://registry.npmjs.org/tap/-/tap-16.3.4.tgz",
"integrity": "sha512-SAexdt2ZF4XBgye6TPucFI2y7VE0qeFXlXucJIV1XDPCs+iJodk0MYacr1zR6Ycltzz7PYg8zrblDXKbAZM2LQ==",
"bundleDependencies": [
"ink",
"treport",
"@types/react",
"@isaacs/import-jsx",
"react"
],
"dev": true,
"dependencies": {
"@isaacs/import-jsx": "^4.0.1",
"@types/react": "^17.0.52",
"chokidar": "^3.3.0",
"findit": "^2.0.0",
"foreground-child": "^2.0.0",
"fs-exists-cached": "^1.0.0",
"glob": "^7.2.3",
"ink": "^3.2.0",
"isexe": "^2.0.0",
"istanbul-lib-processinfo": "^2.0.3",
"jackspeak": "^1.4.2",
"libtap": "^1.4.0",
"minipass": "^3.3.4",
"mkdirp": "^1.0.4",
"nyc": "^15.1.0",
"opener": "^1.5.1",
"react": "^17.0.2",
"rimraf": "^3.0.0",
"signal-exit": "^3.0.6",
"source-map-support": "^0.5.16",
"tap-mocha-reporter": "^5.0.3",
"tap-parser": "^11.0.2",
"tap-yaml": "^1.0.2",
"tcompare": "^5.0.7",
"treport": "^3.0.4",
"which": "^2.0.2"
},
"bin": {
"tap": "bin/run.js"
},
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
},
"peerDependencies": {
"coveralls": "^3.1.1",
"flow-remove-types": ">=2.112.0",
"ts-node": ">=8.5.2",
"typescript": ">=3.7.2"
},
"peerDependenciesMeta": {
"coveralls": {
"optional": true
},
"flow-remove-types": {
"optional": true
},
"ts-node": {
"optional": true
},
"typescript": {
"optional": true
}
}
},
"node_modules/tap-mocha-reporter": {
"version": "5.0.3",
"resolved": "https://registry.npmjs.org/tap-mocha-reporter/-/tap-mocha-reporter-5.0.3.tgz",
"integrity": "sha512-6zlGkaV4J+XMRFkN0X+yuw6xHbE9jyCZ3WUKfw4KxMyRGOpYSRuuQTRJyWX88WWuLdVTuFbxzwXhXuS2XE6o0g==",
"dev": true,
"dependencies": {
"color-support": "^1.1.0",
"debug": "^4.1.1",
"diff": "^4.0.1",
"escape-string-regexp": "^2.0.0",
"glob": "^7.0.5",
"tap-parser": "^11.0.0",
"tap-yaml": "^1.0.0",
"unicode-length": "^2.0.2"
},
"bin": {
"tap-mocha-reporter": "index.js"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/tap-mocha-reporter/node_modules/escape-string-regexp": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
"integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/tap-parser": {
"version": "11.0.2",
"resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-11.0.2.tgz",
"integrity": "sha512-6qGlC956rcORw+fg7Fv1iCRAY8/bU9UabUAhs3mXRH6eRmVZcNPLheSXCYaVaYeSwx5xa/1HXZb1537YSvwDZg==",
"dev": true,
"dependencies": {
"events-to-array": "^1.0.1",
"minipass": "^3.1.6",
"tap-yaml": "^1.0.0"
},
"bin": {
"tap-parser": "bin/cmd.js"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/tap-yaml": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/tap-yaml/-/tap-yaml-1.0.2.tgz",
"integrity": "sha512-GegASpuqBnRNdT1U+yuUPZ8rEU64pL35WPBpCISWwff4dErS2/438barz7WFJl4Nzh3Y05tfPidZnH+GaV1wMg==",
"dev": true,
"dependencies": {
"yaml": "^1.10.2"
}
},
"node_modules/tap/node_modules/@ampproject/remapping": {
"version": "2.1.2",
"dev": true,
"inBundle": true,
"license": "Apache-2.0",
"dependencies": {
"@jridgewell/trace-mapping": "^0.3.0"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/tap/node_modules/@babel/code-frame": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/highlight": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/compat-data": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/core": {
"version": "7.17.8",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@ampproject/remapping": "^2.1.0",
"@babel/code-frame": "^7.16.7",
"@babel/generator": "^7.17.7",
"@babel/helper-compilation-targets": "^7.17.7",
"@babel/helper-module-transforms": "^7.17.7",
"@babel/helpers": "^7.17.8",
"@babel/parser": "^7.17.8",
"@babel/template": "^7.16.7",
"@babel/traverse": "^7.17.3",
"@babel/types": "^7.17.0",
"convert-source-map": "^1.7.0",
"debug": "^4.1.0",
"gensync": "^1.0.0-beta.2",
"json5": "^2.1.2",
"semver": "^6.3.0"
},
"engines": {
"node": ">=6.9.0"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/babel"
}
},
"node_modules/tap/node_modules/@babel/generator": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.17.0",
"jsesc": "^2.5.1",
"source-map": "^0.5.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-annotate-as-pure": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-compilation-targets": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/compat-data": "^7.17.7",
"@babel/helper-validator-option": "^7.16.7",
"browserslist": "^4.17.5",
"semver": "^6.3.0"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0"
}
},
"node_modules/tap/node_modules/@babel/helper-environment-visitor": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-function-name": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-get-function-arity": "^7.16.7",
"@babel/template": "^7.16.7",
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-get-function-arity": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-hoist-variables": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-module-imports": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-module-transforms": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-environment-visitor": "^7.16.7",
"@babel/helper-module-imports": "^7.16.7",
"@babel/helper-simple-access": "^7.17.7",
"@babel/helper-split-export-declaration": "^7.16.7",
"@babel/helper-validator-identifier": "^7.16.7",
"@babel/template": "^7.16.7",
"@babel/traverse": "^7.17.3",
"@babel/types": "^7.17.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-plugin-utils": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-simple-access": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.17.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-split-export-declaration": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-validator-identifier": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helper-validator-option": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/helpers": {
"version": "7.17.8",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/template": "^7.16.7",
"@babel/traverse": "^7.17.3",
"@babel/types": "^7.17.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/highlight": {
"version": "7.16.10",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-validator-identifier": "^7.16.7",
"chalk": "^2.0.0",
"js-tokens": "^4.0.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/parser": {
"version": "7.17.8",
"dev": true,
"inBundle": true,
"license": "MIT",
"bin": {
"parser": "bin/babel-parser.js"
},
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/tap/node_modules/@babel/plugin-proposal-object-rest-spread": {
"version": "7.17.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/compat-data": "^7.17.0",
"@babel/helper-compilation-targets": "^7.16.7",
"@babel/helper-plugin-utils": "^7.16.7",
"@babel/plugin-syntax-object-rest-spread": "^7.8.3",
"@babel/plugin-transform-parameters": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/plugin-syntax-jsx": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-plugin-utils": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/plugin-syntax-object-rest-spread": {
"version": "7.8.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-plugin-utils": "^7.8.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/plugin-transform-destructuring": {
"version": "7.17.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-plugin-utils": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/plugin-transform-parameters": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-plugin-utils": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/plugin-transform-react-jsx": {
"version": "7.17.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-annotate-as-pure": "^7.16.7",
"@babel/helper-module-imports": "^7.16.7",
"@babel/helper-plugin-utils": "^7.16.7",
"@babel/plugin-syntax-jsx": "^7.16.7",
"@babel/types": "^7.17.0"
},
"engines": {
"node": ">=6.9.0"
},
"peerDependencies": {
"@babel/core": "^7.0.0-0"
}
},
"node_modules/tap/node_modules/@babel/template": {
"version": "7.16.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/code-frame": "^7.16.7",
"@babel/parser": "^7.16.7",
"@babel/types": "^7.16.7"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/traverse": {
"version": "7.17.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/code-frame": "^7.16.7",
"@babel/generator": "^7.17.3",
"@babel/helper-environment-visitor": "^7.16.7",
"@babel/helper-function-name": "^7.16.7",
"@babel/helper-hoist-variables": "^7.16.7",
"@babel/helper-split-export-declaration": "^7.16.7",
"@babel/parser": "^7.17.3",
"@babel/types": "^7.17.0",
"debug": "^4.1.0",
"globals": "^11.1.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@babel/types": {
"version": "7.17.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/helper-validator-identifier": "^7.16.7",
"to-fast-properties": "^2.0.0"
},
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/@isaacs/import-jsx": {
"version": "4.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@babel/core": "^7.5.5",
"@babel/plugin-proposal-object-rest-spread": "^7.5.5",
"@babel/plugin-transform-destructuring": "^7.5.0",
"@babel/plugin-transform-react-jsx": "^7.3.0",
"caller-path": "^3.0.1",
"find-cache-dir": "^3.2.0",
"make-dir": "^3.0.2",
"resolve-from": "^3.0.0",
"rimraf": "^3.0.0"
},
"engines": {
"node": ">=10"
}
},
"node_modules/tap/node_modules/@jridgewell/resolve-uri": {
"version": "3.0.5",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/tap/node_modules/@jridgewell/sourcemap-codec": {
"version": "1.4.11",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/@jridgewell/trace-mapping": {
"version": "0.3.4",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@jridgewell/resolve-uri": "^3.0.3",
"@jridgewell/sourcemap-codec": "^1.4.10"
}
},
"node_modules/tap/node_modules/@types/prop-types": {
"version": "15.7.4",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/@types/react": {
"version": "17.0.52",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@types/prop-types": "*",
"@types/scheduler": "*",
"csstype": "^3.0.2"
}
},
"node_modules/tap/node_modules/@types/scheduler": {
"version": "0.16.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/@types/yoga-layout": {
"version": "1.9.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/ansi-escapes": {
"version": "4.3.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"type-fest": "^0.21.3"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/ansi-escapes/node_modules/type-fest": {
"version": "0.21.3",
"dev": true,
"inBundle": true,
"license": "(MIT OR CC0-1.0)",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/ansi-regex": {
"version": "5.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/ansi-styles": {
"version": "3.2.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-convert": "^1.9.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/ansicolors": {
"version": "0.3.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/astral-regex": {
"version": "2.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/auto-bind": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/balanced-match": {
"version": "1.0.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/brace-expansion": {
"version": "1.1.11",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"balanced-match": "^1.0.0",
"concat-map": "0.0.1"
}
},
"node_modules/tap/node_modules/browserslist": {
"version": "4.20.2",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/browserslist"
}
],
"inBundle": true,
"license": "MIT",
"dependencies": {
"caniuse-lite": "^1.0.30001317",
"electron-to-chromium": "^1.4.84",
"escalade": "^3.1.1",
"node-releases": "^2.0.2",
"picocolors": "^1.0.0"
},
"bin": {
"browserslist": "cli.js"
},
"engines": {
"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
}
},
"node_modules/tap/node_modules/caller-callsite": {
"version": "4.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"callsites": "^3.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/caller-path": {
"version": "3.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"caller-callsite": "^4.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/callsites": {
"version": "3.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/caniuse-lite": {
"version": "1.0.30001319",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/caniuse-lite"
}
],
"inBundle": true,
"license": "CC-BY-4.0"
},
"node_modules/tap/node_modules/cardinal": {
"version": "2.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansicolors": "~0.3.2",
"redeyed": "~2.1.0"
},
"bin": {
"cdl": "bin/cdl.js"
}
},
"node_modules/tap/node_modules/chalk": {
"version": "2.4.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-styles": "^3.2.1",
"escape-string-regexp": "^1.0.5",
"supports-color": "^5.3.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/ci-info": {
"version": "2.0.0",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/cli-boxes": {
"version": "2.2.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/cli-cursor": {
"version": "3.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"restore-cursor": "^3.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/cli-truncate": {
"version": "2.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"slice-ansi": "^3.0.0",
"string-width": "^4.2.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/code-excerpt": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"convert-to-spaces": "^1.0.1"
},
"engines": {
"node": ">=10"
}
},
"node_modules/tap/node_modules/color-convert": {
"version": "1.9.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-name": "1.1.3"
}
},
"node_modules/tap/node_modules/color-name": {
"version": "1.1.3",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/commondir": {
"version": "1.0.1",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/concat-map": {
"version": "0.0.1",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/convert-source-map": {
"version": "1.8.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"safe-buffer": "~5.1.1"
}
},
"node_modules/tap/node_modules/convert-to-spaces": {
"version": "1.0.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">= 4"
}
},
"node_modules/tap/node_modules/csstype": {
"version": "3.0.11",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/debug": {
"version": "4.3.4",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ms": "2.1.2"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/tap/node_modules/electron-to-chromium": {
"version": "1.4.89",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/emoji-regex": {
"version": "8.0.0",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/escalade": {
"version": "3.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/escape-string-regexp": {
"version": "1.0.5",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=0.8.0"
}
},
"node_modules/tap/node_modules/esprima": {
"version": "4.0.1",
"dev": true,
"inBundle": true,
"license": "BSD-2-Clause",
"bin": {
"esparse": "bin/esparse.js",
"esvalidate": "bin/esvalidate.js"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/events-to-array": {
"version": "1.1.2",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/find-cache-dir": {
"version": "3.3.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"commondir": "^1.0.1",
"make-dir": "^3.0.2",
"pkg-dir": "^4.1.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/avajs/find-cache-dir?sponsor=1"
}
},
"node_modules/tap/node_modules/find-up": {
"version": "4.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"locate-path": "^5.0.0",
"path-exists": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/fs.realpath": {
"version": "1.0.0",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/gensync": {
"version": "1.0.0-beta.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6.9.0"
}
},
"node_modules/tap/node_modules/glob": {
"version": "7.2.3",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"fs.realpath": "^1.0.0",
"inflight": "^1.0.4",
"inherits": "2",
"minimatch": "^3.1.1",
"once": "^1.3.0",
"path-is-absolute": "^1.0.0"
},
"engines": {
"node": "*"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/tap/node_modules/globals": {
"version": "11.12.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/has-flag": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/indent-string": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/inflight": {
"version": "1.0.6",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"once": "^1.3.0",
"wrappy": "1"
}
},
"node_modules/tap/node_modules/inherits": {
"version": "2.0.4",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/ink": {
"version": "3.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-escapes": "^4.2.1",
"auto-bind": "4.0.0",
"chalk": "^4.1.0",
"cli-boxes": "^2.2.0",
"cli-cursor": "^3.1.0",
"cli-truncate": "^2.1.0",
"code-excerpt": "^3.0.0",
"indent-string": "^4.0.0",
"is-ci": "^2.0.0",
"lodash": "^4.17.20",
"patch-console": "^1.0.0",
"react-devtools-core": "^4.19.1",
"react-reconciler": "^0.26.2",
"scheduler": "^0.20.2",
"signal-exit": "^3.0.2",
"slice-ansi": "^3.0.0",
"stack-utils": "^2.0.2",
"string-width": "^4.2.2",
"type-fest": "^0.12.0",
"widest-line": "^3.1.0",
"wrap-ansi": "^6.2.0",
"ws": "^7.5.5",
"yoga-layout-prebuilt": "^1.9.6"
},
"engines": {
"node": ">=10"
},
"peerDependencies": {
"@types/react": ">=16.8.0",
"react": ">=16.8.0"
},
"peerDependenciesMeta": {
"@types/react": {
"optional": true
}
}
},
"node_modules/tap/node_modules/ink/node_modules/ansi-styles": {
"version": "4.3.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/tap/node_modules/ink/node_modules/chalk": {
"version": "4.1.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-styles": "^4.1.0",
"supports-color": "^7.1.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/chalk?sponsor=1"
}
},
"node_modules/tap/node_modules/ink/node_modules/color-convert": {
"version": "2.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/tap/node_modules/ink/node_modules/color-name": {
"version": "1.1.4",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/ink/node_modules/has-flag": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/ink/node_modules/supports-color": {
"version": "7.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"has-flag": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/is-ci": {
"version": "2.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ci-info": "^2.0.0"
},
"bin": {
"is-ci": "bin.js"
}
},
"node_modules/tap/node_modules/is-fullwidth-code-point": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/js-tokens": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/jsesc": {
"version": "2.5.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"bin": {
"jsesc": "bin/jsesc"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/json5": {
"version": "2.2.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"bin": {
"json5": "lib/cli.js"
},
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/locate-path": {
"version": "5.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"p-locate": "^4.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/lodash": {
"version": "4.17.21",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/loose-envify": {
"version": "1.4.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"js-tokens": "^3.0.0 || ^4.0.0"
},
"bin": {
"loose-envify": "cli.js"
}
},
"node_modules/tap/node_modules/make-dir": {
"version": "3.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"semver": "^6.0.0"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/mimic-fn": {
"version": "2.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/minimatch": {
"version": "3.1.2",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"brace-expansion": "^1.1.7"
},
"engines": {
"node": "*"
}
},
"node_modules/tap/node_modules/minipass": {
"version": "3.3.4",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"yallist": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/ms": {
"version": "2.1.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/node-releases": {
"version": "2.0.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/object-assign": {
"version": "4.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/once": {
"version": "1.4.0",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"wrappy": "1"
}
},
"node_modules/tap/node_modules/onetime": {
"version": "5.1.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"mimic-fn": "^2.1.0"
},
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/p-limit": {
"version": "2.3.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"p-try": "^2.0.0"
},
"engines": {
"node": ">=6"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/p-locate": {
"version": "4.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"p-limit": "^2.2.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/p-try": {
"version": "2.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/patch-console": {
"version": "1.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=10"
}
},
"node_modules/tap/node_modules/path-exists": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/path-is-absolute": {
"version": "1.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/picocolors": {
"version": "1.0.0",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/pkg-dir": {
"version": "4.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"find-up": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/punycode": {
"version": "2.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=6"
}
},
"node_modules/tap/node_modules/react": {
"version": "17.0.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"loose-envify": "^1.1.0",
"object-assign": "^4.1.1"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/react-devtools-core": {
"version": "4.24.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"shell-quote": "^1.6.1",
"ws": "^7"
}
},
"node_modules/tap/node_modules/react-reconciler": {
"version": "0.26.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"loose-envify": "^1.1.0",
"object-assign": "^4.1.1",
"scheduler": "^0.20.2"
},
"engines": {
"node": ">=0.10.0"
},
"peerDependencies": {
"react": "^17.0.2"
}
},
"node_modules/tap/node_modules/redeyed": {
"version": "2.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"esprima": "~4.0.0"
}
},
"node_modules/tap/node_modules/resolve-from": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/restore-cursor": {
"version": "3.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"onetime": "^5.1.0",
"signal-exit": "^3.0.2"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/rimraf": {
"version": "3.0.2",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"glob": "^7.1.3"
},
"bin": {
"rimraf": "bin.js"
},
"funding": {
"url": "https://github.com/sponsors/isaacs"
}
},
"node_modules/tap/node_modules/safe-buffer": {
"version": "5.1.2",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/scheduler": {
"version": "0.20.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"loose-envify": "^1.1.0",
"object-assign": "^4.1.1"
}
},
"node_modules/tap/node_modules/semver": {
"version": "6.3.0",
"dev": true,
"inBundle": true,
"license": "ISC",
"bin": {
"semver": "bin/semver.js"
}
},
"node_modules/tap/node_modules/shell-quote": {
"version": "1.7.3",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/signal-exit": {
"version": "3.0.7",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/slice-ansi": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-styles": "^4.0.0",
"astral-regex": "^2.0.0",
"is-fullwidth-code-point": "^3.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/slice-ansi/node_modules/ansi-styles": {
"version": "4.3.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/tap/node_modules/slice-ansi/node_modules/color-convert": {
"version": "2.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/tap/node_modules/slice-ansi/node_modules/color-name": {
"version": "1.1.4",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/source-map": {
"version": "0.5.7",
"dev": true,
"inBundle": true,
"license": "BSD-3-Clause",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/stack-utils": {
"version": "2.0.5",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"escape-string-regexp": "^2.0.0"
},
"engines": {
"node": ">=10"
}
},
"node_modules/tap/node_modules/stack-utils/node_modules/escape-string-regexp": {
"version": "2.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/string-width": {
"version": "4.2.3",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"emoji-regex": "^8.0.0",
"is-fullwidth-code-point": "^3.0.0",
"strip-ansi": "^6.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/strip-ansi": {
"version": "6.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-regex": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/supports-color": {
"version": "5.5.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"has-flag": "^3.0.0"
},
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/tap-parser": {
"version": "11.0.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"events-to-array": "^1.0.1",
"minipass": "^3.1.6",
"tap-yaml": "^1.0.0"
},
"bin": {
"tap-parser": "bin/cmd.js"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/tap/node_modules/tap-yaml": {
"version": "1.0.2",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"yaml": "^1.10.2"
}
},
"node_modules/tap/node_modules/to-fast-properties": {
"version": "2.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=4"
}
},
"node_modules/tap/node_modules/treport": {
"version": "3.0.4",
"dev": true,
"inBundle": true,
"license": "ISC",
"dependencies": {
"@isaacs/import-jsx": "^4.0.1",
"cardinal": "^2.1.1",
"chalk": "^3.0.0",
"ink": "^3.2.0",
"ms": "^2.1.2",
"tap-parser": "^11.0.0",
"tap-yaml": "^1.0.0",
"unicode-length": "^2.0.2"
},
"peerDependencies": {
"react": "^17.0.2"
}
},
"node_modules/tap/node_modules/treport/node_modules/ansi-styles": {
"version": "4.3.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/tap/node_modules/treport/node_modules/chalk": {
"version": "3.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-styles": "^4.1.0",
"supports-color": "^7.1.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/treport/node_modules/color-convert": {
"version": "2.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/tap/node_modules/treport/node_modules/color-name": {
"version": "1.1.4",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/treport/node_modules/has-flag": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/treport/node_modules/supports-color": {
"version": "7.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"has-flag": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/type-fest": {
"version": "0.12.0",
"dev": true,
"inBundle": true,
"license": "(MIT OR CC0-1.0)",
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/tap/node_modules/unicode-length": {
"version": "2.0.2",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"punycode": "^2.0.0",
"strip-ansi": "^3.0.1"
}
},
"node_modules/tap/node_modules/unicode-length/node_modules/ansi-regex": {
"version": "2.1.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/unicode-length/node_modules/strip-ansi": {
"version": "3.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-regex": "^2.0.0"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/tap/node_modules/widest-line": {
"version": "3.1.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"string-width": "^4.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/wrap-ansi": {
"version": "6.2.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"ansi-styles": "^4.0.0",
"string-width": "^4.1.0",
"strip-ansi": "^6.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tap/node_modules/wrap-ansi/node_modules/ansi-styles": {
"version": "4.3.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/tap/node_modules/wrap-ansi/node_modules/color-convert": {
"version": "2.0.1",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/tap/node_modules/wrap-ansi/node_modules/color-name": {
"version": "1.1.4",
"dev": true,
"inBundle": true,
"license": "MIT"
},
"node_modules/tap/node_modules/wrappy": {
"version": "1.0.2",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/ws": {
"version": "7.5.7",
"dev": true,
"inBundle": true,
"license": "MIT",
"engines": {
"node": ">=8.3.0"
},
"peerDependencies": {
"bufferutil": "^4.0.1",
"utf-8-validate": "^5.0.2"
},
"peerDependenciesMeta": {
"bufferutil": {
"optional": true
},
"utf-8-validate": {
"optional": true
}
}
},
"node_modules/tap/node_modules/yallist": {
"version": "4.0.0",
"dev": true,
"inBundle": true,
"license": "ISC"
},
"node_modules/tap/node_modules/yaml": {
"version": "1.10.2",
"dev": true,
"inBundle": true,
"license": "ISC",
"engines": {
"node": ">= 6"
}
},
"node_modules/tap/node_modules/yoga-layout-prebuilt": {
"version": "1.10.0",
"dev": true,
"inBundle": true,
"license": "MIT",
"dependencies": {
"@types/yoga-layout": "1.9.2"
},
"engines": {
"node": ">=8"
}
},
"node_modules/tcompare": {
"version": "5.0.7",
"resolved": "https://registry.npmjs.org/tcompare/-/tcompare-5.0.7.tgz",
"integrity": "sha512-d9iddt6YYGgyxJw5bjsN7UJUO1kGOtjSlNy/4PoGYAjQS5pAT/hzIoLf1bZCw+uUxRmZJh7Yy1aA7xKVRT9B4w==",
"dev": true,
"dependencies": {
"diff": "^4.0.2"
},
"engines": {
"node": ">=10"
}
},
"node_modules/test-exclude": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz",
"integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==",
"dev": true,
"dependencies": {
"@istanbuljs/schema": "^0.1.2",
"glob": "^7.1.4",
"minimatch": "^3.0.4"
},
"engines": {
"node": ">=8"
}
},
"node_modules/through2": {
"version": "2.0.5",
"resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz",
"integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
"dev": true,
"dependencies": {
"readable-stream": "~2.3.6",
"xtend": "~4.0.1"
}
},
"node_modules/to-fast-properties": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
"integrity": "sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==",
"dev": true,
"engines": {
"node": ">=4"
}
},
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
"dev": true,
"dependencies": {
"is-number": "^7.0.0"
},
"engines": {
"node": ">=8.0"
}
},
"node_modules/trivial-deferred": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/trivial-deferred/-/trivial-deferred-1.0.1.tgz",
"integrity": "sha512-dagAKX7vaesNNAwOc9Np9C2mJ+7YopF4lk+jE2JML9ta4kZ91Y6UruJNH65bLRYoUROD8EY+Pmi44qQWwXR7sw==",
"dev": true
},
"node_modules/ts-node": {
"version": "10.9.1",
"resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz",
"integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==",
"dev": true,
"dependencies": {
"@cspotcode/source-map-support": "^0.8.0",
"@tsconfig/node10": "^1.0.7",
"@tsconfig/node12": "^1.0.7",
"@tsconfig/node14": "^1.0.0",
"@tsconfig/node16": "^1.0.2",
"acorn": "^8.4.1",
"acorn-walk": "^8.1.1",
"arg": "^4.1.0",
"create-require": "^1.1.0",
"diff": "^4.0.1",
"make-error": "^1.1.1",
"v8-compile-cache-lib": "^3.0.1",
"yn": "3.1.1"
},
"bin": {
"ts-node": "dist/bin.js",
"ts-node-cwd": "dist/bin-cwd.js",
"ts-node-esm": "dist/bin-esm.js",
"ts-node-script": "dist/bin-script.js",
"ts-node-transpile-only": "dist/bin-transpile.js",
"ts-script": "dist/bin-script-deprecated.js"
},
"peerDependencies": {
"@swc/core": ">=1.2.50",
"@swc/wasm": ">=1.2.50",
"@types/node": "*",
"typescript": ">=2.7"
},
"peerDependenciesMeta": {
"@swc/core": {
"optional": true
},
"@swc/wasm": {
"optional": true
}
}
},
"node_modules/type-fest": {
"version": "0.8.1",
"resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
"integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
"dev": true,
"engines": {
"node": ">=8"
}
},
"node_modules/typedarray-to-buffer": {
"version": "3.1.5",
"resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz",
"integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==",
"dev": true,
"dependencies": {
"is-typedarray": "^1.0.0"
}
},
"node_modules/typedoc": {
"version": "0.23.24",
"resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.23.24.tgz",
"integrity": "sha512-bfmy8lNQh+WrPYcJbtjQ6JEEsVl/ce1ZIXyXhyW+a1vFrjO39t6J8sL/d6FfAGrJTc7McCXgk9AanYBSNvLdIA==",
"dev": true,
"dependencies": {
"lunr": "^2.3.9",
"marked": "^4.2.5",
"minimatch": "^5.1.2",
"shiki": "^0.12.1"
},
"bin": {
"typedoc": "bin/typedoc"
},
"engines": {
"node": ">= 14.14"
},
"peerDependencies": {
"typescript": "4.6.x || 4.7.x || 4.8.x || 4.9.x"
}
},
"node_modules/typedoc/node_modules/brace-expansion": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
"integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
"dev": true,
"dependencies": {
"balanced-match": "^1.0.0"
}
},
"node_modules/typedoc/node_modules/minimatch": {
"version": "5.1.6",
"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
"integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
"dev": true,
"dependencies": {
"brace-expansion": "^2.0.1"
},
"engines": {
"node": ">=10"
}
},
"node_modules/typescript": {
"version": "4.9.4",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.4.tgz",
"integrity": "sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg==",
"dev": true,
"bin": {
"tsc": "bin/tsc",
"tsserver": "bin/tsserver"
},
"engines": {
"node": ">=4.2.0"
}
},
"node_modules/unicode-length": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/unicode-length/-/unicode-length-2.1.0.tgz",
"integrity": "sha512-4bV582zTV9Q02RXBxSUMiuN/KHo5w4aTojuKTNT96DIKps/SIawFp7cS5Mu25VuY1AioGXrmYyzKZUzh8OqoUw==",
"dev": true,
"dependencies": {
"punycode": "^2.0.0"
}
},
"node_modules/update-browserslist-db": {
"version": "1.0.10",
"resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz",
"integrity": "sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ==",
"dev": true,
"funding": [
{
"type": "opencollective",
"url": "https://opencollective.com/browserslist"
},
{
"type": "tidelift",
"url": "https://tidelift.com/funding/github/npm/browserslist"
}
],
"dependencies": {
"escalade": "^3.1.1",
"picocolors": "^1.0.0"
},
"bin": {
"browserslist-lint": "cli.js"
},
"peerDependencies": {
"browserslist": ">= 4.21.0"
}
},
"node_modules/util-deprecate": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
"integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
"dev": true
},
"node_modules/uuid": {
"version": "8.3.2",
"resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
"integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
"dev": true,
"bin": {
"uuid": "dist/bin/uuid"
}
},
"node_modules/v8-compile-cache-lib": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
"integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
"dev": true
},
"node_modules/vscode-oniguruma": {
"version": "1.7.0",
"resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz",
"integrity": "sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==",
"dev": true
},
"node_modules/vscode-textmate": {
"version": "8.0.0",
"resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-8.0.0.tgz",
"integrity": "sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==",
"dev": true
},
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
"integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
"dev": true,
"dependencies": {
"isexe": "^2.0.0"
},
"bin": {
"node-which": "bin/node-which"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/which-module": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz",
"integrity": "sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q==",
"dev": true
},
"node_modules/wrap-ansi": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
"integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
"dev": true,
"dependencies": {
"ansi-styles": "^4.0.0",
"string-width": "^4.1.0",
"strip-ansi": "^6.0.0"
},
"engines": {
"node": ">=10"
},
"funding": {
"url": "https://github.com/chalk/wrap-ansi?sponsor=1"
}
},
"node_modules/wrap-ansi/node_modules/ansi-styles": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
"dev": true,
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/wrap-ansi/node_modules/color-convert": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
"dev": true,
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/wrap-ansi/node_modules/color-name": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
"dev": true
},
"node_modules/wrappy": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
"dev": true
},
"node_modules/write-file-atomic": {
"version": "3.0.3",
"resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz",
"integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==",
"dev": true,
"dependencies": {
"imurmurhash": "^0.1.4",
"is-typedarray": "^1.0.0",
"signal-exit": "^3.0.2",
"typedarray-to-buffer": "^3.1.5"
}
},
"node_modules/xtend": {
"version": "4.0.2",
"resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
"integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
"dev": true,
"engines": {
"node": ">=0.4"
}
},
"node_modules/y18n": {
"version": "4.0.3",
"resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
"integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==",
"dev": true
},
"node_modules/yallist": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
"integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
"dev": true
},
"node_modules/yaml": {
"version": "1.10.2",
"resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz",
"integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==",
"dev": true,
"engines": {
"node": ">= 6"
}
},
"node_modules/yargs": {
"version": "15.4.1",
"resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz",
"integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
"dev": true,
"dependencies": {
"cliui": "^6.0.0",
"decamelize": "^1.2.0",
"find-up": "^4.1.0",
"get-caller-file": "^2.0.1",
"require-directory": "^2.1.1",
"require-main-filename": "^2.0.0",
"set-blocking": "^2.0.0",
"string-width": "^4.2.0",
"which-module": "^2.0.0",
"y18n": "^4.0.0",
"yargs-parser": "^18.1.2"
},
"engines": {
"node": ">=8"
}
},
"node_modules/yargs-parser": {
"version": "18.1.3",
"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz",
"integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
"dev": true,
"dependencies": {
"camelcase": "^5.0.0",
"decamelize": "^1.2.0"
},
"engines": {
"node": ">=6"
}
},
"node_modules/yargs/node_modules/ansi-styles": {
"version": "4.3.0",
"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
"dev": true,
"dependencies": {
"color-convert": "^2.0.1"
},
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/chalk/ansi-styles?sponsor=1"
}
},
"node_modules/yargs/node_modules/cliui": {
"version": "6.0.0",
"resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz",
"integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
"dev": true,
"dependencies": {
"string-width": "^4.2.0",
"strip-ansi": "^6.0.0",
"wrap-ansi": "^6.2.0"
}
},
"node_modules/yargs/node_modules/color-convert": {
"version": "2.0.1",
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
"dev": true,
"dependencies": {
"color-name": "~1.1.4"
},
"engines": {
"node": ">=7.0.0"
}
},
"node_modules/yargs/node_modules/color-name": {
"version": "1.1.4",
"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
"dev": true
},
"node_modules/yargs/node_modules/wrap-ansi": {
"version": "6.2.0",
"resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
"integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
"dev": true,
"dependencies": {
"ansi-styles": "^4.0.0",
"string-width": "^4.1.0",
"strip-ansi": "^6.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/yn": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
"integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
"dev": true,
"engines": {
"node": ">=6"
}
}
}
}
isaacs-minipass-ffdbee1/package.json 0000664 0000000 0000000 00000003321 14414631765 0017734 0 ustar 00root root 0000000 0000000 {
"name": "minipass",
"version": "5.0.0",
"description": "minimal implementation of a PassThrough stream",
"main": "./index.js",
"module": "./index.mjs",
"types": "./index.d.ts",
"exports": {
".": {
"import": {
"types": "./index.d.ts",
"default": "./index.mjs"
},
"require": {
"types": "./index.d.ts",
"default": "./index.js"
}
},
"./package.json": "./package.json"
},
"devDependencies": {
"@types/node": "^17.0.41",
"end-of-stream": "^1.4.0",
"node-abort-controller": "^3.1.1",
"prettier": "^2.6.2",
"tap": "^16.2.0",
"through2": "^2.0.3",
"ts-node": "^10.8.1",
"typedoc": "^0.23.24",
"typescript": "^4.7.3"
},
"scripts": {
"pretest": "npm run prepare",
"presnap": "npm run prepare",
"prepare": "node ./scripts/transpile-to-esm.js",
"snap": "tap",
"test": "tap",
"preversion": "npm test",
"postversion": "npm publish",
"postpublish": "git push origin --follow-tags",
"typedoc": "typedoc ./index.d.ts",
"format": "prettier --write . --loglevel warn"
},
"repository": {
"type": "git",
"url": "git+https://github.com/isaacs/minipass.git"
},
"keywords": [
"passthrough",
"stream"
],
"author": "Isaac Z. Schlueter (http://blog.izs.me/)",
"license": "ISC",
"files": [
"index.d.ts",
"index.js",
"index.mjs"
],
"tap": {
"check-coverage": true
},
"engines": {
"node": ">=8"
},
"prettier": {
"semi": false,
"printWidth": 80,
"tabWidth": 2,
"useTabs": false,
"singleQuote": true,
"jsxSingleQuote": false,
"bracketSameLine": true,
"arrowParens": "avoid",
"endOfLine": "lf"
}
}
isaacs-minipass-ffdbee1/scripts/ 0000775 0000000 0000000 00000000000 14414631765 0017136 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/scripts/transpile-to-esm.js 0000664 0000000 0000000 00000000712 14414631765 0022677 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
const { readFileSync, writeFileSync } = require('fs')
const { resolve } = require('path')
const cjs = readFileSync(resolve(__dirname, '../index.js'), 'utf8')
const esm = cjs
.replace(/exports\.Minipass\s*=[^\n]*/, '')
.replace(/class Minipass /, 'export class Minipass ')
.replace(
/const ([a-zA-Z0-9]+)\s*=\s*require\('([^']+)'\)/g,
`import $1 from '$2'`
)
writeFileSync(resolve(__dirname, '../index.mjs'), esm, 'utf8')
isaacs-minipass-ffdbee1/tap-snapshots/ 0000775 0000000 0000000 00000000000 14414631765 0020253 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/tap-snapshots/test/ 0000775 0000000 0000000 00000000000 14414631765 0021232 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/tap-snapshots/test/basic.js.test.cjs 0000664 0000000 0000000 00000000703 14414631765 0024405 0 ustar 00root root 0000000 0000000 /* IMPORTANT
* This snapshot file is auto-generated, but designed for humans.
* It should be checked into source control and tracked carefully.
* Re-generate by setting TAP_SNAPSHOT=1 and running tests.
* Make sure to inspect the output below. Do not ignore changes!
*/
'use strict'
exports[`test/basic.js TAP objectMode allows falsey values for data > must match snapshot 1`] = `
Array [
"",
null,
undefined,
0,
null,
Array [],
]
`
isaacs-minipass-ffdbee1/test/ 0000775 0000000 0000000 00000000000 14414631765 0016426 5 ustar 00root root 0000000 0000000 isaacs-minipass-ffdbee1/test/abort.js 0000664 0000000 0000000 00000003112 14414631765 0020070 0 ustar 00root root 0000000 0000000 const { Minipass: MM } = require('../')
const t = require('tap')
if (typeof AbortSignal === 'undefined') {
Object.assign(global, require('node-abort-controller'))
}
const ac = new AbortController()
const m = new MM({ signal: ac.signal, encoding: 'utf8' })
const er = new Error('operation aborted')
let sawAbort = false
m.on('abort', e => {
sawAbort = true
t.equal(e, er)
})
m.write('hello')
t.equal(m.aborted, false)
m.aborted = 123
t.equal(m.aborted, false)
const d = new MM({ encoding: 'utf8' })
m.pipe(d)
ac.abort(er)
t.equal(sawAbort, true)
t.equal(m.read(), null)
t.equal(m.write(' world'), false)
t.equal(m.read(), null)
t.equal(m.aborted, true)
m.aborted = 123
t.equal(m.aborted, true)
t.equal(d.read(), 'hello')
t.equal(d.read(), null)
t.test('aborting rejects .promise() and friends', async t => {
const ac = new AbortController()
const m = new MM({ encoding: 'utf8', signal: ac.signal })
m.write('hello')
const testp = t.rejects(m.promise())
ac.abort(new Error('abort'))
await testp
})
t.test('having a signal means errors are nonfatal', t => {
const ac = new AbortController()
const m = new MM({ encoding: 'utf8', signal: ac.signal })
m.emit('error', new Error('this is fine'))
t.end()
})
t.test('pre-aborted stream', t => {
const ac = new AbortController()
ac.abort(new Error('operation aborted before it began'))
const m = new MM({ signal: ac.signal })
t.equal(m.aborted, true)
m.on('data', () => t.fail('should not get any data'))
t.equal(m.write('no op writing'), false)
m.end()
t.equal(m.write('even write after end is no op'), false)
t.end()
})
isaacs-minipass-ffdbee1/test/array-buffers.js 0000664 0000000 0000000 00000003334 14414631765 0021537 0 ustar 00root root 0000000 0000000 const t = require('tap')
const stringToArrayBuffer = s => {
const buf = Buffer.from(s)
const ab = new ArrayBuffer(buf.length)
const ui = new Uint8Array(ab)
for (let i = 0; i < buf.length; i++) {
ui[i] = buf[i]
}
return ab
}
const { Minipass: MP } = require('../')
const e = { encoding: 'utf8' }
t.test('write array buffer', t => {
const ab = stringToArrayBuffer('hello world')
const mp = new MP(e).end(ab)
t.equal(mp.objectMode, false, 'array buffer does not trigger objectMode')
return mp.concat().then(s => t.equal(s, 'hello world'))
})
t.test('write uint8 typed array', t => {
const ab = stringToArrayBuffer('hello world')
const ui = new Uint8Array(ab, 0, 5)
const mp = new MP(e).end(ui)
t.equal(mp.objectMode, false, 'typed array does not trigger objectMode')
return mp.concat().then(s => t.equal(s, 'hello'))
})
const { ArrayBuffer: VMArrayBuffer, Uint8Array: VMUint8Array } =
require('vm').runInNewContext('({ArrayBuffer,Uint8Array})')
const stringToVMArrayBuffer = s => {
const buf = Buffer.from(s)
const ab = new VMArrayBuffer(buf.length)
const ui = new VMUint8Array(ab)
for (let i = 0; i < buf.length; i++) {
ui[i] = buf[i]
}
return ab
}
t.test('write vm array buffer', t => {
const ab = stringToVMArrayBuffer('hello world')
const mp = new MP(e).end(ab)
t.equal(mp.objectMode, false, 'array buffer does not trigger objectMode')
return mp.concat().then(s => t.equal(s, 'hello world'))
})
t.test('write uint8 typed array', t => {
const ab = stringToVMArrayBuffer('hello world')
const ui = new VMUint8Array(ab, 0, 5)
const mp = new MP(e).end(ui)
t.equal(mp.objectMode, false, 'typed array does not trigger objectMode')
return mp.concat().then(s => t.equal(s, 'hello'))
})
isaacs-minipass-ffdbee1/test/async-duplicate-end.js 0000664 0000000 0000000 00000000567 14414631765 0022625 0 ustar 00root root 0000000 0000000 const { Minipass } = require('../')
const t = require('tap')
t.test('async pipes should only end one time', t => {
const m = new Minipass({ async: true })
let ended = 0
const d = new Minipass()
d.end = () => {
ended++
Minipass.prototype.end.call(d)
}
m.pipe(d)
m.end()
m.end()
m.end()
setTimeout(() => {
t.equal(ended, 1)
t.end()
})
})
isaacs-minipass-ffdbee1/test/async-stream.js 0000664 0000000 0000000 00000004365 14414631765 0021402 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
t.test('pipe', t => {
const m = new MP({ encoding: 'utf8', async: true })
const d1 = new MP({ encoding: 'utf8' })
const d2 = new MP({ encoding: 'utf8' })
m.pipe(d1)
m.write('hello, ')
m.pipe(d2)
m.write('world')
m.end()
return Promise.all([d1.concat(), d2.concat()]).then(result =>
t.strictSame(result, ['hello, world', 'hello, world'])
)
})
t.test('pipe split', t => {
const m = new MP({ encoding: 'utf8' })
t.equal(m.async, false)
m.async = true
t.equal(m.async, true)
m.async = 'banana'
t.equal(m.async, true)
m.async = false
t.equal(m.async, true, 'cannot make an async stream sync')
const d1 = new MP({ encoding: 'utf8' })
const d2 = new MP({ encoding: 'utf8' })
m.pipe(d1)
m.write('hello, ')
m.pipe(d2)
setTimeout(() => {
m.write('world')
m.end()
})
return Promise.all([d1.concat(), d2.concat()]).then(result =>
t.strictSame(result, ['hello, world', 'hello, world'])
)
})
t.test('data event', t => {
const m = new MP({ encoding: 'utf8', async: true })
const d1 = new MP({ encoding: 'utf8' })
const out1 = []
m.on('data', c => out1.push(c))
m.write('hello, ')
const out2 = []
m.on('data', c => out2.push(c))
m.pipe(d1)
m.end('world!')
return d1.concat().then(res => {
t.equal(res, 'hello, world!')
t.equal(out1.join(''), 'hello, world!')
t.equal(out2.join(''), 'hello, world!')
})
})
t.test('data event split', t => {
const m = new MP({ encoding: 'utf8', async: true })
const d1 = new MP({ encoding: 'utf8' })
const out1 = []
m.on('data', c => out1.push(c))
m.write('hello, ')
const out2 = []
m.on('data', c => out2.push(c))
m.pipe(d1)
setTimeout(() => m.end('world!'))
return d1.concat().then(res => {
t.equal(res, 'hello, world!')
t.equal(out1.join(''), 'hello, world!')
t.equal(out2.join(''), 'hello, world!')
})
})
t.test('defer error event', t => {
const m = new MP()
try {
m.emit('error', new Error('poop'))
} catch (_) {}
m.async = true
let calledErrorHandler = false
m.on('error', er => {
t.equal(calledErrorHandler, false)
t.match(er, { message: 'poop' })
calledErrorHandler = true
t.end()
})
t.equal(calledErrorHandler, false)
})
isaacs-minipass-ffdbee1/test/auto-end-deferred-when-paused.js 0000664 0000000 0000000 00000000543 14414631765 0024476 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
t.test('do not auto-end empty stream if explicitly paused', t => {
const mp = new MP()
let waitedForEnd = false
mp.pause()
setTimeout(() => {
waitedForEnd = true
mp.resume()
})
return mp
.end()
.promise()
.then(() => t.ok(waitedForEnd, 'waited for end'))
})
isaacs-minipass-ffdbee1/test/basic.js 0000664 0000000 0000000 00000031113 14414631765 0020044 0 ustar 00root root 0000000 0000000 const { Minipass } = require('../')
const t = require('tap')
const EE = require('events').EventEmitter
t.test('some basic piping and writing', async t => {
let mp = new Minipass({ encoding: 'base64', debugExposeBuffer: true })
t.notOk(mp.flowing)
mp.flowing = true
t.notOk(mp.flowing)
t.equal(mp.encoding, 'base64')
mp.encoding = null
t.equal(mp.encoding, null)
t.equal(mp.readable, true)
t.equal(mp.writable, true)
t.equal(mp.write('hello'), false)
let dest = new Minipass({ debugExposeBuffer: true })
let sawDestData = false
dest.once('data', chunk => {
sawDestData = true
t.type(chunk, Buffer)
})
t.equal(mp.pipe(dest), dest, 'pipe returns dest')
t.ok(sawDestData, 'got data becasue pipe() flushes')
t.equal(mp.write('bye'), true, 'write() returns true when flowing')
dest.pause()
t.equal(mp.write('after pause'), false, 'false when dest is paused')
t.equal(mp.write('after false'), false, 'false when not flowing')
t.equal(dest.buffer.length, 1, '1 item is buffered in dest')
t.equal(mp.buffer.length, 1, '1 item buffered in src')
dest.resume()
t.equal(dest.buffer.length, 0, 'nothing is buffered in dest')
t.equal(mp.buffer.length, 0, 'nothing buffered in src')
})
t.test('unicode splitting', async t => {
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'utf8' })
t.plan(2)
t.equal(mp.encoding, 'utf8')
mp.on('data', chunk => {
t.equal(chunk, butterfly)
})
const butterbuf = Buffer.from([0xf0, 0x9f, 0xa6, 0x8b])
mp.write(butterbuf.slice(0, 1))
mp.write(butterbuf.slice(1, 2))
mp.write(butterbuf.slice(2, 3))
mp.write(butterbuf.slice(3, 4))
mp.end()
})
t.test('unicode splitting with setEncoding', async t => {
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'hex' })
t.plan(4)
t.equal(mp.encoding, 'hex')
mp.setEncoding('hex')
t.equal(mp.encoding, 'hex')
mp.setEncoding('utf8')
t.equal(mp.encoding, 'utf8')
mp.on('data', chunk => {
t.equal(chunk, butterfly)
})
const butterbuf = Buffer.from([0xf0, 0x9f, 0xa6, 0x8b])
mp.write(butterbuf.slice(0, 1))
mp.write(butterbuf.slice(1, 2))
mp.write(butterbuf.slice(2, 3))
mp.write(butterbuf.slice(3, 4))
mp.end()
})
t.test('base64 -> utf8 piping', t => {
t.plan(1)
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'base64' })
const dest = new Minipass({ encoding: 'utf8' })
mp.pipe(dest)
let out = ''
dest.on('data', c => (out += c))
dest.on('end', _ =>
t.equal(Buffer.from(out, 'base64').toString('utf8'), butterfly)
)
mp.write(butterfly)
mp.end()
})
t.test('utf8 -> base64 piping', t => {
t.plan(1)
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'utf8' })
const dest = new Minipass({ encoding: 'base64' })
mp.pipe(dest)
let out = ''
dest.on('data', c => (out += c))
dest.on('end', _ =>
t.equal(Buffer.from(out, 'base64').toString('utf8'), butterfly)
)
mp.write(butterfly)
mp.end()
})
t.test('read method', async t => {
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'utf8' })
mp.on('data', c => t.equal(c, butterfly))
mp.pause()
t.equal(mp.paused, true, 'paused=true')
mp.write(Buffer.from(butterfly))
t.equal(mp.read(5), null)
t.equal(mp.read(0), null)
t.same(mp.read(2), butterfly)
})
t.test('read with no args', async t => {
t.test('buffer -> string', async t => {
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'utf8' })
mp.on('data', c => t.equal(c, butterfly))
mp.pause()
const butterbuf = Buffer.from(butterfly)
mp.write(butterbuf.slice(0, 2))
mp.write(butterbuf.slice(2))
t.same(mp.read(), butterfly)
t.equal(mp.read(), null)
})
t.test('buffer -> buffer', async t => {
const butterfly = Buffer.from('🦋')
const mp = new Minipass()
mp.on('data', c => t.same(c, butterfly))
mp.pause()
mp.write(butterfly.slice(0, 2))
mp.write(butterfly.slice(2))
t.same(mp.read(), butterfly)
t.equal(mp.read(), null)
})
t.test('string -> buffer', async t => {
const butterfly = '🦋'
const butterbuf = Buffer.from(butterfly)
const mp = new Minipass()
mp.on('data', c => t.same(c, butterbuf))
mp.pause()
mp.write(butterfly)
t.same(mp.read(), butterbuf)
t.equal(mp.read(), null)
})
t.test('string -> string', async t => {
const butterfly = '🦋'
const mp = new Minipass({ encoding: 'utf8' })
mp.on('data', c => t.equal(c, butterfly))
mp.pause()
mp.write(butterfly[0])
mp.write(butterfly[1])
t.same(mp.read(), butterfly)
t.equal(mp.read(), null)
})
})
t.test('partial read', async t => {
const butterfly = '🦋'
const mp = new Minipass()
const butterbuf = Buffer.from(butterfly)
mp.write(butterbuf.slice(0, 1))
mp.write(butterbuf.slice(1, 2))
mp.write(butterbuf.slice(2, 3))
mp.write(butterbuf.slice(3, 4))
t.equal(mp.read(5), null)
t.equal(mp.read(0), null)
t.same(mp.read(2), butterbuf.slice(0, 2))
t.same(mp.read(2), butterbuf.slice(2, 4))
})
t.test('write after end', async t => {
const mp = new Minipass()
let sawEnd = false
mp.on('end', _ => (sawEnd = true))
mp.end('not empty')
t.throws(_ => mp.write('nope'))
t.notOk(sawEnd, 'should not get end event yet (not flowing)')
mp.resume()
t.equal(mp.paused, false, 'paused=false after resume')
t.ok(sawEnd, 'should get end event after resume()')
})
t.test('write after end', async t => {
const mp = new Minipass()
let sawEnd = 0
mp.on('end', _ => sawEnd++)
mp.end() // empty
t.ok(mp.emittedEnd, 'emitted end event')
t.throws(_ => mp.write('nope'))
t.equal(sawEnd, 1, 'should get end event (empty stream)')
mp.resume()
t.ok(sawEnd, 2, 'should get end event again, I guess?')
})
t.test('write cb', async t => {
const mp = new Minipass()
let calledCb = false
mp.write('ok', () => (calledCb = true))
t.ok(calledCb)
})
t.test('end with chunk', async t => {
let out = ''
const mp = new Minipass({ encoding: 'utf8' })
let sawEnd = false
mp.prependListener('end', _ => (sawEnd = true))
mp.addListener('data', c => (out += c))
let endCb = false
mp.end('ok', _ => (endCb = true))
t.equal(out, 'ok')
t.ok(sawEnd, 'should see end event')
t.ok(endCb, 'end cb should get called')
})
t.test('no drain if could not entirely drain on resume', async t => {
const mp = new Minipass()
const dest = new Minipass({ encoding: 'buffer' })
t.equal(mp.write('foo'), false)
t.equal(mp.write('bar'), false)
t.equal(mp.write('baz'), false)
t.equal(mp.write('qux'), false)
mp.on('drain', _ => t.fail('should not drain'))
mp.pipe(dest)
})
t.test('end with chunk pending', async t => {
const mp = new Minipass()
t.equal(mp.write('foo'), false)
t.equal(mp.write('626172', 'hex'), false)
t.equal(mp.write('baz'), false)
t.equal(mp.write('qux'), false)
let sawEnd = false
mp.on('end', _ => (sawEnd = true))
let endCb = false
mp.end(_ => (endCb = true))
t.notOk(endCb, 'endcb should not happen yet')
t.notOk(sawEnd, 'should not see end yet')
let out = ''
mp.on('data', c => (out += c))
t.ok(sawEnd, 'see end after flush')
t.ok(endCb, 'end cb after flush')
t.equal(out, 'foobarbazqux')
})
t.test('pipe to stderr does not throw', t => {
const spawn = require('child_process').spawn
const module = JSON.stringify(require.resolve('../'))
const fs = require('fs')
const file = __dirname + '/prog.js'
fs.writeFileSync(
file,
`
const { Minipass: MP } = require(${module})
const mp = new MP()
mp.pipe(process.stderr)
mp.end("hello")
`
)
let err = ''
return new Promise(res => {
const child = spawn(process.execPath, [file])
child.stderr.on('data', c => (err += c))
child.on('close', (code, signal) => {
t.equal(code, 0)
t.equal(signal, null)
t.equal(err, 'hello')
fs.unlinkSync(file)
res()
})
})
})
t.test('emit works with many args', t => {
const mp = new Minipass()
t.plan(2)
mp.on('foo', function (a, b, c, d, e, f, g) {
t.same([a, b, c, d, e, f, g], [1, 2, 3, 4, 5, 6, 7])
t.equal(arguments.length, 7)
})
mp.emit('foo', 1, 2, 3, 4, 5, 6, 7)
})
t.test('emit drain on resume, even if no flush', t => {
const mp = new Minipass({ debugExposeBuffer: true })
mp.encoding = 'utf8'
const chunks = []
class SlowStream extends EE {
write(chunk) {
chunks.push(chunk)
setTimeout(_ => this.emit('drain'))
return false
}
end() {
return this.write()
}
}
const ss = new SlowStream()
mp.pipe(ss)
t.ok(mp.flowing, 'flowing, because piped')
t.equal(mp.write('foo'), false, 'write() returns false, backpressure')
t.equal(mp.buffer.length, 0, 'buffer len is 0')
t.equal(mp.flowing, false, 'flowing false, awaiting drain')
t.same(chunks, ['foo'], 'chunk made it through')
mp.once('drain', _ => {
t.pass('received mp drain event')
t.end()
})
})
t.test('save close for end', t => {
const mp = new Minipass()
let ended = false
mp.on('close', _ => {
t.equal(ended, true, 'end before close')
t.end()
})
mp.on('end', _ => {
t.equal(ended, false, 'only end once')
ended = true
})
mp.emit('close')
mp.end('foo')
t.equal(ended, false, 'no end until flushed')
mp.resume()
})
t.test('eos works', t => {
const eos = require('end-of-stream')
const mp = new Minipass()
eos(mp, er => {
if (er) throw er
t.end()
})
mp.emit('close')
mp.end('foo')
mp.resume()
})
t.test('bufferLength property', t => {
const eos = require('end-of-stream')
const mp = new Minipass()
mp.write('a')
mp.write('a')
mp.write('a')
mp.write('a')
mp.write('a')
mp.write('a')
t.equal(mp.bufferLength, 6)
t.equal(mp.read(7), null)
t.equal(mp.read(3).toString(), 'aaa')
t.equal(mp.bufferLength, 3)
t.equal(mp.read().toString(), 'aaa')
t.equal(mp.bufferLength, 0)
t.end()
})
t.test('emit resume event on resume', t => {
const mp = new Minipass()
t.plan(3)
mp.on('resume', _ => t.pass('got resume event'))
mp.end('asdf')
t.equal(mp.flowing, false, 'not flowing yet')
mp.resume()
t.equal(mp.flowing, true, 'flowing after resume')
})
t.test('objectMode', t => {
const mp = new Minipass({ objectMode: true })
t.equal(mp.objectMode, true, 'objectMode getter returns value')
mp.objectMode = false
t.equal(mp.objectMode, true, 'objectMode getter is read-only')
const a = { a: 1 }
const b = { b: 1 }
const out = []
mp.on('data', c => out.push(c))
mp.on('end', _ => {
t.equal(out.length, 2)
t.equal(out[0], a)
t.equal(out[1], b)
t.same(out, [{ a: 1 }, { b: 1 }], 'objs not munged')
t.end()
})
t.ok(mp.write(a))
let cbcalled = false
t.ok(mp.write(b, () => (cbcalled = true)))
t.equal(cbcalled, true)
mp.end()
})
t.test('objectMode no encoding', t => {
const mp = new Minipass({
objectMode: true,
encoding: 'utf8',
})
t.equal(mp.encoding, null)
const a = { a: 1 }
const b = { b: 1 }
const out = []
mp.on('data', c => out.push(c))
mp.on('end', _ => {
t.equal(out.length, 2)
t.equal(out[0], a)
t.equal(out[1], b)
t.same(out, [{ a: 1 }, { b: 1 }], 'objs not munged')
t.end()
})
t.ok(mp.write(a))
t.ok(mp.write(b))
mp.end()
})
t.test('objectMode read() and buffering', t => {
const mp = new Minipass({ objectMode: true })
const a = { a: 1 }
const b = { b: 1 }
t.notOk(mp.write(a))
t.notOk(mp.write(b))
t.equal(mp.read(2), a)
t.equal(mp.read(), b)
t.end()
})
t.test('set encoding in object mode throws', async t =>
t.throws(
_ => (new Minipass({ objectMode: true }).encoding = 'utf8'),
new Error('cannot set encoding in objectMode')
)
)
t.test('set encoding again throws', async t =>
t.throws(_ => {
const mp = new Minipass({ encoding: 'hex' })
mp.write('ok')
mp.encoding = 'utf8'
}, new Error('cannot change encoding'))
)
t.test('set encoding with existing buffer', async t => {
const mp = new Minipass()
const butterfly = '🦋'
const butterbuf = Buffer.from(butterfly)
mp.write(butterbuf.slice(0, 1))
mp.write(butterbuf.slice(1, 2))
mp.setEncoding('utf8')
mp.write(butterbuf.slice(2))
t.equal(mp.read(), butterfly)
})
t.test('end:false', async t => {
t.plan(1)
const mp = new Minipass({ encoding: 'utf8' })
const d = new Minipass({ encoding: 'utf8' })
d.end = () => t.threw(new Error('no end no exit no way out'))
d.on('data', c => t.equal(c, 'this is fine'))
mp.pipe(d, { end: false })
mp.end('this is fine')
})
t.test('objectMode allows falsey values for data', t => {
const mp = new Minipass({ objectMode: true })
mp.write('')
mp.write(null)
mp.write(undefined)
const data = []
mp.on('end', () => {
t.matchSnapshot(data)
t.end()
})
mp.on('data', c => data.push(c))
mp.write(0)
mp.write(NaN)
mp.write([])
mp.end()
})
isaacs-minipass-ffdbee1/test/buffer-chunk-when-flowing-stops.js 0000664 0000000 0000000 00000002053 14414631765 0025113 0 ustar 00root root 0000000 0000000 // Reproduces an issue where write is called while the stream is flowing but a
// destination cannot accept all of the buffered chunks. minipass should add
// the chunk to the end of the buffer instead of emitting it before the buffer
// is cleared.
//
// This caused issues when piping make-fetch-happen stream to tar.extract
// https://github.com/npm/cli/issues/3884
const { Minipass } = require('../')
const t = require('tap')
class Pauser extends Minipass {
write(chunk, encoding, callback) {
super.write(chunk, encoding, callback)
return false
}
}
const src = new Minipass({ encoding: 'utf8' })
const pauser = new Pauser({ encoding: 'utf8' })
// queue up two chunks while the src is buffering
src.write('1')
src.write('2')
// when the src starts flowing write a third chunk
src.once('resume', () => src.write('3'))
// pipe the src to the pauser which will request the src stops after the first
// chunk.
src.pipe(pauser)
src.end()
// we should expect the chunks in the original order.
t.resolveMatch(pauser.collect(), ['1', '2', '3'], '123')
isaacs-minipass-ffdbee1/test/collect-with-error-end.js 0000664 0000000 0000000 00000000403 14414631765 0023252 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const mp = new MP()
const poop = new Error('poop')
mp.on('end', () => mp.emit('error', poop))
mp.end('foo')
const t = require('tap')
t.test('promise catches error emitted on end', t =>
t.rejects(mp.collect(), poop)
)
isaacs-minipass-ffdbee1/test/collect.js 0000664 0000000 0000000 00000002761 14414631765 0020417 0 ustar 00root root 0000000 0000000 'use strict'
const t = require('tap')
const { Minipass: MP } = require('../index.js')
t.test('basic', async t => {
const mp = new MP()
let i = 5
const interval = setInterval(() => {
if (i-- > 0) mp.write('foo\n')
else {
clearInterval(interval)
mp.end()
}
})
mp.setEncoding('utf8')
const all = await mp.collect()
t.same(all, ['foo\n', 'foo\n', 'foo\n', 'foo\n', 'foo\n'])
})
t.test('error', async t => {
const mp = new MP()
const poop = new Error('poop')
setTimeout(() => mp.emit('error', poop))
await t.rejects(mp.collect(), poop)
})
t.test('concat strings', async t => {
const mp = new MP({ encoding: 'utf8' })
mp.write('foo')
mp.write('bar')
mp.write('baz')
mp.end()
await t.resolveMatch(mp.concat(), 'foobarbaz')
})
t.test('concat buffers', async t => {
const mp = new MP()
mp.write('foo')
mp.write('bar')
mp.write('baz')
mp.end()
await t.resolveMatch(mp.concat(), Buffer.from('foobarbaz'))
})
t.test('concat objectMode fails', async t => {
const a = new MP({ objectMode: true })
await t.rejects(a.concat(), new Error('cannot concat in objectMode'))
const b = new MP()
b.write('asdf')
setTimeout(() => b.end({ foo: 1 }))
await t.rejects(b.concat(), new Error('cannot concat in objectMode'))
})
t.test('collect does not set bodyLength in objectMode', t =>
new MP({ objectMode: true })
.end({ a: 1 })
.collect()
.then(data => {
t.equal(typeof data.dataLength, 'undefined')
t.same(data, [{ a: 1 }])
})
)
isaacs-minipass-ffdbee1/test/dest-write-returns-nonboolean.js 0000664 0000000 0000000 00000001254 14414631765 0024705 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
t.test('writing to a non-bool returning write() does not pause', t => {
const booleyStream = new (class extends MP {
write(chunk, encoding, cb) {
// no return!
super.write(chunk, encoding, cb)
}
})()
const booleyStream2 = new (class extends MP {
write(chunk, encoding, cb) {
// no return!
super.write(chunk, encoding, cb)
}
})()
const src = new MP()
try {
return src
.pipe(booleyStream)
.pipe(booleyStream2)
.concat()
.then(d => t.equal(d.toString(), 'hello', 'got data all the way through'))
} finally {
src.end('hello')
}
})
isaacs-minipass-ffdbee1/test/destroy.js 0000664 0000000 0000000 00000004706 14414631765 0020464 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const t = require('tap')
t.match(new MP(), { destroy: Function }, 'destroy is implemented')
{
const mp = new MP()
t.equal(mp.destroy(), mp, 'destroy() returns this')
}
t.equal(new MP().destroy().destroyed, true, 'destroy() sets .destroyed getter')
t.test('destroy(er) emits error', t => {
const mp = new MP()
const er = new Error('skoarchhh')
const ret = t.rejects(() => mp.promise(), er)
mp.destroy(er)
return ret
})
t.test('calls close if present', t => {
const mp = new MP()
let closeCalled = false
mp.close = () => {
closeCalled = true
setTimeout(() => mp.emit('close'))
}
mp.on('close', () => {
t.equal(closeCalled, true, 'called close')
t.end()
})
mp.destroy()
})
t.test('destroy a second time just emits the error', t => {
const mp = new MP()
mp.destroy()
const er = new Error('skoarchhh')
const ret = t.rejects(() => mp.promise(), er)
mp.destroy(er)
return ret
})
t.test('destroy with no error rejects a promise', t => {
const mp = new MP()
const ret = t.rejects(() => mp.promise(), { message: 'stream destroyed' })
mp.destroy()
return ret
})
t.test('destroy with no error second time rejects a promise', t => {
const mp = new MP()
mp.destroy()
const ret = t.rejects(() => mp.promise(), { message: 'stream destroyed' })
mp.destroy()
return ret
})
t.test('emits after destruction are ignored', t => {
const mp = new MP().destroy()
mp.on('foo', () => t.fail('should not emit foo after destroy'))
mp.emit('foo')
t.end()
})
t.test('pipe after destroy is a no-op', t => {
const p = new MP()
p.write('foo')
p.destroy()
const q = new MP()
q.on('data', c => t.fail('should not get data, upstream is destroyed'))
p.pipe(q)
t.end()
})
t.test('resume after destroy is a no-op', t => {
const p = new MP()
p.pause()
p.on('resume', () => t.fail('should not see resume event after destroy'))
p.destroy()
p.resume()
t.end()
})
t.test('read after destroy always returns null', t => {
const p = new MP({ encoding: 'utf8' })
p.write('hello, ')
p.write('world')
t.equal(p.read(), 'hello, world')
p.write('destroyed!')
p.destroy()
t.equal(p.read(), null)
t.end()
})
t.test('write after destroy emits error', t => {
const p = new MP()
p.destroy()
p.on('error', er => {
t.match(er, {
message: 'Cannot call write after a stream was destroyed',
code: 'ERR_STREAM_DESTROYED',
})
t.end()
})
p.write('nope')
})
isaacs-minipass-ffdbee1/test/emit-during-end-event.js 0000664 0000000 0000000 00000000552 14414631765 0023075 0 ustar 00root root 0000000 0000000 const { Minipass } = require('../')
const t = require('tap')
class FancyEnder extends Minipass {
emit(ev, ...data) {
if (ev === 'end') this.emit('foo')
return super.emit(ev, ...data)
}
}
const mp = new FancyEnder()
let fooEmits = 0
mp.on('foo', () => fooEmits++)
mp.end('asdf')
mp.resume()
t.equal(fooEmits, 1, 'should only see one event emitted')
isaacs-minipass-ffdbee1/test/empty-buffer-end-with-encoding.js 0000664 0000000 0000000 00000002066 14414631765 0024676 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
const enc = { encoding: 'utf8' }
t.test('encoding and immediate end', t =>
new MP(enc)
.end()
.concat()
.then(s => t.equal(s, ''))
)
t.test('encoding and end with empty string', t =>
new MP(enc)
.end('')
.concat()
.then(s => t.equal(s, ''))
)
t.test('encoding and end with empty buffer', t =>
new MP(enc)
.end(Buffer.alloc(0))
.concat()
.then(s => t.equal(s, ''))
)
t.test('encoding and end with stringly empty buffer', t =>
new MP(enc)
.end(Buffer.from(''))
.concat()
.then(s => t.equal(s, ''))
)
t.test('encoding and write then end with empty buffer', t => {
const mp = new MP(enc)
mp.write('ok')
return mp
.end(Buffer.alloc(0))
.concat()
.then(s => t.equal(s, 'ok'))
})
t.test('encoding and write then end with empty string', t => {
const mp = new MP(enc)
mp.write('ok')
return mp
.end('')
.concat()
.then(s => t.equal(s, 'ok'))
})
t.test('empty write with cb', t => new MP(enc).write(Buffer.from(''), t.end))
isaacs-minipass-ffdbee1/test/empty-stream-emits-end-without-read.js 0000664 0000000 0000000 00000000216 14414631765 0025707 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const t = require('tap')
t.test('empty end emits end without reading', t => new MP().end().promise())
isaacs-minipass-ffdbee1/test/end-missed.js 0000664 0000000 0000000 00000001416 14414631765 0021016 0 ustar 00root root 0000000 0000000 'use strict'
const t = require('tap')
const { Minipass: MP } = require('../')
t.test('end is not missed if listened to after end', t => {
t.plan(1)
const mp = new MP()
mp.end('foo')
let str = ''
mp.on('data', d => (str += d))
mp.on('end', () => t.equal(str, 'foo'))
})
t.test('listening for any endish event after end re-emits', t => {
t.plan(1)
const mp = new MP()
mp.end('foo')
let str = ''
mp.on('data', d => (str += d))
mp.on('finish', () => t.equal(str, 'foo'))
})
t.test('all endish listeners get called', t => {
t.plan(3)
const mp = new MP()
let str = ''
mp.on('finish', () => t.equal(str, 'foo'))
mp.on('prefinish', () => t.equal(str, 'foo'))
mp.end('foo')
mp.on('data', d => (str += d))
mp.on('end', () => t.equal(str, 'foo'))
})
isaacs-minipass-ffdbee1/test/end-returns-this.js 0000664 0000000 0000000 00000000177 14414631765 0022204 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
const mp = new MP()
t.equal(mp.end(), mp, 'end returns this')
isaacs-minipass-ffdbee1/test/end-twice.js 0000664 0000000 0000000 00000001710 14414631765 0020642 0 ustar 00root root 0000000 0000000 'use strict'
const t = require('tap')
const { Minipass: MP } = require('../')
t.test('organic', t => {
const butterfly = Buffer.from([0x61, 0xf0, 0x9f, 0xa6, 0x8b, 0xf0])
const mp = new MP({ encoding: 'utf8' })
let sawEnd = 0
mp.on('end', () => t.equal(sawEnd++, 0, 'should not have seen the end yet'))
mp.once('data', () => {
mp.once('data', () => {
mp.once('data', () => mp.end())
mp.end()
})
mp.end(butterfly.slice(3))
})
mp.end(butterfly.slice(0, 3))
t.equal(sawEnd, 1, 'should see end exactly once')
t.end()
})
t.test('manufactured', t => {
// *should* already be impossible, but just to be even more
// deliberate, in case that wasn't the only way it could happen
const mp = new MP()
let sawEnd = 0
mp.on('end', () => {
t.equal(sawEnd++, 0, 'should not have seen the end yet')
mp.emit('end')
})
mp.emit('end')
mp.emit('end')
t.equal(sawEnd, 1, 'should see end exactly once')
t.end()
})
isaacs-minipass-ffdbee1/test/error-before-promise.js 0000664 0000000 0000000 00000003062 14414631765 0023032 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const t = require('tap')
t.test('emit an error before calling stream.promise()', t => {
const mp = new MP()
const poop = new Error('poop')
mp.once('error', er => t.equal(er, poop))
mp.emit('error', poop)
mp.end()
return t.rejects(mp.promise(), poop)
})
t.test('end properly when emitting error event', t => {
// this simulates a case where the 'emit' method is overridden
// in a child class to do special behavior on the 'end' event,
// which can cause an error to be emitted, in which case we
// still need to try to re-emit end if the error is handled.
// See http://npm.im/minipass-flush
const mp = new MP()
const poop = new Error('poop')
mp.on('error', er => t.equal(er, poop, 'catch all'))
let mpEnded = false
mp.on('end', () => {
mpEnded = true
t.pass('emitted mp end event')
if (pipelineEnded) t.end()
})
const { emit } = mp
let flushed = false
let flushing = false
mp.emit = (ev, ...data) => {
if (ev !== 'end' || flushed) return emit.call(mp, ev, ...data)
if (flushing) return
if (ev === 'end') {
flushing = true
Promise.resolve().then(() => {
flushed = true
mp.emit('error', poop)
})
} else {
return emit.call(mp, ev, ...data)
}
}
const src = new MP()
const dest = new MP()
let pipelineEnded = false
mp.pipe(dest)
.on('data', c => {
t.equal(c.toString(), 'ok')
})
.on('end', () => {
pipelineEnded = true
t.pass('pipeline ended')
if (mpEnded) t.end()
})
mp.end()
})
isaacs-minipass-ffdbee1/test/esm.mjs 0000664 0000000 0000000 00000000433 14414631765 0017725 0 ustar 00root root 0000000 0000000 import { Minipass } from '../index.mjs'
import t from 'tap'
t.test(`just make sure it's actually a stream`, async t => {
t.type(Minipass, 'function')
const m = new Minipass({ encoding: 'utf8' })
m.write('hello ')
m.end('world')
t.equal(await m.concat(), 'hello world')
})
isaacs-minipass-ffdbee1/test/flush-buffer-before-flowing.js 0000664 0000000 0000000 00000003036 14414631765 0024261 0 ustar 00root root 0000000 0000000 // this is a minimal reproduction of a pretty complex interaction between
// minipass-pipeline and a slow-draining proxy stream, which occurred in
// make-fetch-happen. https://github.com/npm/npm-registry-fetch/issues/23
// The pipeline in question was a wrapper that tee'd data into the cache,
// which is a slow-draining sink stream. When multiple chunks come through,
// the Pipeline's buffer is holding a chunk, but the Pipeline itself is in
// flowing mode. The solution is to always drain the buffer before emitting
// 'data', if there is other data waiting to be emitted.
const { Minipass } = require('../')
const t = require('tap')
const src = new Minipass({ encoding: 'utf8' })
const mid = new Minipass({ encoding: 'utf8' })
const proxy = new Minipass({ encoding: 'utf8' })
mid.write = function (chunk, encoding, cb) {
Minipass.prototype.write.call(this, chunk, encoding, cb)
return proxy.write(chunk, encoding, cb)
}
proxy.on('drain', chunk => mid.emit('drain'))
proxy.on('readable', () => setTimeout(() => proxy.read()))
const dest = new Minipass({ encoding: 'utf8' })
src.write('a')
src.write('b')
const pipeline = new (class Pipeline extends Minipass {
constructor(opt) {
super(opt)
dest.on('data', c => super.write(c))
dest.on('end', () => super.end())
}
emit(ev, ...args) {
if (ev === 'resume') dest.resume()
return super.emit(ev, ...args)
}
})({ encoding: 'utf8' })
mid.pipe(dest)
src.pipe(mid)
t.test('get all data', t => pipeline.concat().then(d => t.equal(d, 'abcd')))
src.write('c')
src.write('d')
src.end()
isaacs-minipass-ffdbee1/test/is-stream.js 0000664 0000000 0000000 00000002777 14414631765 0020705 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const EE = require('events')
const t = require('tap')
const Stream = require('stream')
t.equal(MP.isStream(new MP()), true, 'a MiniPass is a stream')
t.equal(MP.isStream(new Stream()), true, 'a Stream is a stream')
t.equal(new MP() instanceof Stream, true, 'a MiniPass is a Stream')
const w = new EE()
w.write = () => {}
w.end = () => {}
t.equal(MP.isStream(w), true, 'EE with write() and end() is a stream')
const r = new EE()
r.pipe = () => {}
t.equal(MP.isStream(r), true, 'EE with pipe() is a stream')
t.equal(
MP.isStream(new Stream.Readable()),
true,
'Stream.Readable() is a stream'
)
t.equal(
MP.isStream(new Stream.Writable()),
true,
'Stream.Writable() is a stream'
)
t.equal(MP.isStream(new Stream.Duplex()), true, 'Stream.Duplex() is a stream')
t.equal(
MP.isStream(new Stream.Transform()),
true,
'Stream.Transform() is a stream'
)
t.equal(
MP.isStream(new Stream.PassThrough()),
true,
'Stream.PassThrough() is a stream'
)
t.equal(
MP.isStream(new (class extends MP {})()),
true,
'extends MP is a stream'
)
t.equal(MP.isStream(new EE()), false, 'EE without streaminess is not a stream')
t.equal(
MP.isStream({
write() {},
end() {},
pipe() {},
}),
false,
'non-EE is not a stream'
)
t.equal(MP.isStream('hello'), false, 'string is not a stream')
t.equal(MP.isStream(99), false, 'number is not a stream')
t.equal(
MP.isStream(() => {}),
false,
'function is not a stream'
)
t.equal(MP.isStream(null), false, 'null is not a stream')
isaacs-minipass-ffdbee1/test/iterate-max-listener-test.js 0000664 0000000 0000000 00000003146 14414631765 0024010 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
// make warnings throw
Object.defineProperty(process, 'emitWarning', {
value: (...args) => {
throw new Error('got warning: ' + args.join(', '))
}
})
// create a stream that emits a bunch of things in chunks
const chunks = []
for (let i = 0; i < 10000; i++) {
chunks.push(String(i))
}
class EmitterStream extends MP {
constructor () {
super({ encoding: 'utf8' })
this.i = 0
this.p = new Promise(resolve => this.resolve = resolve)
this.interval = setInterval(() => {
for (let j = 0; j < 500 && this.i < chunks.length; j++) {
this.write(chunks[this.i++])
}
if (this.i === chunks.length) {
clearInterval(this.interval)
this.end()
this.resolve()
}
})
}
}
t.test('async iterate the emitter stream', async t => {
const actual = []
const s = new EmitterStream()
for await (const chunk of s) {
actual.push(chunk)
}
t.same(actual.join(''), chunks.join(''), 'got expected chunks')
})
t.test('sync iterate the emitter stream repeatedly', async t => {
const actual = []
const s = new EmitterStream()
s.on('readable', () => {
for (const chunk of s) {
if (!chunk) break
actual.push(chunk)
}
})
s.on('end', () => {
t.same(actual.join(''), chunks.join(''), 'got expected chunks')
})
})
t.test('sync iterate the emitter stream after completion', async t => {
const actual = []
const s = new EmitterStream()
await s.p
for (const chunk of s) {
actual.push(chunk)
}
t.same(actual.join(''), chunks.join(''), 'got expected chunks')
})
isaacs-minipass-ffdbee1/test/iteration-unsupported.js 0000664 0000000 0000000 00000000564 14414631765 0023355 0 ustar 00root root 0000000 0000000 'use strict'
const t = require('tap')
global._MP_NO_ITERATOR_SYMBOLS_ = '1'
const { Minipass: MP } = require('../index.js')
const mp = new MP()
mp.write('foo')
setTimeout(() => mp.end())
t.throws(() => {
for (let x of mp) {
t.fail('should not be iterable')
}
})
t.rejects(async () => {
for await (let x of mp) {
t.fail('should not be async iterable')
}
})
isaacs-minipass-ffdbee1/test/iteration.js 0000664 0000000 0000000 00000015506 14414631765 0020771 0 ustar 00root root 0000000 0000000 'use strict'
const t = require('tap')
const { Minipass: MP } = require('../index.js')
t.test('sync iteration', t => {
const cases = {
buffer: [null, [Buffer.from('ab'), Buffer.from('cd'), Buffer.from('e')]],
string: [{ encoding: 'utf8' }, ['ab', 'cd', 'e']],
object: [{ objectMode: true }, ['a', 'b', 'c', 'd', 'e']],
}
const runTest = (c, opt, expect) => {
t.test(c, t => {
const result = []
const mp = new MP(opt)
mp.write('a')
mp.write('b')
for (let letter of mp) {
result.push(letter)
}
mp.write('c')
mp.write('d')
result.push.call(result, ...mp)
mp.write('e')
mp.end()
for (let letter of mp) {
result.push(letter) // e
}
for (let letter of mp) {
result.push(letter) // nothing
}
t.match(result, expect)
t.end()
})
}
for (let c in cases) {
runTest(c, cases[c][0], cases[c][1])
}
t.test('destroy while iterating', t => {
const mp = new MP({ objectMode: true })
mp.write('a')
mp.write('b')
mp.write('c')
mp.write('d')
const result = []
for (let letter of mp) {
result.push(letter)
mp.destroy()
}
t.same(result, ['a'])
t.end()
})
t.end()
})
t.test('async iteration', t => {
const expect = [
'start\n',
'foo\n',
'foo\n',
'foo\n',
'foo\n',
'foo\n',
'bar\n',
]
t.test('end immediate', async t => {
const mp = new MP({ encoding: 'utf8' })
let i = 5
mp.write('start\n')
const inter = setInterval(() => {
if (i-- > 0) mp.write(Buffer.from('foo\n', 'utf8'))
else {
mp.end('bar\n')
clearInterval(inter)
}
})
const result = []
for await (let x of mp) result.push(x)
t.same(result, expect)
})
t.test('end later', async t => {
const mp = new MP({ encoding: 'utf8' })
let i = 5
mp.write('start\n')
const inter = setInterval(() => {
if (i-- > 0) mp.write(Buffer.from('foo\n', 'utf8'))
else {
mp.write('bar\n')
setTimeout(() => mp.end())
clearInterval(inter)
}
})
const result = []
for await (let x of mp) result.push(x)
t.same(result, expect)
})
t.test('multiple chunks at once, asyncly', async t => {
const mp = new MP()
let i = 6
const write = () => {
if (i === 6) mp.write(Buffer.from('start\n', 'utf8'))
else if (i > 0) mp.write('foo\n')
else if (i === 0) {
mp.end('bar\n')
clearInterval(inter)
}
i--
}
const inter = setInterval(() => {
write()
write()
write()
})
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.toString()).join(''), expect.join(''))
})
t.test('multiple object chunks at once, asyncly', async t => {
const mp = new MP({ objectMode: true })
let i = 6
const write = () => {
if (i === 6) mp.write(['start\n'])
else if (i > 0) mp.write(['foo\n'])
else if (i === 0) {
mp.end(['bar\n'])
clearInterval(inter)
}
i--
}
const inter = setInterval(() => {
write()
write()
write()
})
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.join('')).join(''), expect.join(''))
})
t.test('all chunks at once, asyncly', async t => {
const mp = new MP()
setTimeout(() => {
mp.write(Buffer.from('start\n', 'utf8'))
for (let i = 0; i < 5; i++) {
mp.write('foo\n')
}
mp.end('bar\n')
})
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.toString()).join(''), expect.join(''))
})
t.test('all object chunks at once, asyncly', async t => {
const mp = new MP({ objectMode: true })
setTimeout(() => {
mp.write(['start\n'])
for (let i = 0; i < 5; i++) {
mp.write(['foo\n'])
}
mp.end(['bar\n'])
})
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.join('')).join(''), expect.join(''))
})
t.test('all object chunks at once, syncly', async t => {
const mp = new MP({ objectMode: true })
mp.write(['start\n'])
for (let i = 0; i < 5; i++) {
mp.write(['foo\n'])
}
mp.end(['bar\n'])
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.join('')).join(''), expect.join(''))
})
t.test('pipe in all at once', async t => {
const inp = new MP({ encoding: 'utf8' })
const mp = new MP({ encoding: 'utf8' })
inp.pipe(mp)
let i = 5
inp.write('start\n')
const inter = setInterval(() => {
if (i-- > 0) inp.write(Buffer.from('foo\n', 'utf8'))
else {
inp.end('bar\n')
clearInterval(inter)
}
})
const result = []
for await (let x of mp) result.push(x)
t.same(result, expect)
})
t.test('pipe in multiple object chunks at once, asyncly', async t => {
const mp = new MP({ objectMode: true })
const inp = new MP({ objectMode: true })
inp.pipe(mp)
let i = 5
inp.write(['start\n'])
const write = () => {
if (i > 0) inp.write(['foo\n'])
else if (i === 0) {
inp.end(['bar\n'])
clearInterval(inter)
}
i--
}
const inter = setInterval(() => {
write()
write()
write()
})
const result = []
for await (let x of mp) result.push(x)
t.same(result.map(x => x.join('')).join(''), expect.join(''))
})
t.test('throw error', async t => {
const mp = new MP()
const poop = new Error('poop')
setTimeout(() => {
mp.read = () => {
throw poop
}
mp.end('this is fine')
})
const result = []
const run = async () => {
for await (let x of mp) {
result.push(x)
}
}
await t.rejects(run, poop)
})
t.test('emit error', async t => {
const mp = new MP()
const poop = new Error('poop')
setTimeout(() => mp.emit('error', poop))
const result = []
const run = async () => {
for await (let x of mp) {
result.push(x)
}
}
await t.rejects(run, poop)
})
t.test('destroy', async t => {
const mp = new MP()
setTimeout(() => mp.destroy())
const result = []
const run = async () => {
for await (let x of mp) {
result.push(x)
}
}
await t.rejects(run, { message: 'stream destroyed' })
})
t.end()
})
t.test('iterators are compliant Generators', async t => {
const mp = new MP({ encoding: 'utf8' })
const it = mp[Symbol.iterator]()
t.equal(it[Symbol.iterator](), it, 'sync is iterable iterator')
const ait = mp[Symbol.asyncIterator]()
t.equal(ait[Symbol.asyncIterator](), ait, 'async is iterable iterator')
t.same(await ait.throw('yeet'), { done: true })
t.same(await ait.next(), { done: true }, 'stopped by throw')
})
isaacs-minipass-ffdbee1/test/no-process-ok.js 0000664 0000000 0000000 00000000461 14414631765 0021464 0 ustar 00root root 0000000 0000000 const tap = require('tap')
const proc = global.process
global.process = null
const { Minipass: MP } = require('../')
const src = new MP()
const dest = new MP({ encoding: 'utf8' })
src.pipe(dest)
src.end('ok')
const result = dest.read()
global.process = proc
const t = require('tap')
t.equal(result, 'ok')
isaacs-minipass-ffdbee1/test/pipe-ended-stream.js 0000664 0000000 0000000 00000001336 14414631765 0022272 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass: MP } = require('../')
t.test('pipe from ended stream', t => {
const from = new MP()
from.end().on('end', () => {
t.equal(from.emittedEnd, true, 'from already emitted end')
from.pipe(new MP()).on('end', () => t.end())
})
})
t.test('pipe from ended stream with a promise', t => {
const from = new MP()
return from
.end()
.promise()
.then(() => from.pipe(new MP()).promise())
})
t.test('pipe from ended stream is no-op if {end:false}', async t => {
const from = new MP()
await from.end().promise()
const to = new MP({ encoding: 'utf8' })
from.pipe(to, { end: false })
to.write('this is fine')
to.end()
t.equal(await to.concat(), 'this is fine')
})
isaacs-minipass-ffdbee1/test/proxy-errors.js 0000664 0000000 0000000 00000003226 14414631765 0021462 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass } = require('../')
t.test('not proxied', t => {
const src = new Minipass()
const dest = new Minipass()
let srcEr = null
let destEr = null
src.on('error', er => (srcEr = er))
dest.on('error', er => (destEr = er))
src.pipe(dest)
src.emit('error', new Error('not proxied'))
t.match(srcEr, { message: 'not proxied' })
t.equal(destEr, null)
t.end()
})
t.test('proxied', t => {
const src = new Minipass()
const dest = new Minipass()
let srcEr = null
let destEr = null
src.on('error', er => (srcEr = er))
dest.on('error', er => (destEr = er))
src.pipe(dest, { proxyErrors: true })
// let the flow go
dest.resume()
src.emit('error', new Error('proxied'))
t.match(srcEr, { message: 'proxied' })
t.match(destEr, { message: 'proxied' })
t.end()
})
t.test('not proxied after stream end', t => {
const src = new Minipass()
const dest = new Minipass()
let srcEr = null
let destEr = null
src.on('error', er => (srcEr = er))
dest.on('error', er => (destEr = er))
src.pipe(dest, { proxyErrors: true })
// let the flow go
dest.resume()
src.end('hello')
src.emit('error', new Error('post end'))
t.match(srcEr, { message: 'post end' })
t.equal(destEr, null)
t.end()
})
t.test('not proxied after unpipe', t => {
const src = new Minipass()
const dest = new Minipass()
let srcEr = null
let destEr = null
src.on('error', er => (srcEr = er))
dest.on('error', er => (destEr = er))
src.pipe(dest, { proxyErrors: true })
src.unpipe(dest)
src.emit('error', new Error('unpiped'))
t.match(srcEr, { message: 'unpiped' })
t.equal(destEr, null)
t.end()
})
isaacs-minipass-ffdbee1/test/readable-emits-immediately.js 0000664 0000000 0000000 00000000570 14414631765 0024145 0 ustar 00root root 0000000 0000000 // https://github.com/isaacs/minipass/issues/36
const { Minipass } = require('../')
const t = require('tap')
const m = new Minipass({ encoding: 'utf8' })
m.write('hello')
t.equal(m.flowing, false)
let readableEmitted = false
m.on('readable', () => {
readableEmitted = true
m.on('data', c => t.equal(c, 'hello'))
})
t.equal(m.flowing, true)
t.equal(readableEmitted, true)
isaacs-minipass-ffdbee1/test/readable-only-when-buffering.js 0000664 0000000 0000000 00000000457 14414631765 0024414 0 ustar 00root root 0000000 0000000 const { Minipass: MP } = require('../')
const t = require('tap')
const mp = new MP()
let readables = 0
mp.on('readable', () => readables++)
const ondata = d => {}
mp.on('data', ondata)
t.equal(mp.write('foo'), true)
t.equal(readables, 0)
mp.pause()
t.equal(mp.write('foo'), false)
t.equal(readables, 1)
isaacs-minipass-ffdbee1/test/unpipe.js 0000664 0000000 0000000 00000001706 14414631765 0020270 0 ustar 00root root 0000000 0000000 const t = require('tap')
const { Minipass } = require('../')
const src = new Minipass({ encoding: 'utf8', debugExposePipes: true })
const dest = new Minipass({ encoding: 'utf8' })
const dest2 = new Minipass({ encoding: 'utf8' })
const destOut = []
const dest2Out = []
const srcOut = []
src.pipe(dest)
src.pipe(dest2)
dest.on('data', c => destOut.push(c))
dest2.on('data', c => dest2Out.push(c))
src.on('data', c => srcOut.push(c))
src.write('hello')
t.strictSame(destOut, ['hello'])
t.strictSame(dest2Out, ['hello'])
t.strictSame(srcOut, ['hello'])
t.match(src.pipes, [{ dest }, { dest: dest2 }])
src.unpipe(dest)
t.match(src.pipes, [{ dest: dest2 }])
src.unpipe(dest) // no-op
t.match(src.pipes, [{ dest: dest2 }])
src.write('world')
t.strictSame(destOut, ['hello'])
t.strictSame(dest2Out, ['hello', 'world'])
t.strictSame(srcOut, ['hello', 'world'])
src.end()
t.equal(dest.emittedEnd, false)
t.equal(src.emittedEnd, true)
t.equal(dest2.emittedEnd, true)
isaacs-minipass-ffdbee1/test/write-returns-true-when-readable-triggers-flow.js 0000664 0000000 0000000 00000003030 14414631765 0030054 0 ustar 00root root 0000000 0000000 // if you do s.on('readable', s => s.pipe(d)), then s.write() should return
// true, because even though s is not flowing at the START of the write(),
// it IS flowing by the END of the write call.
const { Minipass } = require('../')
const t = require('tap')
t.test('empty write', async t => {
const s = new Minipass({ encoding: 'utf8' })
const dest = new Minipass({ encoding: 'utf8' })
const p = dest.concat().then(d => t.equal(d, 'a', 'got data'))
t.equal(s.write('a'), false, 'first write returns false')
t.equal(s.write(''), false, 'empty write returns false')
// since readable emits immediately, the NEXT one needs to trigger
let firstReadable = false
s.on('readable', () => {
if (!firstReadable) firstReadable = true
else s.pipe(dest)
})
t.equal(s.flowing, false, 'src is not flowing yet')
t.equal(s.write(''), true, 'return true, now flowing')
s.end()
await p
})
t.test('non-empty write', async t => {
const s = new Minipass({ encoding: 'utf8' })
const dest = new Minipass({ encoding: 'utf8' })
const p = dest.concat().then(d => t.equal(d, 'ab', 'got data'))
t.equal(s.write('a'), false, 'first write returns false')
t.equal(s.write(''), false, 'empty write returns false')
// since readable emits immediately, the NEXT one needs to trigger
let firstReadable = false
s.on('readable', () => {
if (!firstReadable) firstReadable = true
else s.pipe(dest)
})
t.equal(s.flowing, false, 'src is not flowing yet')
t.equal(s.write('b'), true, 'return true, now flowing')
s.end()
await p
})
isaacs-minipass-ffdbee1/tsconfig.json 0000664 0000000 0000000 00000000664 14414631765 0020164 0 ustar 00root root 0000000 0000000 {
"exclude": ["./tap-snapshots"],
"include": ["./index.d.ts"],
"compilerOptions": {
"declaration": true,
"sourceMap": true,
"target": "ES6",
"forceConsistentCasingInFileNames": true,
"esModuleInterop": true,
"moduleResolution": "node",
"module": "CommonJS",
"resolveJsonModule": true,
"strict": true,
"skipLibCheck": true,
"noEmit": true,
"allowSyntheticDefaultImports": true
}
}
isaacs-minipass-ffdbee1/typedoc.json 0000664 0000000 0000000 00000000122 14414631765 0020004 0 ustar 00root root 0000000 0000000 {
"navigationLinks": {
"isaacs projects": "https://isaacs.github.io/"
}
}