pax_global_header00006660000000000000000000000064144146317650014525gustar00rootroot0000000000000052 comment=3066600b811753bd9c85831a8ecd5c6ca248f2aa isaacs-minipass-ffdbee1/000077500000000000000000000000001441463176500154475ustar00rootroot00000000000000isaacs-minipass-ffdbee1/.github/000077500000000000000000000000001441463176500170075ustar00rootroot00000000000000isaacs-minipass-ffdbee1/.github/FUNDING.yml000066400000000000000000000001001441463176500206130ustar00rootroot00000000000000# These are supported funding model platforms github: [isaacs] isaacs-minipass-ffdbee1/.github/workflows/000077500000000000000000000000001441463176500210445ustar00rootroot00000000000000isaacs-minipass-ffdbee1/.github/workflows/ci.yml000066400000000000000000000015071441463176500221650ustar00rootroot00000000000000name: 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.sh000066400000000000000000000004321441463176500250410ustar00rootroot00000000000000#!/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.sh000066400000000000000000000010011441463176500243360ustar00rootroot00000000000000#!/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.yml000066400000000000000000000021461441463176500246530ustar00rootroot00000000000000name: "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.js000066400000000000000000000010561441463176500247110ustar00rootroot00000000000000#!/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.yml000066400000000000000000000024131441463176500230560ustar00rootroot00000000000000# 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/.gitignore000066400000000000000000000000661441463176500174410ustar00rootroot00000000000000.*.swp node_modules .nyc_output/ coverage/ /index.mjs isaacs-minipass-ffdbee1/.prettierignore000066400000000000000000000001571441463176500205150ustar00rootroot00000000000000/node_modules /example /.github /dist .env /tap-snapshots /.nyc_output /coverage /benchmark /bench /LICENSE.md isaacs-minipass-ffdbee1/CHANGELOG.md000066400000000000000000000045311441463176500172630ustar00rootroot00000000000000# 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/LICENSE000066400000000000000000000014231441463176500164540ustar00rootroot00000000000000The 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.md000066400000000000000000000617161441463176500167410ustar00rootroot00000000000000# 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/000077500000000000000000000000001441463176500165265ustar00rootroot00000000000000isaacs-minipass-ffdbee1/bench/README.md000066400000000000000000000025251441463176500200110ustar00rootroot00000000000000Stream 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/000077500000000000000000000000001441463176500176525ustar00rootroot00000000000000isaacs-minipass-ffdbee1/bench/impls/README.md000066400000000000000000000012551441463176500211340ustar00rootroot00000000000000To 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.js000066400000000000000000000005171441463176500217750ustar00rootroot00000000000000// 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.js000066400000000000000000000003311441463176500244330ustar00rootroot00000000000000const 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.js000066400000000000000000000000571441463176500235070ustar00rootroot00000000000000module.exports = require('stream').PassThrough isaacs-minipass-ffdbee1/bench/impls/extend-minipass-current.js000066400000000000000000000003171441463176500250010ustar00rootroot00000000000000const 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.js000066400000000000000000000003221441463176500233150ustar00rootroot00000000000000const 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.js000066400000000000000000000004501441463176500232360ustar00rootroot00000000000000const 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.js000066400000000000000000000002351441463176500246260ustar00rootroot00000000000000const Minipass = require('../..') module.exports = class extends Minipass { constructor (options = {}) { options.async = true super(options) } } isaacs-minipass-ffdbee1/bench/impls/minipass-current.js000066400000000000000000000000421441463176500235070ustar00rootroot00000000000000module.exports = require('../..') isaacs-minipass-ffdbee1/bench/impls/minipass-latest.js000066400000000000000000000000451441463176500233240ustar00rootroot00000000000000module.exports = require('minipass') isaacs-minipass-ffdbee1/bench/impls/minipass-v3.js000066400000000000000000000000461441463176500223610ustar00rootroot00000000000000module.exports = require('minipass3') isaacs-minipass-ffdbee1/bench/impls/push-through.js000066400000000000000000000040241441463176500226450ustar00rootroot00000000000000// 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.js000066400000000000000000000003231441463176500217500ustar00rootroot00000000000000const 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-42157000066400000000000000000000005331441463176500236320ustar00rootroot00000000000000const { 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.js000066400000000000000000000164751441463176500202100ustar00rootroot00000000000000// 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.json000066400000000000000000000173461441463176500217550ustar00rootroot00000000000000{ "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.json000066400000000000000000000002771441463176500210220ustar00rootroot00000000000000{ "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.json000066400000000000000000000237121441463176500211270ustar00rootroot00000000000000{ "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.tab000066400000000000000000000421221441463176500207200ustar00rootroot00000000000000impl 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/000077500000000000000000000000001441463176500202275ustar00rootroot00000000000000isaacs-minipass-ffdbee1/bench/results/baseline-fast-fast-1.json000066400000000000000000000001341441463176500247260ustar00rootroot00000000000000{ "defaults": 3.407458007335663, "str": 2.7500839829444885, "obj": 2.019791007041931 }isaacs-minipass-ffdbee1/bench/results/baseline-fast-fast-20.json000066400000000000000000000001361441463176500250110ustar00rootroot00000000000000{ "defaults": 3.4377079606056213, "str": 2.8121660351753235, "obj": 1.9334579706192017 }isaacs-minipass-ffdbee1/bench/results/baseline-fast-mixed-1.json000066400000000000000000000001341441463176500250770ustar00rootroot00000000000000{ "defaults": 3.710582971572876, "str": 2.706125020980835, "obj": 1.8798329830169678 }isaacs-minipass-ffdbee1/bench/results/baseline-fast-mixed-20.json000066400000000000000000000001351441463176500251610ustar00rootroot00000000000000{ "defaults": 3.7309159636497498, "str": 2.734583020210266, "obj": 1.8174999952316284 }isaacs-minipass-ffdbee1/bench/results/baseline-fast-slow-1.json000066400000000000000000000001351441463176500247560ustar00rootroot00000000000000{ "defaults": 3.5882920026779175, "str": 2.9291670322418213, "obj": 1.868624985218048 }isaacs-minipass-ffdbee1/bench/results/baseline-fast-slow-20.json000066400000000000000000000001351441463176500250370ustar00rootroot00000000000000{ "defaults": 3.6982919573783875, "str": 2.8588340282440186, "obj": 2.010374963283539 }isaacs-minipass-ffdbee1/bench/results/baseline-slow-fast-1.json000066400000000000000000000001331441463176500247540ustar00rootroot00000000000000{ "defaults": 7.692415952682495, "str": 8.131583988666534, "obj": 5.750458002090454 }isaacs-minipass-ffdbee1/bench/results/baseline-slow-fast-20.json000066400000000000000000000001341441463176500250360ustar00rootroot00000000000000{ "defaults": 7.852207958698273, "str": 8.019291043281555, "obj": 5.8379170298576355 }isaacs-minipass-ffdbee1/bench/results/baseline-slow-slow-1.json000066400000000000000000000001341441463176500250040ustar00rootroot00000000000000{ "defaults": 7.7466660141944885, "str": 7.729292035102844, "obj": 5.734125018119812 }isaacs-minipass-ffdbee1/bench/results/baseline-slow-slow-20.json000066400000000000000000000001341441463176500250650ustar00rootroot00000000000000{ "defaults": 7.534042000770569, "str": 7.757792055606842, "obj": 5.7709580063819885 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-fast-1.json000066400000000000000000000001341441463176500273720ustar00rootroot00000000000000{ "defaults": 24.934708952903748, "str": 1480.325041949749, "obj": 6.816040992736816 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-fast-20.json000066400000000000000000000001341441463176500274530ustar00rootroot00000000000000{ "defaults": 254.3630409836769, "str": 31438.616124987602, "obj": 77.12849998474121 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-mixed-1.json000066400000000000000000000001351441463176500275440ustar00rootroot00000000000000{ "defaults": 38.514332950115204, "str": 1536.4794580340385, "obj": 27.35904198884964 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-mixed-20.json000066400000000000000000000001351441463176500276250ustar00rootroot00000000000000{ "defaults": 300.4728749990463, "str": 31662.917167007923, "obj": 130.17666602134705 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-slow-1.json000066400000000000000000000001331441463176500274200ustar00rootroot00000000000000{ "defaults": 33.0645409822464, "str": 1506.1100000143051, "obj": 23.59537500143051 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-fast-slow-20.json000066400000000000000000000001331441463176500275010ustar00rootroot00000000000000{ "defaults": 287.9106249809265, "str": 31293.62929201126, "obj": 128.8274160027504 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-fast-1.json000066400000000000000000000001351441463176500274220ustar00rootroot00000000000000{ "defaults": 31.692166030406952, "str": 1479.3482499718666, "obj": 12.53549998998642 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-fast-20.json000066400000000000000000000001351441463176500275030ustar00rootroot00000000000000{ "defaults": 265.43387496471405, "str": 31434.417541980743, "obj": 81.58758401870728 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-slow-1.json000066400000000000000000000001361441463176500274520ustar00rootroot00000000000000{ "defaults": 39.295709013938904, "str": 1489.5767920017242, "obj": 15.700709044933319 }isaacs-minipass-ffdbee1/bench/results/core-extend-transform-slow-slow-20.json000066400000000000000000000001351441463176500275320ustar00rootroot00000000000000{ "defaults": 279.1723749637604, "str": 31088.125959038734, "obj": 102.80712503194809 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-1.json000066400000000000000000000001351441463176500264420ustar00rootroot00000000000000{ "defaults": 25.10208296775818, "str": 1464.0363330245018, "obj": 6.7474170327186584 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-100.json000066400000000000000000000000351441463176500266010ustar00rootroot00000000000000{ "obj": 407.321750164032 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-fast-20.json000066400000000000000000000001351441463176500265230ustar00rootroot00000000000000{ "defaults": 244.94245797395706, "str": 31256.311416983604, "obj": 75.07454198598862 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-1.json000066400000000000000000000001341441463176500266120ustar00rootroot00000000000000{ "defaults": 39.00841599702835, "str": 1529.571458041668, "obj": 27.366249978542328 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-100.json000066400000000000000000000000361441463176500267530ustar00rootroot00000000000000{ "obj": 722.3131666183472 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-mixed-20.json000066400000000000000000000001331441463176500266720ustar00rootroot00000000000000{ "defaults": 297.1557089686394, "str": 32194.21895802021, "obj": 208.2157090306282 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-1.json000066400000000000000000000001361441463176500264720ustar00rootroot00000000000000{ "defaults": 33.410207986831665, "str": 1500.9538750052452, "obj": 23.252583026885986 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-100.json000066400000000000000000000000361441463176500266310ustar00rootroot00000000000000{ "obj": 713.4662504196167 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-fast-slow-20.json000066400000000000000000000001351441463176500265520ustar00rootroot00000000000000{ "defaults": 285.84004098176956, "str": 31379.71829199791, "obj": 128.63429099321365 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-mixed-1.json000066400000000000000000000000171441463176500256570ustar00rootroot00000000000000{ "obj": {} }isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-fast-1.json000066400000000000000000000001341441463176500264700ustar00rootroot00000000000000{ "defaults": 32.13895797729492, "str": 1478.332457959652, "obj": 12.470874965190887 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-fast-20.json000066400000000000000000000001331441463176500265500ustar00rootroot00000000000000{ "defaults": 278.5909160375595, "str": 31030.64262497425, "obj": 67.46312499046326 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-1.json000066400000000000000000000001361441463176500265210ustar00rootroot00000000000000{ "defaults": 38.971583008766174, "str": 1494.3747920393944, "obj": 15.394749999046326 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-100.json000066400000000000000000000000371441463176500266610ustar00rootroot00000000000000{ "obj": 423.62200021743774 }isaacs-minipass-ffdbee1/bench/results/core-passthrough-slow-slow-20.json000066400000000000000000000001341441463176500266000ustar00rootroot00000000000000{ "defaults": 286.05125004053116, "str": 30932.92258399725, "obj": 82.41066700220108 }isaacs-minipass-ffdbee1/bench/results/core-transform-fast-fast-20.json000066400000000000000000000002071441463176500261670ustar00rootroot00000000000000{ "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.json000066400000000000000000000006261441463176500305100ustar00rootroot00000000000000{ "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.json000066400000000000000000000002071441463176500274540ustar00rootroot00000000000000{ "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.json000066400000000000000000000001331441463176500277330ustar00rootroot00000000000000{ "defaults": 9.391750037670135, "str": 8.311500012874603, "obj": 5.157707989215851 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-fast-20.json000066400000000000000000000001331441463176500300140ustar00rootroot00000000000000{ "defaults": 57.24487501382828, "str": 60.99250000715256, "obj": 30.03591698408127 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-mixed-1.json000066400000000000000000000001341441463176500301050ustar00rootroot00000000000000{ "defaults": 13.512374997138977, "str": 12.540499985218048, "obj": 8.06879198551178 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-mixed-20.json000066400000000000000000000001351441463176500301670ustar00rootroot00000000000000{ "defaults": 114.66458302736282, "str": 123.72312504053116, "obj": 92.14691698551178 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-slow-1.json000066400000000000000000000001341441463176500277630ustar00rootroot00000000000000{ "defaults": 14.671917021274567, "str": 13.739666998386383, "obj": 8.62345802783966 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-fast-slow-20.json000066400000000000000000000001351441463176500300450ustar00rootroot00000000000000{ "defaults": 113.52045798301697, "str": 122.84945797920227, "obj": 91.31158298254013 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-fast-1.json000066400000000000000000000001351441463176500277640ustar00rootroot00000000000000{ "defaults": 13.307500004768372, "str": 14.416042029857635, "obj": 9.894125044345856 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-fast-20.json000066400000000000000000000001351441463176500300450ustar00rootroot00000000000000{ "defaults": 61.072625041007996, "str": 63.395416021347046, "obj": 37.77045798301697 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-slow-1.json000066400000000000000000000001321441463176500300100ustar00rootroot00000000000000{ "defaults": 19.4930419921875, "str": 19.182792007923126, "obj": 16.5867919921875 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-current-slow-slow-20.json000066400000000000000000000001351441463176500300740ustar00rootroot00000000000000{ "defaults": 118.21458297967911, "str": 127.44670897722244, "obj": 98.42250001430511 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-fast-1.json000066400000000000000000000001341441463176500262540ustar00rootroot00000000000000{ "defaults": 12.583540916442871, "str": 12.105957984924316, "obj": 9.06024980545044 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-fast-20.json000066400000000000000000000001361441463176500263370ustar00rootroot00000000000000{ "defaults": 126.18258285522461, "str": 128.73254108428955, "obj": 105.26249980926514 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-mixed-1.json000066400000000000000000000001341441463176500264250ustar00rootroot00000000000000{ "defaults": 21.804834365844727, "str": 20.67766571044922, "obj": 18.17937469482422 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-mixed-20.json000066400000000000000000000001341441463176500265060ustar00rootroot00000000000000{ "defaults": 284.1690001487732, "str": 296.5096673965454, "obj": 267.44170808792114 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-slow-1.json000066400000000000000000000001341441463176500263030ustar00rootroot00000000000000{ "defaults": 20.50854206085205, "str": 20.54229211807251, "obj": 17.428500175476074 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-fast-slow-20.json000066400000000000000000000001341441463176500263640ustar00rootroot00000000000000{ "defaults": 276.1806254386902, "str": 293.58387517929077, "obj": 276.8616247177124 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-fast-1.json000066400000000000000000000001351441463176500263040ustar00rootroot00000000000000{ "defaults": 16.363709449768066, "str": 15.237417221069336, "obj": 12.49150037765503 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-fast-20.json000066400000000000000000000001361441463176500263660ustar00rootroot00000000000000{ "defaults": 125.16524982452393, "str": 128.87895822525024, "obj": 110.46454191207886 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-slow-1.json000066400000000000000000000001351441463176500263330ustar00rootroot00000000000000{ "defaults": 27.080874919891357, "str": 26.84391689300537, "obj": 26.955999851226807 }isaacs-minipass-ffdbee1/bench/results/extend-minipass-slow-slow-20.json000066400000000000000000000001331441463176500264120ustar00rootroot00000000000000{ "defaults": 274.1978340148926, "str": 294.1859998703003, "obj": 277.8759160041809 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-fast-1.json000066400000000000000000000001351441463176500261740ustar00rootroot00000000000000{ "defaults": 24.68295907974243, "str": 1409.8773746490479, "obj": 21.667250156402588 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-fast-20.json000066400000000000000000000001341441463176500262540ustar00rootroot00000000000000{ "defaults": 289.5474581718445, "str": 1649.342541694641, "obj": 235.78379201889038 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-mixed-1.json000066400000000000000000000001361441463176500263460ustar00rootroot00000000000000{ "defaults": 26.036499977111816, "str": 1378.7794170379639, "obj": 16.916458129882812 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-mixed-20.json000066400000000000000000000001331441463176500264240ustar00rootroot00000000000000{ "defaults": 242.00229215621948, "str": 1575.54691696167, "obj": 149.2092089653015 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-slow-1.json000066400000000000000000000001361441463176500262240ustar00rootroot00000000000000{ "defaults": 24.177124977111816, "str": 1384.6977500915527, "obj": 16.081832885742188 }isaacs-minipass-ffdbee1/bench/results/extend-through2-fast-slow-20.json000066400000000000000000000001361441463176500263050ustar00rootroot00000000000000{ "defaults": 239.68829202651978, "str": 1595.5013337135315, "obj": 154.00483322143555 }isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-fast-1.json000066400000000000000000000001351441463176500262230ustar00rootroot00000000000000{ "defaults": 30.115875244140625, "str": 1383.3513751029968, "obj": 32.43433332443237 }isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-fast-20.json000066400000000000000000000001331441463176500263020ustar00rootroot00000000000000{ "defaults": 312.4208331108093, "str": 1739.513334274292, "obj": 239.5954999923706 }isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-slow-1.json000066400000000000000000000001341441463176500262510ustar00rootroot00000000000000{ "defaults": 35.7008752822876, "str": 1406.1673340797424, "obj": 37.660542011260986 }isaacs-minipass-ffdbee1/bench/results/extend-through2-slow-slow-20.json000066400000000000000000000001361441463176500263340ustar00rootroot00000000000000{ "defaults": 298.22725009918213, "str": 1673.6373329162598, "obj": 248.40116691589355 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-fast-1.json000066400000000000000000000001351441463176500275630ustar00rootroot00000000000000{ "defaults": 15.126042008399963, "str": 14.437624990940094, "obj": 8.553624987602234 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-fast-20.json000066400000000000000000000001361441463176500276450ustar00rootroot00000000000000{ "defaults": 139.32095801830292, "str": 141.90308398008347, "obj": 107.51195901632309 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-mixed-1.json000066400000000000000000000001351441463176500277340ustar00rootroot00000000000000{ "defaults": 30.16175001859665, "str": 19.623667001724243, "obj": 12.403167009353638 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-mixed-20.json000066400000000000000000000001351441463176500300150ustar00rootroot00000000000000{ "defaults": 146.7203330397606, "str": 148.47591596841812, "obj": 114.99945896863937 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-slow-1.json000066400000000000000000000001351441463176500276120ustar00rootroot00000000000000{ "defaults": 27.98837500810623, "str": 17.754124999046326, "obj": 11.067457973957062 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-fast-slow-20.json000066400000000000000000000001361441463176500276740ustar00rootroot00000000000000{ "defaults": 145.10608303546906, "str": 148.36312502622604, "obj": 112.49658298492432 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-fast-1.json000066400000000000000000000001351441463176500276120ustar00rootroot00000000000000{ "defaults": 14.532292008399963, "str": 14.49212497472763, "obj": 14.286958992481232 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-fast-20.json000066400000000000000000000001331441463176500276710ustar00rootroot00000000000000{ "defaults": 84.68783301115036, "str": 87.13433396816254, "obj": 60.39887499809265 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-slow-1.json000066400000000000000000000001341441463176500276400ustar00rootroot00000000000000{ "defaults": 21.74616700410843, "str": 18.65733301639557, "obj": 14.652042031288147 }isaacs-minipass-ffdbee1/bench/results/minipass-current-async-slow-slow-20.json000066400000000000000000000001361441463176500277230ustar00rootroot00000000000000{ "defaults": 178.65487498044968, "str": 166.86449998617172, "obj": 130.19733399152756 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-fast-1.json000066400000000000000000000001331441463176500264460ustar00rootroot00000000000000{ "defaults": 9.214917004108429, "str": 8.199416995048523, "obj": 5.105875015258789 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-fast-20.json000066400000000000000000000001341441463176500265300ustar00rootroot00000000000000{ "defaults": 57.41624999046326, "str": 60.32475000619888, "obj": 29.545875012874603 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-1.json000066400000000000000000000001351441463176500266210ustar00rootroot00000000000000{ "defaults": 13.566124975681305, "str": 12.383000016212463, "obj": 7.925790965557098 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-100.json000066400000000000000000000000361441463176500267610ustar00rootroot00000000000000{ "obj": 676.8444590568542 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-mixed-20.json000066400000000000000000000001351441463176500267020ustar00rootroot00000000000000{ "defaults": 112.53495800495148, "str": 123.22929102182388, "obj": 90.61699998378754 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-slow-1.json000066400000000000000000000001341441463176500264760ustar00rootroot00000000000000{ "defaults": 12.99433296918869, "str": 12.603249967098236, "obj": 7.787625014781952 }isaacs-minipass-ffdbee1/bench/results/minipass-current-fast-slow-20.json000066400000000000000000000001341441463176500265570ustar00rootroot00000000000000{ "defaults": 112.14308398962021, "str": 122.3718329668045, "obj": 92.39629197120667 }isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-fast-1.json000066400000000000000000000001361441463176500265000ustar00rootroot00000000000000{ "defaults": 13.379290997982025, "str": 13.831874966621399, "obj": 10.078208029270172 }isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-fast-20.json000066400000000000000000000001341441463176500265570ustar00rootroot00000000000000{ "defaults": 59.585207998752594, "str": 61.93591696023941, "obj": 35.97454100847244 }isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-slow-1.json000066400000000000000000000001331441463176500265240ustar00rootroot00000000000000{ "defaults": 20.05220800638199, "str": 19.6290420293808, "obj": 15.730000019073486 }isaacs-minipass-ffdbee1/bench/results/minipass-current-slow-slow-20.json000066400000000000000000000001351441463176500266070ustar00rootroot00000000000000{ "defaults": 115.59104204177856, "str": 125.09641599655151, "obj": 97.22012501955032 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-fast-1.json000066400000000000000000000001321441463176500262570ustar00rootroot00000000000000{ "defaults": 9.20908397436142, "str": 8.295958995819092, "obj": 5.196291983127594 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-fast-20.json000066400000000000000000000001351441463176500263430ustar00rootroot00000000000000{ "defaults": 57.19783401489258, "str": 59.831041038036346, "obj": 29.262917041778564 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-mixed-1.json000066400000000000000000000001351441463176500264330ustar00rootroot00000000000000{ "defaults": 13.397624969482422, "str": 12.475832998752594, "obj": 8.041584014892578 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-mixed-20.json000066400000000000000000000001351441463176500265140ustar00rootroot00000000000000{ "defaults": 112.09566700458527, "str": 122.23299998044968, "obj": 90.01541703939438 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-slow-1.json000066400000000000000000000001351441463176500263110ustar00rootroot00000000000000{ "defaults": 13.002458989620209, "str": 12.386833012104034, "obj": 7.695333003997803 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-fast-slow-20.json000066400000000000000000000001341441463176500263710ustar00rootroot00000000000000{ "defaults": 113.0157499909401, "str": 123.11825001239777, "obj": 91.26908296346664 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-fast-1.json000066400000000000000000000001341441463176500263100ustar00rootroot00000000000000{ "defaults": 12.991750001907349, "str": 14.473416030406952, "obj": 9.93445897102356 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-fast-20.json000066400000000000000000000001341441463176500263710ustar00rootroot00000000000000{ "defaults": 60.432124972343445, "str": 63.34337502717972, "obj": 37.68408399820328 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-slow-1.json000066400000000000000000000001351441463176500263400ustar00rootroot00000000000000{ "defaults": 19.147916972637177, "str": 19.38154101371765, "obj": 16.095083951950073 }isaacs-minipass-ffdbee1/bench/results/minipass-latest-slow-slow-20.json000066400000000000000000000001351441463176500264210ustar00rootroot00000000000000{ "defaults": 115.9765830039978, "str": 124.78712499141693, "obj": 100.68733298778534 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-fast-1.json000066400000000000000000000001331441463176500253140ustar00rootroot00000000000000{ "defaults": 9.453750014305115, "str": 8.397374987602234, "obj": 5.251791000366211 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-fast-20.json000066400000000000000000000001341441463176500253760ustar00rootroot00000000000000{ "defaults": 57.91070902347565, "str": 60.624458968639374, "obj": 29.65308302640915 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-mixed-1.json000066400000000000000000000001351441463176500254670ustar00rootroot00000000000000{ "defaults": 14.111000001430511, "str": 13.970665991306305, "obj": 8.385917007923126 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-mixed-20.json000066400000000000000000000001351441463176500255500ustar00rootroot00000000000000{ "defaults": 116.30437499284744, "str": 129.18783402442932, "obj": 96.91087502241135 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-slow-1.json000066400000000000000000000001351441463176500253450ustar00rootroot00000000000000{ "defaults": 13.282292008399963, "str": 12.831542015075684, "obj": 8.239207983016968 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-fast-slow-20.json000066400000000000000000000001341441463176500254250ustar00rootroot00000000000000{ "defaults": 115.99166697263718, "str": 128.30966699123383, "obj": 95.9580420255661 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-fast-1.json000066400000000000000000000001351441463176500253450ustar00rootroot00000000000000{ "defaults": 13.550792038440704, "str": 13.598625004291534, "obj": 7.527709007263184 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-fast-20.json000066400000000000000000000001341441463176500254250ustar00rootroot00000000000000{ "defaults": 61.014499962329865, "str": 64.24833297729492, "obj": 37.54316699504852 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-slow-1.json000066400000000000000000000001351441463176500253740ustar00rootroot00000000000000{ "defaults": 19.803040981292725, "str": 19.487249970436096, "obj": 16.86175000667572 }isaacs-minipass-ffdbee1/bench/results/minipass-v3-slow-slow-20.json000066400000000000000000000001351441463176500254550ustar00rootroot00000000000000{ "defaults": 111.40716600418091, "str": 122.67037498950958, "obj": 93.60766696929932 }isaacs-minipass-ffdbee1/bench/results/push-through-fast-fast-1.json000066400000000000000000000001341441463176500256010ustar00rootroot00000000000000{ "defaults": 4.571958065032959, "str": 4.329500198364258, "obj": 0.9436254501342773 }isaacs-minipass-ffdbee1/bench/results/push-through-fast-fast-20.json000066400000000000000000000000561441463176500256650ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-ffdbee1/bench/results/push-through-fast-mixed-1.json000066400000000000000000000001321441463176500257500ustar00rootroot00000000000000{ "defaults": 8.806500434875488, "str": 7.162916660308838, "obj": 3.48104190826416 }isaacs-minipass-ffdbee1/bench/results/push-through-fast-mixed-20.json000066400000000000000000000000561441463176500260360ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-ffdbee1/bench/results/push-through-fast-slow-1.json000066400000000000000000000001341441463176500256300ustar00rootroot00000000000000{ "defaults": 8.510458946228027, "str": 6.624207973480225, "obj": 3.3635826110839844 }isaacs-minipass-ffdbee1/bench/results/push-through-fast-slow-20.json000066400000000000000000000000561441463176500257140ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-ffdbee1/bench/results/push-through-slow-fast-1.json000066400000000000000000000001331441463176500256270ustar00rootroot00000000000000{ "defaults": 8.911791801452637, "str": 9.212250232696533, "obj": 6.082250118255615 }isaacs-minipass-ffdbee1/bench/results/push-through-slow-fast-20.json000066400000000000000000000000561441463176500257140ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-ffdbee1/bench/results/push-through-slow-slow-1.json000066400000000000000000000001341441463176500256570ustar00rootroot00000000000000{ "defaults": 16.439791202545166, "str": 14.342957973480225, "obj": 11.8979172706604 }isaacs-minipass-ffdbee1/bench/results/push-through-slow-slow-20.json000066400000000000000000000000561441463176500257430ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-ffdbee1/bench/results/through2-fast-fast-1.json000066400000000000000000000001361441463176500247100ustar00rootroot00000000000000{ "defaults": 23.358792304992676, "str": 1519.4609580039978, "obj": 18.863791942596436 }isaacs-minipass-ffdbee1/bench/results/through2-fast-fast-20.json000066400000000000000000000001341441463176500247670ustar00rootroot00000000000000{ "defaults": 269.9025411605835, "str": 30722.50658416748, "obj": 237.11420822143555 }isaacs-minipass-ffdbee1/bench/results/through2-fast-mixed-1.json000066400000000000000000000001361441463176500250610ustar00rootroot00000000000000{ "defaults": 25.791290760040283, "str": 1463.4079580307007, "obj": 16.932791233062744 }isaacs-minipass-ffdbee1/bench/results/through2-fast-mixed-20.json000066400000000000000000000001361441463176500251420ustar00rootroot00000000000000{ "defaults": 237.30966711044312, "str": 36814.678584098816, "obj": 142.29699993133545 }isaacs-minipass-ffdbee1/bench/results/through2-fast-slow-1.json000066400000000000000000000001351441463176500247360ustar00rootroot00000000000000{ "defaults": 23.46716594696045, "str": 1448.8229160308838, "obj": 14.695291996002197 }isaacs-minipass-ffdbee1/bench/results/through2-fast-slow-20.json000066400000000000000000000001351441463176500250170ustar00rootroot00000000000000{ "defaults": 235.12229204177856, "str": 36618.73558282852, "obj": 148.23050022125244 }isaacs-minipass-ffdbee1/bench/results/through2-slow-fast-1.json000066400000000000000000000001341441463176500247350ustar00rootroot00000000000000{ "defaults": 30.843832969665527, "str": 1474.772541999817, "obj": 30.43804121017456 }isaacs-minipass-ffdbee1/bench/results/through2-slow-fast-20.json000066400000000000000000000001351441463176500250170ustar00rootroot00000000000000{ "defaults": 284.6131248474121, "str": 29469.896290779114, "obj": 238.76466703414917 }isaacs-minipass-ffdbee1/bench/results/through2-slow-slow-1.json000066400000000000000000000001341441463176500247640ustar00rootroot00000000000000{ "defaults": 34.66804075241089, "str": 1452.2015419006348, "obj": 37.72975015640259 }isaacs-minipass-ffdbee1/bench/results/through2-slow-slow-20.json000066400000000000000000000001361441463176500250470ustar00rootroot00000000000000{ "defaults": 294.61695766448975, "str": 29603.270833015442, "obj": 264.94858407974243 }isaacs-minipass-ffdbee1/bench/test.js000066400000000000000000000103021441463176500200370ustar00rootroot00000000000000'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.ts000066400000000000000000000103461441463176500173540ustar00rootroot00000000000000/// // 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.js000066400000000000000000000441671441463176500171300ustar00rootroot00000000000000'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.json000066400000000000000000004345141441463176500206760ustar00rootroot00000000000000{ "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.json000066400000000000000000000033211441463176500177340ustar00rootroot00000000000000{ "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/000077500000000000000000000000001441463176500171365ustar00rootroot00000000000000isaacs-minipass-ffdbee1/scripts/transpile-to-esm.js000066400000000000000000000007121441463176500226770ustar00rootroot00000000000000#!/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/000077500000000000000000000000001441463176500202535ustar00rootroot00000000000000isaacs-minipass-ffdbee1/tap-snapshots/test/000077500000000000000000000000001441463176500212325ustar00rootroot00000000000000isaacs-minipass-ffdbee1/tap-snapshots/test/basic.js.test.cjs000066400000000000000000000007031441463176500244050ustar00rootroot00000000000000/* 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/000077500000000000000000000000001441463176500164265ustar00rootroot00000000000000isaacs-minipass-ffdbee1/test/abort.js000066400000000000000000000031121441463176500200700ustar00rootroot00000000000000const { 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.js000066400000000000000000000033341441463176500215370ustar00rootroot00000000000000const 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.js000066400000000000000000000005671441463176500226250ustar00rootroot00000000000000const { 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.js000066400000000000000000000043651441463176500214020ustar00rootroot00000000000000const 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.js000066400000000000000000000005431441463176500244760ustar00rootroot00000000000000const 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.js000066400000000000000000000311131441463176500200440ustar00rootroot00000000000000const { 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.js000066400000000000000000000020531441463176500251130ustar00rootroot00000000000000// 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.js000066400000000000000000000004031441463176500232520ustar00rootroot00000000000000const { 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.js000066400000000000000000000027611441463176500204170ustar00rootroot00000000000000'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.js000066400000000000000000000012541441463176500247050ustar00rootroot00000000000000const 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.js000066400000000000000000000047061441463176500204640ustar00rootroot00000000000000const { 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.js000066400000000000000000000005521441463176500230750ustar00rootroot00000000000000const { 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.js000066400000000000000000000020661441463176500246760ustar00rootroot00000000000000const 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.js000066400000000000000000000002161441463176500257070ustar00rootroot00000000000000const { 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.js000066400000000000000000000014161441463176500210160ustar00rootroot00000000000000'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.js000066400000000000000000000001771441463176500222040ustar00rootroot00000000000000const 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.js000066400000000000000000000017101441463176500206420ustar00rootroot00000000000000'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.js000066400000000000000000000030621441463176500230320ustar00rootroot00000000000000const { 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.mjs000066400000000000000000000004331441463176500177250ustar00rootroot00000000000000import { 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.js000066400000000000000000000030361441463176500242610ustar00rootroot00000000000000// 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.js000066400000000000000000000027771441463176500207050ustar00rootroot00000000000000const { 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.js000066400000000000000000000031461441463176500240100ustar00rootroot00000000000000const 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.js000066400000000000000000000005641441463176500233550ustar00rootroot00000000000000'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.js000066400000000000000000000155061441463176500207710ustar00rootroot00000000000000'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.js000066400000000000000000000004611441463176500214640ustar00rootroot00000000000000const 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.js000066400000000000000000000013361441463176500222720ustar00rootroot00000000000000const 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.js000066400000000000000000000032261441463176500214620ustar00rootroot00000000000000const 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.js000066400000000000000000000005701441463176500241450ustar00rootroot00000000000000// 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.js000066400000000000000000000004571441463176500244140ustar00rootroot00000000000000const { 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.js000066400000000000000000000017061441463176500202700ustar00rootroot00000000000000const 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.js000066400000000000000000000030301441463176500300540ustar00rootroot00000000000000// 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.json000066400000000000000000000006641441463176500201640ustar00rootroot00000000000000{ "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.json000066400000000000000000000001221441463176500200040ustar00rootroot00000000000000{ "navigationLinks": { "isaacs projects": "https://isaacs.github.io/" } }