pax_global_header00006660000000000000000000000064151454552110014515gustar00rootroot0000000000000052 comment=ab4b3b05d0d557ac6bb178f38501b11d0c96454e isaacs-minipass-90fd647/000077500000000000000000000000001514545521100151465ustar00rootroot00000000000000isaacs-minipass-90fd647/.github/000077500000000000000000000000001514545521100165065ustar00rootroot00000000000000isaacs-minipass-90fd647/.github/workflows/000077500000000000000000000000001514545521100205435ustar00rootroot00000000000000isaacs-minipass-90fd647/.github/workflows/ci.yml000066400000000000000000000015011514545521100216560ustar00rootroot00000000000000name: CI on: [push, pull_request] jobs: build: strategy: matrix: node-version: [16.x, 18.x, 20.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-90fd647/.github/workflows/static.yml000066400000000000000000000024131514545521100225550ustar00rootroot00000000000000# 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-90fd647/.gitignore000066400000000000000000000000541514545521100171350ustar00rootroot00000000000000node_modules /.nyc_output/ /coverage/ /dist isaacs-minipass-90fd647/.prettierignore000066400000000000000000000001571514545521100202140ustar00rootroot00000000000000/node_modules /example /.github /dist .env /tap-snapshots /.nyc_output /coverage /benchmark /bench /LICENSE.md isaacs-minipass-90fd647/.tshy/000077500000000000000000000000001514545521100162135ustar00rootroot00000000000000isaacs-minipass-90fd647/.tshy/build.json000066400000000000000000000002261514545521100202050ustar00rootroot00000000000000{ "extends": "../tsconfig.json", "compilerOptions": { "rootDir": "../src", "module": "nodenext", "moduleResolution": "nodenext" } } isaacs-minipass-90fd647/.tshy/commonjs.json000066400000000000000000000004301514545521100207300ustar00rootroot00000000000000{ "extends": "./build.json", "include": [ "../src/**/*.ts", "../src/**/*.cts", "../src/**/*.tsx", "../src/**/*.json" ], "exclude": [ "../src/**/*.mts", "../src/package.json" ], "compilerOptions": { "outDir": "../.tshy-build/commonjs" } } isaacs-minipass-90fd647/.tshy/esm.json000066400000000000000000000003741514545521100176760ustar00rootroot00000000000000{ "extends": "./build.json", "include": [ "../src/**/*.ts", "../src/**/*.mts", "../src/**/*.tsx", "../src/**/*.json" ], "exclude": [ "../src/package.json" ], "compilerOptions": { "outDir": "../.tshy-build/esm" } } isaacs-minipass-90fd647/CHANGELOG.md000066400000000000000000000111771514545521100167660ustar00rootroot00000000000000# chernge lerg ## 7.1 - Update the type definitions to be more easily extended in classes that are compatible with the NodeJS.WritableStream type in the latest versions of `@types/node`. ## 7.0 This is a big one, please read carefully before upgrading from prior versions, especially if you extend Minipass in a subclass. ### Breaking Changes - Rewritten in TypeScript as hybrid esm/cjs build, so a lot of types changed in subtle ways, and several behaviors got stricter. - Minipass now inherits from `EventEmitter` rather than `Stream`. Nothing from the `Stream` class was ever used by Minipass, but it inherited from `Stream` to pass checks in some stream libraries that checked `instanceof Stream`. Unfortunately, the type difference in the `pipe()` method signature made it challenging to continue doing in TypeScript. - It is no longer possible to change the type of data emitted after a Minipass stream is instantiated, as this would thwart TypeScript's static checks. As a consequence: - The `setEncoding` method and the `encoding` setter are deprecated. Encoding may _only_ be set in the constructor options object. - `objectMode` is no longer inferred by writing something other than a string or Buffer. It may _only_ be set in the constructor options object. - If all existing data consumers are removed, via `stream.unpipe(dest)`, `stream.removeListener('data', handler)`, `stream.removeAllListeners('data')`, and/or `stream.removeAllListeners()`, then the data will stop flowing. Note that it is still possible to explicitly discard a stream's data by calling `stream.resume()` in the absence of any consumers. ### Features and Fixes - Removed a very subtle performance issue that made objectMode Minipass streams slower in some cases than node core streams. Minipass is now faster than node core streams for all data types. - The array returned by `stream.collect()` for objectMode streams will have a `dataLength` property equal to 0, rather than undefined. - `isStream` is moved from a static member on the Minipass class to a named export. - `isWritable()` and `isReadable()` methods added. ## 6.0 - Define event argument types in an extensible manner, defaulting to `unknown[]` for event argument signatures if not declared. - Drop support for old node versions ## 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-90fd647/LICENSE.md000066400000000000000000000030201514545521100165450ustar00rootroot00000000000000# Blue Oak Model License Version 1.0.0 ## Purpose This license gives everyone as much permission to work with this software as possible, while protecting contributors from liability. ## Acceptance In order to receive this license, you must agree to its rules. The rules of this license are both obligations under that agreement and conditions to your license. You must not do anything with this software that triggers a rule that you cannot or will not follow. ## Copyright Each contributor licenses you to do everything with this software that would otherwise infringe that contributor's copyright in it. ## Notices You must ensure that everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license or a link to . ## Excuse If anyone notifies you in writing that you have not complied with [Notices](#notices), you can keep your license by taking all practical steps to comply within 30 days after the notice. If you do not do so, your license ends immediately. ## Patent Each contributor licenses you to do everything with this software that would otherwise infringe any patent claims they can license or become able to license. ## Reliability No contributor can revoke this license. ## No Liability ***As far as the law allows, this software comes as is, without any warranty or condition, and no contributor will be liable to anyone for any damages related to this software or this license, under any kind of legal claim.*** isaacs-minipass-90fd647/README.md000066400000000000000000000650271514545521100164370ustar00rootroot00000000000000# 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 only be set at instantiation. Attempting to write something other than a String or Buffer without having set `objectMode` in the options will throw an error. 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) ## Usage in TypeScript The `Minipass` class takes three type template definitions: - `RType` the type being read, which defaults to `Buffer`. If `RType` is `string`, then the constructor _must_ get an options object specifying either an `encoding` or `objectMode: true`. If it's anything other than `string` or `Buffer`, then it _must_ get an options object specifying `objectMode: true`. - `WType` the type being written. If `RType` is `Buffer` or `string`, then this defaults to `ContiguousData` (Buffer, string, ArrayBuffer, or ArrayBufferView). Otherwise, it defaults to `RType`. - `Events` type mapping event names to the arguments emitted with that event, which extends `Minipass.Events`. To declare types for custom events in subclasses, extend the third parameter with your own event signatures. For example: ```js import { Minipass } from 'minipass' // a NDJSON stream that emits 'jsonError' when it can't stringify export interface Events extends Minipass.Events { jsonError: [e: Error] } export class NDJSONStream extends Minipass { constructor() { super({ objectMode: true }) } // data is type `any` because that's WType write(data, encoding, cb) { try { const json = JSON.stringify(data) return super.write(json + '\n', encoding, cb) } catch (er) { if (!er instanceof Error) { er = Object.assign(new Error('json stringify failed'), { cause: er, }) } // trying to emit with something OTHER than an error will // fail, because we declared the event arguments type. this.emit('jsonError', er) } } } const s = new NDJSONStream() s.on('jsonError', e => { // here, TS knows that e is an Error }) ``` Emitting/handling events that aren't declared in this way is fine, but the arguments will be typed as `unknown`. ## 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) // options is optional 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. - `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` Read-only. The encoding that has been set. - `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`. - `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) return true } 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-90fd647/bench/000077500000000000000000000000001514545521100162255ustar00rootroot00000000000000isaacs-minipass-90fd647/bench/README.md000066400000000000000000000025251514545521100175100ustar00rootroot00000000000000Stream 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-90fd647/bench/diff.patch000066400000000000000000000337321514545521100201660ustar00rootroot00000000000000diff --git a/results.json b/results-nextTick.json index 87dfa67..c92eb2e 100644 --- a/results.json +++ b/results-nextTick.json @@ -2,186 +2,186 @@ "minipass-current": { "fast-fast": { "1": { - "defaults": 9.158959150314331, - "str": 8.571416854858398, - "obj": 5.3308329582214355 + "defaults": 9.315250158309937, + "str": 9.058249950408936, + "obj": 5.591958999633789 }, "20": { - "defaults": 54.96150016784668, - "str": 61.00970911979675, - "obj": 30.064125061035156 + "defaults": 54.78470802307129, + "str": 60.74754190444946, + "obj": 29.725499868392944 } }, "fast-slow": { "1": { - "defaults": 12.961749792098999, - "str": 12.348084211349487, - "obj": 7.9047088623046875 + "defaults": 12.800167083740234, + "str": 12.566958904266357, + "obj": 7.83791708946228 }, "20": { - "defaults": 113.74904084205627, - "str": 119.8478331565857, - "obj": 89.65687489509583 + "defaults": 112.79266595840454, + "str": 120.37079095840454, + "obj": 89.15604209899902 } }, "slow-fast": { "1": { - "defaults": 13.018833875656128, - "str": 14.099333047866821, - "obj": 7.656540870666504 + "defaults": 13.068458080291748, + "str": 13.965208053588867, + "obj": 7.480791091918945 }, "20": { - "defaults": 58.90929102897644, - "str": 64.20579195022583, - "obj": 37.45337510108948 + "defaults": 60.267333030700684, + "str": 64.88925004005432, + "obj": 37.4123330116272 } }, "slow-slow": { "1": { - "defaults": 19.89079189300537, - "str": 19.510541915893555, - "obj": 17.49870800971985 + "defaults": 19.580082893371582, + "str": 18.83570885658264, + "obj": 16.99166703224182 }, "20": { - "defaults": 116.40170812606812, - "str": 124.50712513923645, - "obj": 95.88216590881348 + "defaults": 115.7289171218872, + "str": 125.36541700363159, + "obj": 101.21020793914795 } }, "fast-mixed": { "1": { - "defaults": 15.063082933425903, - "str": 13.990000009536743, - "obj": 8.578375101089478 + "defaults": 13.190709114074707, + "str": 12.39187479019165, + "obj": 8.11525011062622 }, "20": { - "defaults": 112.92349982261658, - "str": 120.54766702651978, - "obj": 89.67341709136963 + "defaults": 112.43612504005432, + "str": 119.79841709136963, + "obj": 89.03837513923645 } } }, "minipass-current-async": { "fast-fast": { "1": { - "defaults": 17.436917066574097, - "str": 14.613209009170532, - "obj": 8.351541996002197 + "defaults": 23.541666984558105, + "str": 20.826499938964844, + "obj": 8.195333003997803 }, "20": { - "defaults": 162.37374997138977, - "str": 160.77308297157288, - "obj": 128.16333293914795 + "defaults": 181.57949995994568, + "str": 160.56612491607666, + "obj": 133.86737513542175 } }, "fast-slow": { "1": { - "defaults": 22.917708158493042, - "str": 24.7020001411438, - "obj": 14.04404091835022 + "defaults": 30.262207984924316, + "str": 27.52079200744629, + "obj": 12.913583040237427 }, "20": { - "defaults": 168.95862483978271, - "str": 164.41550016403198, - "obj": 137.45499992370605 + "defaults": 183.56925010681152, + "str": 155.51291704177856, + "obj": 128.51025009155273 } }, "slow-fast": { "1": { - "defaults": 15.140833854675293, - "str": 15.567458152770996, - "obj": 12.085041999816895 + "defaults": 37.37308311462402, + "str": 23.700542211532593, + "obj": 14.856584072113037 }, "20": { - "defaults": 85.23075008392334, - "str": 89.06154203414917, - "obj": 60.17091703414917 + "defaults": 182.5156660079956, + "str": 160.24374985694885, + "obj": 134.98245906829834 } }, "slow-slow": { "1": { - "defaults": 21.48016595840454, - "str": 18.91920804977417, - "obj": 14.956875085830688 + "defaults": 44.433499813079834, + "str": 24.88837504386902, + "obj": 15.051375150680542 }, "20": { - "defaults": 173.2601671218872, - "str": 170.78049993515015, - "obj": 130.8087079524994 + "defaults": 186.05995798110962, + "str": 159.04087495803833, + "obj": 134.96404099464417 } }, "fast-mixed": { "1": { - "defaults": 22.68120789527893, - "str": 24.782583951950073, - "obj": 12.76816701889038 + "defaults": 28.58899998664856, + "str": 28.117417097091675, + "obj": 12.967083215713501 }, "20": { - "defaults": 167.30625009536743, - "str": 161.40633296966553, - "obj": 134.8336660861969 + "defaults": 191.03862500190735, + "str": 163.90049982070923, + "obj": 134.50950002670288 } } }, "extend-minipass-current": { "fast-fast": { "1": { - "defaults": 9.264999866485596, - "str": 8.606290817260742, - "obj": 5.553667068481445 + "defaults": 9.33525013923645, + "str": 8.731750011444092, + "obj": 5.395874977111816 }, "20": { - "defaults": 55.02154207229614, - "str": 61.52625012397766, - "obj": 30.30887508392334 + "defaults": 55.11312484741211, + "str": 61.02541708946228, + "obj": 30.082666873931885 } }, "fast-slow": { "1": { - "defaults": 13.048249959945679, - "str": 12.585958003997803, - "obj": 7.9548749923706055 + "defaults": 13.090957880020142, + "str": 12.572582960128784, + "obj": 7.939083099365234 }, "20": { - "defaults": 114.63466596603394, - "str": 120.61920809745789, - "obj": 88.93641710281372 + "defaults": 112.31958413124084, + "str": 120.6009578704834, + "obj": 89.31583404541016 } }, "slow-fast": { "1": { - "defaults": 12.917500019073486, - "str": 13.975665807723999, - "obj": 7.778666973114014 + "defaults": 13.612625122070312, + "str": 14.184916019439697, + "obj": 7.404917001724243 }, "20": { - "defaults": 59.025875091552734, - "str": 63.917749881744385, - "obj": 38.440624952316284 + "defaults": 58.18820810317993, + "str": 62.939374923706055, + "obj": 37.03279209136963 } }, "slow-slow": { "1": { - "defaults": 19.838834047317505, - "str": 19.04937481880188, - "obj": 17.28666615486145 + "defaults": 19.72470784187317, + "str": 19.544250011444092, + "obj": 17.341624975204468 }, "20": { - "defaults": 116.37400007247925, - "str": 124.82429099082947, - "obj": 96.49554204940796 + "defaults": 115.94391703605652, + "str": 128.59970808029175, + "obj": 96.19916701316833 } }, "fast-mixed": { "1": { - "defaults": 13.131874799728394, - "str": 12.410041093826294, - "obj": 7.892500162124634 + "defaults": 13.334333181381226, + "str": 12.839375019073486, + "obj": 8.038000106811523 }, "20": { - "defaults": 112.85424995422363, - "str": 120.06445789337158, - "obj": 88.77620792388916 + "defaults": 113.43108415603638, + "str": 120.52441716194153, + "obj": 89.3023750782013 } } } isaacs-minipass-90fd647/bench/impls/000077500000000000000000000000001514545521100173515ustar00rootroot00000000000000isaacs-minipass-90fd647/bench/impls/README.md000066400000000000000000000012551514545521100206330ustar00rootroot00000000000000To 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-90fd647/bench/impls/baseline.js000066400000000000000000000005171514545521100214740ustar00rootroot00000000000000// 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-90fd647/bench/impls/core-extend-transform.js000066400000000000000000000003311514545521100241320ustar00rootroot00000000000000const 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-90fd647/bench/impls/core-passthrough.js000066400000000000000000000000571514545521100232060ustar00rootroot00000000000000module.exports = require('stream').PassThrough isaacs-minipass-90fd647/bench/impls/extend-minipass-current.js000066400000000000000000000003301514545521100244730ustar00rootroot00000000000000const Minipass = require('../..').Minipass module.exports = class ExtendMinipass extends Minipass { constructor (opts) { super(opts) } write (data, encoding) { return super.write(data, encoding) } } isaacs-minipass-90fd647/bench/impls/extend-minipass.js000066400000000000000000000003221514545521100230140ustar00rootroot00000000000000const Minipass = require('minipass') module.exports = class ExtendMinipass extends Minipass { constructor (opts) { super(opts) } write (data, encoding) { return super.write(data, encoding) } } isaacs-minipass-90fd647/bench/impls/extend-through2.js000066400000000000000000000004501514545521100227350ustar00rootroot00000000000000const 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-90fd647/bench/impls/minipass-current-async.js000066400000000000000000000002461514545521100243270ustar00rootroot00000000000000const Minipass = require('../..').Minipass module.exports = class extends Minipass { constructor (options = {}) { options.async = true super(options) } } isaacs-minipass-90fd647/bench/impls/minipass-current.js000066400000000000000000000000531514545521100232100ustar00rootroot00000000000000module.exports = require('../..').Minipass isaacs-minipass-90fd647/bench/impls/minipass-latest.js000066400000000000000000000000561514545521100230250ustar00rootroot00000000000000module.exports = require('minipass').Minipass isaacs-minipass-90fd647/bench/impls/minipass-v3.js000066400000000000000000000000461514545521100220600ustar00rootroot00000000000000module.exports = require('minipass3') isaacs-minipass-90fd647/bench/impls/minipass-v4.js000066400000000000000000000000461514545521100220610ustar00rootroot00000000000000module.exports = require('minipass4') isaacs-minipass-90fd647/bench/impls/minipass-v5.js000066400000000000000000000000571514545521100220640ustar00rootroot00000000000000module.exports = require('minipass5').Minipass isaacs-minipass-90fd647/bench/impls/push-through.js000066400000000000000000000040241514545521100223440ustar00rootroot00000000000000// 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-90fd647/bench/impls/through2.js000066400000000000000000000003231514545521100214470ustar00rootroot00000000000000const 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-90fd647/bench/impls/web-std.js.REMOVED-GH-42157000066400000000000000000000005331514545521100233310ustar00rootroot00000000000000const { 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-90fd647/bench/index.js000066400000000000000000000165371514545521100177060ustar00rootroot00000000000000// 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-v4', 'minipass-v5', '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-90fd647/bench/package-lock.json000066400000000000000000000122371514545521100214460ustar00rootroot00000000000000{ "name": "bench", "lockfileVersion": 3, "requires": true, "packages": { "": { "dependencies": { "@npmcli/promise-spawn": "^2.0.0", "@web-std/stream": "^1.0.1", "minipass": "6", "minipass3": "npm:minipass@3", "minipass4": "npm:minipass@4", "minipass5": "npm:minipass@5", "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": "6.0.2", "resolved": "https://registry.npmjs.org/minipass/-/minipass-6.0.2.tgz", "integrity": "sha512-MzWSV5nYVT7mVyWCwn2o7JH13w2TBRmmSqSRCKzTw+lmft9X4z+3wjvs06Tzijo5z4W/kahUCDpRXTF+ZrmF/w==", "engines": { "node": ">=16 || 14 >=14.17" } }, "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/minipass4": { "name": "minipass", "version": "4.2.8", "resolved": "https://registry.npmjs.org/minipass/-/minipass-4.2.8.tgz", "integrity": "sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==", "engines": { "node": ">=8" } }, "node_modules/minipass5": { "name": "minipass", "version": "5.0.0", "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", "engines": { "node": ">=8" } }, "node_modules/readable-stream": { "version": "3.6.2", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", "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": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" }, "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==" } } } isaacs-minipass-90fd647/bench/package.json000066400000000000000000000003731514545521100205160ustar00rootroot00000000000000{ "dependencies": { "@npmcli/promise-spawn": "^2.0.0", "@web-std/stream": "^1.0.1", "minipass": "6", "minipass5": "npm:minipass@5", "minipass4": "npm:minipass@4", "minipass3": "npm:minipass@3", "through2": "^4.0.2" } } isaacs-minipass-90fd647/bench/results-nextTick.json000066400000000000000000000026641514545521100224200ustar00rootroot00000000000000{ "minipass-current-async": { "fast-fast": { "1": { "defaults": 24.52541708946228, "str": 21.20929217338562, "obj": 8.22320818901062 }, "20": { "defaults": 178.54866695404053, "str": 163.10595893859863, "obj": 132.5037910938263 } }, "fast-slow": { "1": { "defaults": 29.903625011444092, "str": 27.529124975204468, "obj": 12.759667158126831 }, "20": { "defaults": 191.90645790100098, "str": 161.4192910194397, "obj": 133.296875 } }, "slow-fast": { "1": { "defaults": 37.47254204750061, "str": 23.132165908813477, "obj": 14.519999980926514 }, "20": { "defaults": 175.35491704940796, "str": 163.75045800209045, "obj": 134.10804200172424 } }, "slow-slow": { "1": { "defaults": 40.83904218673706, "str": 25.787042140960693, "obj": 14.58033299446106 }, "20": { "defaults": 188.99554204940796, "str": 163.10204195976257, "obj": 134.2707920074463 } }, "fast-mixed": { "1": { "defaults": 28.914207935333252, "str": 28.854541063308716, "obj": 12.629791021347046 }, "20": { "defaults": 187.74029111862183, "str": 162.31783318519592, "obj": 133.96545886993408 } } } } isaacs-minipass-90fd647/bench/results-promise-defer.json000066400000000000000000000026711514545521100233660ustar00rootroot00000000000000{ "minipass-current-async": { "fast-fast": { "1": { "defaults": 17.14595890045166, "str": 14.430583953857422, "obj": 8.14916706085205 }, "20": { "defaults": 165.50191712379456, "str": 158.9027500152588, "obj": 126.32129096984863 } }, "fast-slow": { "1": { "defaults": 22.986708879470825, "str": 24.979916095733643, "obj": 12.887042045593262 }, "20": { "defaults": 168.84174990653992, "str": 165.80754208564758, "obj": 136.3969588279724 } }, "slow-fast": { "1": { "defaults": 15.21733283996582, "str": 14.676584005355835, "obj": 12.021875143051147 }, "20": { "defaults": 85.48395895957947, "str": 89.20491695404053, "obj": 60.448583126068115 } }, "slow-slow": { "1": { "defaults": 21.6863751411438, "str": 18.976624965667725, "obj": 14.663833141326904 }, "20": { "defaults": 173.18383312225342, "str": 167.75729203224182, "obj": 128.6553339958191 } }, "fast-mixed": { "1": { "defaults": 22.969000101089478, "str": 26.25429105758667, "obj": 13.501375198364258 }, "20": { "defaults": 168.70462489128113, "str": 162.4323329925537, "obj": 135.76133394241333 } } } } isaacs-minipass-90fd647/bench/results-qm.json000066400000000000000000000027031514545521100212360ustar00rootroot00000000000000{ "minipass-current-async": { "fast-fast": { "1": { "defaults": 24.707584142684937, "str": 24.110999822616577, "obj": 13.093999862670898 }, "20": { "defaults": 235.39866709709167, "str": 229.49095821380615, "obj": 202.40733408927917 } }, "fast-slow": { "1": { "defaults": 29.634999990463257, "str": 26.674499988555908, "obj": 15.581332921981812 }, "20": { "defaults": 242.4340419769287, "str": 241.9201250076294, "obj": 198.6067500114441 } }, "slow-fast": { "1": { "defaults": 19.403500080108643, "str": 17.811957836151123, "obj": 14.711999893188477 }, "20": { "defaults": 132.10370802879333, "str": 136.36554193496704, "obj": 102.89450001716614 } }, "slow-slow": { "1": { "defaults": 26.931583881378174, "str": 22.143749952316284, "obj": 17.612792015075684 }, "20": { "defaults": 220.47929215431213, "str": 208.18587493896484, "obj": 172.82945895195007 } }, "fast-mixed": { "1": { "defaults": 30.526124954223633, "str": 26.479417085647583, "obj": 16.500207901000977 }, "20": { "defaults": 243.33962488174438, "str": 237.56174993515015, "obj": 199.57999992370605 } } } } isaacs-minipass-90fd647/bench/results.json000066400000000000000000000342561514545521100206330ustar00rootroot00000000000000{ "baseline": { "fast-fast": { "1": { "defaults": 3.3990838527679443, "str": 2.658750057220459, "obj": 1.8272500038146973 }, "20": { "defaults": 3.3317079544067383, "str": 2.5267090797424316, "obj": 1.6895420551300049 } }, "fast-slow": { "1": { "defaults": 3.533208131790161, "str": 2.6589999198913574, "obj": 1.7267498970031738 }, "20": { "defaults": 3.558332920074463, "str": 2.7277917861938477, "obj": 1.825958013534546 } }, "slow-fast": { "1": { "defaults": 7.663082838058472, "str": 7.863041877746582, "obj": 5.66966700553894 }, "20": { "defaults": 7.421875, "str": 7.890166997909546, "obj": 5.565249919891357 } }, "slow-slow": { "1": { "defaults": 7.716665983200073, "str": 7.789834022521973, "obj": 5.735374927520752 }, "20": { "defaults": 7.742792129516602, "str": 7.878582954406738, "obj": 5.557208061218262 } }, "fast-mixed": { "1": { "defaults": 3.6327500343322754, "str": 2.7679169178009033, "obj": 1.7796669006347656 }, "20": { "defaults": 3.5595409870147705, "str": 2.654458999633789, "obj": 1.7744169235229492 } } }, "minipass-v3": { "fast-fast": { "1": { "defaults": 8.96229100227356, "str": 8.173666954040527, "obj": 5.094624996185303 }, "20": { "defaults": 56.02125000953674, "str": 59.039124965667725, "obj": 29.18766713142395 } }, "fast-slow": { "1": { "defaults": 12.820749998092651, "str": 12.260708093643188, "obj": 7.883208990097046 }, "20": { "defaults": 112.68245792388916, "str": 124.49425005912781, "obj": 93.80837512016296 } }, "slow-fast": { "1": { "defaults": 13.644958019256592, "str": 13.941625118255615, "obj": 9.986666917800903 }, "20": { "defaults": 58.234708070755005, "str": 60.60979080200195, "obj": 36.09575009346008 } }, "slow-slow": { "1": { "defaults": 19.341042041778564, "str": 19.677291870117188, "obj": 16.29824995994568 }, "20": { "defaults": 108.75849986076355, "str": 119.96637487411499, "obj": 92.20295882225037 } }, "fast-mixed": { "1": { "defaults": 14.748833894729614, "str": 14.528291940689087, "obj": 8.816375017166138 }, "20": { "defaults": 112.7664577960968, "str": 124.79616594314575, "obj": 94.15024995803833 } } }, "minipass-v4": { "fast-fast": { "1": { "defaults": 9.067874908447266, "str": 8.513124942779541, "obj": 5.3687920570373535 }, "20": { "defaults": 55.740999937057495, "str": 57.79591608047485, "obj": 28.896167039871216 } }, "fast-slow": { "1": { "defaults": 12.763917207717896, "str": 12.276791095733643, "obj": 7.75220799446106 }, "20": { "defaults": 109.29241704940796, "str": 120.14249992370605, "obj": 88.43941688537598 } }, "slow-fast": { "1": { "defaults": 12.893832921981812, "str": 13.651708126068115, "obj": 9.69395899772644 }, "20": { "defaults": 58.75887489318848, "str": 61.16729211807251, "obj": 36.75349998474121 } }, "slow-slow": { "1": { "defaults": 19.634707927703857, "str": 19.170832872390747, "obj": 16.464499950408936 }, "20": { "defaults": 114.11229205131531, "str": 123.68508315086365, "obj": 95.43070816993713 } }, "fast-mixed": { "1": { "defaults": 13.131667137145996, "str": 12.219375133514404, "obj": 7.822416067123413 }, "20": { "defaults": 110.00562500953674, "str": 119.71024990081787, "obj": 89.30245780944824 } } }, "minipass-v5": { "fast-fast": { "1": { "defaults": 9.045500040054321, "str": 8.363375186920166, "obj": 5.296582937240601 }, "20": { "defaults": 55.41020894050598, "str": 57.3116250038147, "obj": 29.30795907974243 } }, "fast-slow": { "1": { "defaults": 12.69533395767212, "str": 12.118332862854004, "obj": 7.893208026885986 }, "20": { "defaults": 109.11375021934509, "str": 119.16074991226196, "obj": 87.87933301925659 } }, "slow-fast": { "1": { "defaults": 12.915709018707275, "str": 14.087542057037354, "obj": 9.628709077835083 }, "20": { "defaults": 58.45437502861023, "str": 60.98283386230469, "obj": 36.37870812416077 } }, "slow-slow": { "1": { "defaults": 19.6010000705719, "str": 19.504374980926514, "obj": 16.68008303642273 }, "20": { "defaults": 113.02391600608826, "str": 122.68854212760925, "obj": 93.84029197692871 } }, "fast-mixed": { "1": { "defaults": 13.159540891647339, "str": 12.466333150863647, "obj": 7.881624937057495 }, "20": { "defaults": 110.05741691589355, "str": 119.14762496948242, "obj": 88.40920901298523 } } }, "minipass-latest": { "fast-fast": { "1": { "defaults": 9.106709003448486, "str": 8.27245807647705, "obj": 5.223582983016968 }, "20": { "defaults": 55.94037485122681, "str": 57.88187503814697, "obj": 29.797584056854248 } }, "fast-slow": { "1": { "defaults": 12.913458108901978, "str": 12.469624996185303, "obj": 7.9867918491363525 }, "20": { "defaults": 109.13374996185303, "str": 119.18562507629395, "obj": 88.77216601371765 } }, "slow-fast": { "1": { "defaults": 13.740790843963623, "str": 13.026999950408936, "obj": 11.303791046142578 }, "20": { "defaults": 58.92799997329712, "str": 61.270041942596436, "obj": 36.384124994277954 } }, "slow-slow": { "1": { "defaults": 19.82358407974243, "str": 19.03404211997986, "obj": 16.994542121887207 }, "20": { "defaults": 113.54299998283386, "str": 122.18516683578491, "obj": 94.0842502117157 } }, "fast-mixed": { "1": { "defaults": 13.074541091918945, "str": 12.364291906356812, "obj": 7.872082948684692 }, "20": { "defaults": 109.3677499294281, "str": 120.48091697692871, "obj": 88.43137502670288 } } }, "minipass-current": { "fast-fast": { "1": { "defaults": 9.237291097640991, "str": 8.494791984558105, "obj": 5.270291805267334 }, "20": { "defaults": 55.45591592788696, "str": 60.21724987030029, "obj": 30.116125106811523 } }, "fast-slow": { "1": { "defaults": 12.837042093276978, "str": 12.397625207901001, "obj": 8.142207860946655 }, "20": { "defaults": 112.8249580860138, "str": 119.85637497901917, "obj": 93.4788339138031 } }, "slow-fast": { "1": { "defaults": 13.317584037780762, "str": 13.745499849319458, "obj": 7.646499872207642 }, "20": { "defaults": 58.255666971206665, "str": 62.18691611289978, "obj": 38.114166021347046 } }, "slow-slow": { "1": { "defaults": 19.602458000183105, "str": 19.340165853500366, "obj": 17.1333749294281 }, "20": { "defaults": 114.9782497882843, "str": 122.02308297157288, "obj": 95.23783302307129 } }, "fast-mixed": { "1": { "defaults": 13.639082908630371, "str": 12.444166898727417, "obj": 7.978666067123413 }, "20": { "defaults": 112.22262501716614, "str": 118.59824991226196, "obj": 89.4826250076294 } } }, "minipass-current-async": { "fast-fast": { "1": { "defaults": 16.789916038513184, "str": 13.664083003997803, "obj": 8.046792030334473 }, "20": { "defaults": 164.3801248073578, "str": 156.7847089767456, "obj": 125.96362495422363 } }, "fast-slow": { "1": { "defaults": 23.611124992370605, "str": 24.252208948135376, "obj": 13.320249795913696 }, "20": { "defaults": 167.81833291053772, "str": 162.2190420627594, "obj": 133.96308302879333 } }, "slow-fast": { "1": { "defaults": 15.29449987411499, "str": 14.680792093276978, "obj": 12.648375034332275 }, "20": { "defaults": 85.04554104804993, "str": 87.39795804023743, "obj": 59.65033411979675 } }, "slow-slow": { "1": { "defaults": 21.52458381652832, "str": 18.75612497329712, "obj": 14.529249906539917 }, "20": { "defaults": 176.85458302497864, "str": 166.02983283996582, "obj": 127.8735420703888 } }, "fast-mixed": { "1": { "defaults": 22.599792003631592, "str": 24.439208030700684, "obj": 13.420375108718872 }, "20": { "defaults": 167.20274996757507, "str": 161.45175004005432, "obj": 134.34225010871887 } } }, "extend-minipass-current": { "fast-fast": { "1": { "defaults": 9.193875074386597, "str": 8.732290983200073, "obj": 5.323959112167358 }, "20": { "defaults": 55.100250005722046, "str": 62.77754187583923, "obj": 31.361207962036133 } }, "fast-slow": { "1": { "defaults": 13.048874855041504, "str": 12.627707958221436, "obj": 7.943833112716675 }, "20": { "defaults": 112.71425008773804, "str": 119.46612501144409, "obj": 88.86787509918213 } }, "slow-fast": { "1": { "defaults": 13.905959129333496, "str": 15.27899980545044, "obj": 8.198750019073486 }, "20": { "defaults": 59.27174997329712, "str": 62.621875047683716, "obj": 37.86075019836426 } }, "slow-slow": { "1": { "defaults": 19.91116714477539, "str": 19.340209007263184, "obj": 17.08750009536743 }, "20": { "defaults": 115.68562483787537, "str": 123.51199984550476, "obj": 95.79333400726318 } }, "fast-mixed": { "1": { "defaults": 13.097042083740234, "str": 12.528666973114014, "obj": 7.946000099182129 }, "20": { "defaults": 113.75462508201599, "str": 122.74500012397766, "obj": 89.51083302497864 } } }, "core-extend-transform": { "fast-fast": { "1": { "defaults": 24.127000093460083, "str": 1415.3659579753876, "obj": 6.487624883651733 }, "20": { "defaults": 242.2933750152588, "str": 30514.069749832153, "obj": 75.56558299064636 } }, "fast-slow": { "1": { "defaults": 32.54316711425781, "str": 1453.245125055313, "obj": 23.765000104904175 }, "20": { "defaults": 277.2532501220703, "str": 30932.80695796013, "obj": 124.2115831375122 } }, "slow-fast": { "1": { "defaults": 30.72125005722046, "str": 1442.7514998912811, "obj": 11.64175009727478 }, "20": { "defaults": 261.35354113578796, "str": 30612.279416799545, "obj": 78.83837509155273 } }, "slow-slow": { "1": { "defaults": 39.06583285331726, "str": 1452.0763339996338, "obj": 14.533082962036133 }, "20": { "defaults": 271.046875, "str": 30285.33316707611, "obj": 94.80037498474121 } }, "fast-mixed": { "1": { "defaults": 36.86058306694031, "str": 1484.2210412025452, "obj": 28.041290998458862 }, "20": { "defaults": 299.55041694641113, "str": 32348.9279589653, "obj": 129.61362504959106 } } }, "core-passthrough": { "fast-fast": { "1": { "defaults": 24.39108395576477, "str": 1457.369541168213, "obj": 6.425541877746582 }, "20": { "defaults": 246.28545904159546, "str": 30877.510459184647, "obj": 81.12966704368591 } }, "fast-slow": { "1": { "defaults": 35.926417112350464, "str": 1636.9020409584045, "obj": 25.536499977111816 }, "20": { "defaults": 309.2916250228882, "str": 31383.35754084587, "obj": 126.46375012397766 } }, "slow-fast": { "1": { "defaults": 31.042332887649536, "str": 1462.309958934784, "obj": 11.72333288192749 }, "20": { "defaults": 263.05920791625977, "str": 30782.21883392334, "obj": 81.56983304023743 } }, "slow-slow": { "1": { "defaults": 38.84020781517029, "str": 1576.2104170322418, "obj": 15.817957878112793 }, "20": { "defaults": 276.67433404922485, "str": 30440.37458395958, "obj": 95.23049998283386 } }, "fast-mixed": { "1": { "defaults": 37.690500020980835, "str": 1469.4447920322418, "obj": 25.87837505340576 }, "20": { "defaults": 290.7175419330597, "str": 31910.76212501526, "obj": 128.84325003623962 } } } } isaacs-minipass-90fd647/bench/results.tab000066400000000000000000000517571514545521100204350ustar00rootroot00000000000000impl case pipeline type time score core-extend-transform fast-mixed 20 str 32348.9279589653 1 core-passthrough fast-mixed 20 str 31910.76212501526 1.0137309736518816 core-passthrough fast-slow 20 str 31383.35754084587 1.0307669571957916 core-extend-transform fast-slow 20 str 30932.80695796013 1.045780552761661 core-passthrough fast-fast 20 str 30877.510459184647 1.047653372240798 core-passthrough slow-fast 20 str 30782.21883392334 1.0508965625088527 core-extend-transform slow-fast 20 str 30612.279416799545 1.0567304550739436 core-extend-transform fast-fast 20 str 30514.069749832153 1.0601315466660504 core-passthrough slow-slow 20 str 30440.37458395958 1.062698090975905 core-extend-transform slow-slow 20 str 30285.33316707611 1.068138421344249 core-passthrough fast-slow 1 str 1636.9020409584045 19.762287021173872 core-passthrough slow-slow 1 str 1576.2104170322418 20.523229392096827 core-extend-transform fast-mixed 1 str 1484.2210412025452 21.79522258541461 core-passthrough fast-mixed 1 str 1469.4447920322418 22.014388110646024 core-passthrough slow-fast 1 str 1462.309958934784 22.121799664504643 core-passthrough fast-fast 1 str 1457.369541168213 22.196791579049144 core-extend-transform fast-slow 1 str 1453.245125055313 22.259787699431673 core-extend-transform slow-slow 1 str 1452.0763339996338 22.277704829650823 core-extend-transform slow-fast 1 str 1442.7514998912811 22.421690749517822 core-extend-transform fast-fast 1 str 1415.3659579753876 22.85552211898531 core-passthrough fast-slow 20 defaults 309.2916250228882 104.5903779534005 core-extend-transform fast-mixed 20 defaults 299.55041694641113 107.991597169943 core-passthrough fast-mixed 20 defaults 290.7175419330597 111.27270732914332 core-extend-transform fast-slow 20 defaults 277.2532501220703 116.67646076185787 core-passthrough slow-slow 20 defaults 276.67433404922485 116.92059572540582 core-extend-transform slow-slow 20 defaults 271.046875 119.34809415886201 core-passthrough slow-fast 20 defaults 263.05920791625977 122.97204197947335 core-extend-transform slow-fast 20 defaults 261.35354113578796 123.77459214206017 core-passthrough fast-fast 20 defaults 246.28545904159546 131.34729141074402 core-extend-transform fast-fast 20 defaults 242.2933750152588 133.51140103161333 minipass-current-async slow-slow 20 defaults 176.85458302497864 182.91257939522208 minipass-current-async fast-slow 20 defaults 167.81833291053772 192.76158568569616 minipass-current-async fast-mixed 20 defaults 167.20274996757507 193.4712674596476 minipass-current-async slow-slow 20 str 166.02983283996582 194.83804449858147 minipass-current-async fast-fast 20 defaults 164.3801248073578 196.79342619356217 minipass-current-async fast-slow 20 str 162.2190420627594 199.4151090255491 minipass-current-async fast-mixed 20 str 161.45175004005432 200.362820167263 minipass-current-async fast-fast 20 str 156.7847089767456 206.3270593802825 minipass-current-async fast-mixed 20 obj 134.34225010871887 240.79489462761234 minipass-current-async fast-slow 20 obj 133.96308302879333 241.47643684799633 core-extend-transform fast-mixed 20 obj 129.61362504959106 249.5796869085976 core-passthrough fast-mixed 20 obj 128.84325003623962 251.0719649641448 minipass-current-async slow-slow 20 obj 127.8735420703888 252.9759278988192 core-passthrough fast-slow 20 obj 126.46375012397766 255.79605165315994 minipass-current-async fast-fast 20 obj 125.96362495422363 256.81166265833656 minipass-v3 fast-mixed 20 str 124.79616594314575 259.21411699220573 minipass-v3 fast-slow 20 str 124.49425005912781 259.84274730440455 core-extend-transform fast-slow 20 obj 124.2115831375122 260.4340685614838 minipass-v4 slow-slow 20 str 123.68508315086365 261.5426786713481 extend-minipass-current slow-slow 20 str 123.51199984550476 261.9091910051576 extend-minipass-current fast-mixed 20 str 122.74500012397766 263.545789452047 minipass-v5 slow-slow 20 str 122.68854212760925 263.6670661985611 minipass-latest slow-slow 20 str 122.18516683578491 264.7533149620509 minipass-current slow-slow 20 str 122.02308297157288 265.1049880988622 minipass-latest fast-mixed 20 str 120.48091697692871 268.49835451667343 minipass-v4 fast-slow 20 str 120.14249992370605 269.254659920576 minipass-v3 slow-slow 20 str 119.96637487411499 269.6499581062626 minipass-current fast-slow 20 str 119.85637497901917 269.8974331955891 minipass-v4 fast-mixed 20 str 119.71024990081787 270.22688521464937 extend-minipass-current fast-slow 20 str 119.46612501144409 270.77908449668456 minipass-latest fast-slow 20 str 119.18562507629395 271.41635527151766 minipass-v5 fast-slow 20 str 119.16074991226196 271.4730142499423 minipass-v5 fast-mixed 20 str 119.14762496948242 271.5029188978875 minipass-current fast-mixed 20 str 118.59824991226196 272.76058443439746 extend-minipass-current slow-slow 20 defaults 115.68562483787537 279.6278967615888 minipass-current slow-slow 20 defaults 114.9782497882843 281.3482377626302 minipass-v4 slow-slow 20 defaults 114.11229205131531 283.4832898143722 extend-minipass-current fast-mixed 20 defaults 113.75462508201599 284.37461716956153 minipass-latest slow-slow 20 defaults 113.54299998283386 284.90464373722745 minipass-v5 slow-slow 20 defaults 113.02391600608826 286.2131228688162 minipass-current fast-slow 20 defaults 112.8249580860138 286.7178371500357 minipass-v3 fast-mixed 20 defaults 112.7664577960968 286.8665788674352 extend-minipass-current fast-slow 20 defaults 112.71425008773804 286.99945156698936 minipass-v3 fast-slow 20 defaults 112.68245792388916 287.0804254271347 minipass-current fast-mixed 20 defaults 112.22262501716614 288.25673926284514 minipass-v5 fast-mixed 20 defaults 110.05741691589355 293.9277412233518 minipass-v4 fast-mixed 20 defaults 110.00562500953674 294.0661257654858 minipass-latest fast-mixed 20 defaults 109.3677499294281 295.7812333145662 minipass-v4 fast-slow 20 defaults 109.29241704940796 295.98510886936725 minipass-latest fast-slow 20 defaults 109.13374996185303 296.41543491607916 minipass-v5 fast-slow 20 defaults 109.11375021934509 296.46976567056043 minipass-v3 slow-slow 20 defaults 108.75849986076355 297.43815886003887 extend-minipass-current slow-slow 20 obj 95.79333400726318 337.69497944932743 minipass-v4 slow-slow 20 obj 95.43070816993713 338.97818196382156 minipass-current slow-slow 20 obj 95.23783302307129 339.66467875354533 core-passthrough slow-slow 20 obj 95.23049998283386 339.6908339743725 core-extend-transform slow-slow 20 obj 94.80037498474121 341.23206753319374 minipass-v3 fast-mixed 20 obj 94.15024995803833 343.58833856928516 minipass-latest slow-slow 20 obj 94.0842502117157 343.8293644916256 minipass-v5 slow-slow 20 obj 93.84029197692871 344.72322365448855 minipass-v3 fast-slow 20 obj 93.80837512016296 344.84051042914075 minipass-current fast-slow 20 obj 93.4788339138031 346.05617768824834 minipass-v3 slow-slow 20 obj 92.20295882225037 350.8447925334786 extend-minipass-current fast-mixed 20 obj 89.51083302497864 361.3967926087572 minipass-current fast-mixed 20 obj 89.4826250076294 361.5107173734252 minipass-v4 fast-mixed 20 obj 89.30245780944824 362.24006317934476 extend-minipass-current fast-slow 20 obj 88.86787509918213 364.01149372438425 minipass-latest fast-slow 20 obj 88.77216601371765 364.4039501521967 minipass-v4 fast-slow 20 obj 88.43941688537598 365.7750028009785 minipass-latest fast-mixed 20 obj 88.43137502670288 365.8082660051047 minipass-v5 fast-mixed 20 obj 88.40920901298523 365.8999816887176 minipass-v5 fast-slow 20 obj 87.87933301925659 368.1062070859918 minipass-current-async slow-fast 20 str 87.39795804023743 370.133681430773 minipass-current-async slow-fast 20 defaults 85.04554104804993 380.37182855581415 core-passthrough slow-fast 20 obj 81.56983304023743 396.5795534117124 core-passthrough fast-fast 20 obj 81.12966704368591 398.7311810554623 core-extend-transform slow-fast 20 obj 78.83837509155273 410.31956736043105 core-extend-transform fast-fast 20 obj 75.56558299064636 428.09076141144186 extend-minipass-current fast-fast 20 str 62.77754187583923 515.2945940913818 extend-minipass-current slow-fast 20 str 62.621875047683716 516.5755246762104 minipass-current slow-fast 20 str 62.18691611289978 520.1886502980163 minipass-latest slow-fast 20 str 61.270041942596436 527.9730017040438 minipass-v4 slow-fast 20 str 61.16729211807251 528.8598994462839 minipass-v5 slow-fast 20 str 60.98283386230469 530.4595721479113 minipass-v3 slow-fast 20 str 60.60979080200195 533.7244615253945 minipass-current fast-fast 20 str 60.21724987030029 537.2036755022931 minipass-current-async slow-fast 20 obj 59.65033411979675 542.3092500035024 extend-minipass-current slow-fast 20 defaults 59.27174997329712 545.7731208128496 minipass-v3 fast-fast 20 str 59.039124965667725 547.9235672577594 minipass-latest slow-fast 20 defaults 58.92799997329712 548.9568282246814 minipass-v4 slow-fast 20 defaults 58.75887489318848 550.5368851559698 minipass-v5 slow-fast 20 defaults 58.45437502861023 553.4047356272694 minipass-current slow-fast 20 defaults 58.255666971206665 555.2923799662962 minipass-v3 slow-fast 20 defaults 58.234708070755005 555.4922318776192 minipass-latest fast-fast 20 str 57.88187503814697 558.8783697426143 minipass-v4 fast-fast 20 str 57.79591608047485 559.7095807586604 minipass-v5 fast-fast 20 str 57.3116250038147 564.4392033346138 minipass-v3 fast-fast 20 defaults 56.02125000953674 577.4403097656408 minipass-latest fast-fast 20 defaults 55.94037485122681 578.2751375012616 minipass-v4 fast-fast 20 defaults 55.740999937057495 580.3435172582763 minipass-current fast-fast 20 defaults 55.45591592788696 583.3269078276658 minipass-v5 fast-fast 20 defaults 55.41020894050598 583.8080847826867 extend-minipass-current fast-fast 20 defaults 55.100250005722046 587.0922174691755 core-extend-transform slow-slow 1 defaults 39.06583285331726 828.0619046425476 core-passthrough slow-slow 1 defaults 38.84020781517029 832.8721646625792 minipass-current slow-fast 20 obj 38.114166021347046 848.7376567769385 extend-minipass-current slow-fast 20 obj 37.86075019836426 854.4185677642201 core-passthrough fast-mixed 1 defaults 37.690500020980835 858.2780260531941 core-extend-transform fast-mixed 1 defaults 36.86058306694031 877.6021773778874 minipass-v4 slow-fast 20 obj 36.75349998474121 880.1591133469047 minipass-latest slow-fast 20 obj 36.384124994277954 889.0945697897845 minipass-v5 slow-fast 20 obj 36.37870812416077 889.226957938094 minipass-v3 slow-fast 20 obj 36.09575009346008 896.1976929474132 core-passthrough fast-slow 1 defaults 35.926417112350464 900.421766462336 core-extend-transform fast-slow 1 defaults 32.54316711425781 994.0313382956691 extend-minipass-current fast-fast 20 obj 31.361207962036133 1031.4949602108707 core-passthrough slow-fast 1 defaults 31.042332887649536 1042.0907499460393 core-extend-transform slow-fast 1 defaults 30.72125005722046 1052.9821507495033 minipass-current fast-fast 20 obj 30.116125106811523 1074.139778747591 minipass-latest fast-fast 20 obj 29.797584056854248 1085.6225087659136 minipass-v5 fast-fast 20 obj 29.30795907974243 1103.759148528523 minipass-v3 fast-fast 20 obj 29.18766713142395 1108.3081019564556 minipass-v4 fast-fast 20 obj 28.896167039871216 1119.488543734189 core-extend-transform fast-mixed 1 obj 28.041290998458862 1153.6176405267213 core-passthrough fast-mixed 1 obj 25.87837505340576 1250.0370634634562 core-passthrough fast-slow 1 obj 25.536499977111816 1266.7721883562515 minipass-current-async fast-mixed 1 str 24.439208030700684 1323.6487826581115 core-passthrough fast-fast 1 defaults 24.39108395576477 1326.2603670108608 minipass-current-async fast-slow 1 str 24.252208948135376 1333.8549089753096 core-extend-transform fast-fast 1 defaults 24.127000093460083 1340.777047857428 core-extend-transform fast-slow 1 obj 23.765000104904175 1361.2004130515336 minipass-current-async fast-slow 1 defaults 23.611124992370605 1370.0714374862746 minipass-current-async fast-mixed 1 defaults 22.599792003631592 1431.3816673076951 minipass-current-async slow-slow 1 defaults 21.52458381652832 1502.8828540752168 extend-minipass-current slow-slow 1 defaults 19.91116714477539 1624.6625686859109 minipass-latest slow-slow 1 defaults 19.82358407974243 1631.8405303924037 minipass-v3 slow-slow 1 str 19.677291870117188 1643.972563525971 minipass-v4 slow-slow 1 defaults 19.634707927703857 1647.5380269508437 minipass-current slow-slow 1 defaults 19.602458000183105 1650.2485534550378 minipass-v5 slow-slow 1 defaults 19.6010000705719 1650.371299550812 minipass-v5 slow-slow 1 str 19.504374980926514 1658.5472741679537 minipass-v3 slow-slow 1 defaults 19.341042041778564 1672.5535205956544 extend-minipass-current slow-slow 1 str 19.340209007263184 1672.6255619479973 minipass-current slow-slow 1 str 19.340165853500366 1672.6292940818025 minipass-v4 slow-slow 1 str 19.170832872390747 1687.4033681423016 minipass-latest slow-slow 1 str 19.03404211997986 1699.530123714969 minipass-current-async slow-slow 1 str 18.75612497329712 1724.712754101399 minipass-current slow-slow 1 obj 17.1333749294281 1888.0651414102385 extend-minipass-current slow-slow 1 obj 17.08750009536743 1893.1340323875331 minipass-latest slow-slow 1 obj 16.994542121887207 1903.4892335994882 minipass-current-async fast-fast 1 defaults 16.789916038513184 1926.6878931831711 minipass-v5 slow-slow 1 obj 16.68008303642273 1939.3745156021098 minipass-v4 slow-slow 1 obj 16.464499950408936 1964.7683231437488 minipass-v3 slow-slow 1 obj 16.29824995994568 1984.809905263787 core-passthrough slow-slow 1 obj 15.817957878112793 2045.0761222298047 minipass-current-async slow-fast 1 defaults 15.29449987411499 2115.069353376758 extend-minipass-current slow-fast 1 str 15.27899980545044 2117.2150252548304 minipass-v3 fast-mixed 1 defaults 14.748833894729614 2193.321057776978 minipass-current-async slow-fast 1 str 14.680792093276978 2203.486552594079 core-extend-transform slow-slow 1 obj 14.533082962036133 2225.882013022866 minipass-current-async slow-slow 1 obj 14.529249906539917 2226.469237369534 minipass-v3 fast-mixed 1 str 14.528291940689087 2226.6160461964787 minipass-v5 slow-fast 1 str 14.087542057037354 2296.2790689810627 minipass-v3 slow-fast 1 str 13.941625118255615 2320.3125664745185 extend-minipass-current slow-fast 1 defaults 13.905959129333496 2326.263701633342 minipass-current slow-fast 1 str 13.745499849319458 2353.4195419286193 minipass-latest slow-fast 1 defaults 13.740790843963623 2354.2260650285857 minipass-current-async fast-fast 1 str 13.664083003997803 2367.442290090066 minipass-v4 slow-fast 1 str 13.651708126068115 2369.588307941817 minipass-v3 slow-fast 1 defaults 13.644958019256592 2370.760533913885 minipass-current fast-mixed 1 defaults 13.639082908630371 2371.781752165752 minipass-current-async fast-mixed 1 obj 13.420375108718872 2410.4339630528684 minipass-current-async fast-slow 1 obj 13.320249795913696 2428.5526513841432 minipass-current slow-fast 1 defaults 13.317584037780762 2429.0387706354522 minipass-v5 fast-mixed 1 defaults 13.159540891647339 2458.2109835988203 minipass-v4 fast-mixed 1 defaults 13.131667137145996 2463.428871682163 extend-minipass-current fast-mixed 1 defaults 13.097042083740234 2469.941514437521 minipass-latest fast-mixed 1 defaults 13.074541091918945 2474.192228357398 extend-minipass-current fast-slow 1 defaults 13.048874855041504 2479.058793829042 minipass-latest slow-fast 1 str 13.026999950408936 2483.2216229454907 minipass-v5 slow-fast 1 defaults 12.915709018707275 2504.618825966945 minipass-latest fast-slow 1 defaults 12.913458108901978 2505.0553992710406 minipass-v4 slow-fast 1 defaults 12.893832921981812 2508.8682438110263 minipass-current fast-slow 1 defaults 12.837042093276978 2519.9674289380964 minipass-v3 fast-slow 1 defaults 12.820749998092651 2523.169702535177 minipass-v4 fast-slow 1 defaults 12.763917207717896 2534.404402075331 minipass-v5 fast-slow 1 defaults 12.69533395767212 2548.095864734303 minipass-current-async slow-fast 1 obj 12.648375034332275 2557.556039503777 extend-minipass-current fast-slow 1 str 12.627707958221436 2561.7418510145467 extend-minipass-current fast-mixed 1 str 12.528666973114014 2581.992803255504 minipass-latest fast-slow 1 str 12.469624996185303 2594.21818770504 minipass-v5 fast-mixed 1 str 12.466333150863647 2594.903213919341 minipass-current fast-mixed 1 str 12.444166898727417 2599.5254019193053 minipass-current fast-slow 1 str 12.397625207901001 2609.2842311727045 minipass-latest fast-mixed 1 str 12.364291906356812 2616.318686421004 minipass-v4 fast-slow 1 str 12.276791095733643 2634.966067819384 minipass-v3 fast-slow 1 str 12.260708093643188 2638.422488480682 minipass-v4 fast-mixed 1 str 12.219375133514404 2647.3471520029725 minipass-v5 fast-slow 1 str 12.118332862854004 2669.420647630797 core-passthrough slow-fast 1 obj 11.72333288192749 2759.362741361197 core-extend-transform slow-fast 1 obj 11.64175009727478 2778.699739185938 minipass-latest slow-fast 1 obj 11.303791046142578 2861.776887675607 minipass-v3 slow-fast 1 obj 9.986666917800903 3239.2116634334134 minipass-v4 slow-fast 1 obj 9.69395899772644 3337.0192680361256 minipass-v5 slow-fast 1 obj 9.628709077835083 3359.632916257828 minipass-current fast-fast 1 defaults 9.237291097640991 3501.9929129684497 extend-minipass-current fast-fast 1 defaults 9.193875074386597 3518.530292965024 minipass-latest fast-fast 1 defaults 9.106709003448486 3552.208371511109 minipass-v4 fast-fast 1 defaults 9.067874908447266 3567.4210645352364 minipass-v5 fast-fast 1 defaults 9.045500040054321 3576.2454055299563 minipass-v3 fast-fast 1 defaults 8.96229100227356 3609.4485160947133 minipass-v3 fast-mixed 1 obj 8.816375017166138 3669.1869272778818 extend-minipass-current fast-fast 1 str 8.732290983200073 3704.5178660675565 minipass-v4 fast-fast 1 str 8.513124942779541 3799.8887807234923 minipass-current fast-fast 1 str 8.494791984558105 3808.0894762072357 minipass-v5 fast-fast 1 str 8.363375186920166 3867.9273900753788 minipass-latest fast-fast 1 str 8.27245807647705 3910.437219494689 extend-minipass-current slow-fast 1 obj 8.198750019073486 3945.5926676272716 minipass-v3 fast-fast 1 str 8.173666954040527 3957.700765257398 minipass-current fast-slow 1 obj 8.142207860946655 3972.992155373966 minipass-current-async fast-fast 1 obj 8.046792030334473 4020.102400685592 minipass-latest fast-slow 1 obj 7.9867918491363525 4050.3031217050357 minipass-current fast-mixed 1 obj 7.978666067123413 4054.428107006641 extend-minipass-current fast-mixed 1 obj 7.946000099182129 4071.095841327127 extend-minipass-current fast-slow 1 obj 7.943833112716675 4072.206389530059 minipass-v5 fast-slow 1 obj 7.893208026885986 4098.324515048609 baseline slow-fast 20 str 7.890166997909546 4099.904091705025 minipass-v3 fast-slow 1 obj 7.883208990097046 4103.522816609619 minipass-v5 fast-mixed 1 obj 7.881624937057495 4104.347544738961 baseline slow-slow 20 str 7.878582954406738 4105.932265506138 minipass-latest fast-mixed 1 obj 7.872082948684692 4109.322547772483 baseline slow-fast 1 str 7.863041877746582 4114.04752281899 minipass-v4 fast-mixed 1 obj 7.822416067123413 4135.41387742383 baseline slow-slow 1 str 7.789834022521973 4152.710810710223 minipass-v4 fast-slow 1 obj 7.75220799446106 4172.866360407069 baseline slow-slow 20 defaults 7.742792129516602 4177.94090527714 baseline slow-slow 1 defaults 7.716665983200073 4192.086067920011 baseline slow-fast 1 defaults 7.663082838058472 4221.398703705161 minipass-current slow-fast 1 obj 7.646499872207642 4230.553651945038 baseline slow-fast 20 defaults 7.421875 4358.592398681641 core-extend-transform fast-fast 1 obj 6.487624883651733 4986.251292130324 core-passthrough fast-fast 1 obj 6.425541877746582 5034.428002251224 baseline slow-slow 1 obj 5.735374927520752 5640.2464298788 baseline slow-fast 1 obj 5.66966700553894 5705.613385647208 baseline slow-fast 20 obj 5.565249919891357 5812.664017718867 baseline slow-slow 20 obj 5.557208061218262 5821.075547758726 minipass-v4 fast-fast 1 obj 5.3687920570373535 6025.364293363287 extend-minipass-current fast-fast 1 obj 5.323959112167358 6076.103756138015 minipass-v5 fast-fast 1 obj 5.296582937240601 6107.509000098535 minipass-current fast-fast 1 obj 5.270291805267334 6137.976634734822 minipass-latest fast-fast 1 obj 5.223582983016968 6192.861885058373 minipass-v3 fast-fast 1 obj 5.094624996185303 6349.619056002586 baseline fast-mixed 1 defaults 3.6327500343322754 8904.804253869137 baseline fast-mixed 20 defaults 3.5595409870147705 9087.949282498617 baseline fast-slow 20 defaults 3.558332920074463 9091.034674262113 baseline fast-slow 1 defaults 3.533208131790161 9155.68139558627 baseline fast-fast 1 defaults 3.3990838527679443 9516.954967916694 baseline fast-fast 20 defaults 3.3317079544067383 9709.412830190731 baseline fast-mixed 1 str 2.7679169178009033 11687.102221502504 baseline fast-slow 20 str 2.7277917861938477 11859.016557895911 baseline fast-slow 1 str 2.6589999198913574 12165.825097236944 baseline fast-fast 1 str 2.658750057220459 12166.968411007347 baseline fast-mixed 20 str 2.654458999633789 12186.636886622917 baseline fast-fast 20 str 2.5267090797424316 12802.790878585394 baseline fast-fast 1 obj 1.8272500038146973 17703.61356761876 baseline fast-slow 20 obj 1.825958013534546 17716.140086018073 baseline fast-mixed 1 obj 1.7796669006347656 18176.956568348378 baseline fast-mixed 20 obj 1.7744169235229492 18230.736829729587 baseline fast-slow 1 obj 1.7267498970031738 18733.997329380378 baseline fast-fast 20 obj 1.6895420551300049 19146.56569852365 isaacs-minipass-90fd647/bench/results/000077500000000000000000000000001514545521100177265ustar00rootroot00000000000000isaacs-minipass-90fd647/bench/results/baseline-fast-fast-1.json000066400000000000000000000001351514545521100244260ustar00rootroot00000000000000{ "defaults": 3.3990838527679443, "str": 2.658750057220459, "obj": 1.8272500038146973 }isaacs-minipass-90fd647/bench/results/baseline-fast-fast-20.json000066400000000000000000000001361514545521100245100ustar00rootroot00000000000000{ "defaults": 3.3317079544067383, "str": 2.5267090797424316, "obj": 1.6895420551300049 }isaacs-minipass-90fd647/bench/results/baseline-fast-mixed-1.json000066400000000000000000000001361514545521100246000ustar00rootroot00000000000000{ "defaults": 3.6327500343322754, "str": 2.7679169178009033, "obj": 1.7796669006347656 }isaacs-minipass-90fd647/bench/results/baseline-fast-mixed-20.json000066400000000000000000000001351514545521100246600ustar00rootroot00000000000000{ "defaults": 3.5595409870147705, "str": 2.654458999633789, "obj": 1.7744169235229492 }isaacs-minipass-90fd647/bench/results/baseline-fast-slow-1.json000066400000000000000000000001351514545521100244550ustar00rootroot00000000000000{ "defaults": 3.533208131790161, "str": 2.6589999198913574, "obj": 1.7267498970031738 }isaacs-minipass-90fd647/bench/results/baseline-fast-slow-20.json000066400000000000000000000001341514545521100245350ustar00rootroot00000000000000{ "defaults": 3.558332920074463, "str": 2.7277917861938477, "obj": 1.825958013534546 }isaacs-minipass-90fd647/bench/results/baseline-slow-fast-1.json000066400000000000000000000001321514545521100244520ustar00rootroot00000000000000{ "defaults": 7.663082838058472, "str": 7.863041877746582, "obj": 5.66966700553894 }isaacs-minipass-90fd647/bench/results/baseline-slow-fast-20.json000066400000000000000000000001221514545521100245320ustar00rootroot00000000000000{ "defaults": 7.421875, "str": 7.890166997909546, "obj": 5.565249919891357 }isaacs-minipass-90fd647/bench/results/baseline-slow-slow-1.json000066400000000000000000000001331514545521100245020ustar00rootroot00000000000000{ "defaults": 7.716665983200073, "str": 7.789834022521973, "obj": 5.735374927520752 }isaacs-minipass-90fd647/bench/results/baseline-slow-slow-20.json000066400000000000000000000001331514545521100245630ustar00rootroot00000000000000{ "defaults": 7.742792129516602, "str": 7.878582954406738, "obj": 5.557208061218262 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-fast-1.json000066400000000000000000000001351514545521100270720ustar00rootroot00000000000000{ "defaults": 24.127000093460083, "str": 1415.3659579753876, "obj": 6.487624883651733 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-fast-20.json000066400000000000000000000001341514545521100271520ustar00rootroot00000000000000{ "defaults": 242.2933750152588, "str": 30514.069749832153, "obj": 75.56558299064636 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-mixed-1.json000066400000000000000000000001351514545521100272430ustar00rootroot00000000000000{ "defaults": 36.86058306694031, "str": 1484.2210412025452, "obj": 28.041290998458862 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-mixed-20.json000066400000000000000000000001341514545521100273230ustar00rootroot00000000000000{ "defaults": 299.55041694641113, "str": 32348.9279589653, "obj": 129.61362504959106 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-slow-1.json000066400000000000000000000001341514545521100271200ustar00rootroot00000000000000{ "defaults": 32.54316711425781, "str": 1453.245125055313, "obj": 23.765000104904175 }isaacs-minipass-90fd647/bench/results/core-extend-transform-fast-slow-20.json000066400000000000000000000001331514545521100272000ustar00rootroot00000000000000{ "defaults": 277.2532501220703, "str": 30932.80695796013, "obj": 124.2115831375122 }isaacs-minipass-90fd647/bench/results/core-extend-transform-slow-fast-1.json000066400000000000000000000001341514545521100271200ustar00rootroot00000000000000{ "defaults": 30.72125005722046, "str": 1442.7514998912811, "obj": 11.64175009727478 }isaacs-minipass-90fd647/bench/results/core-extend-transform-slow-fast-20.json000066400000000000000000000001351514545521100272020ustar00rootroot00000000000000{ "defaults": 261.35354113578796, "str": 30612.279416799545, "obj": 78.83837509155273 }isaacs-minipass-90fd647/bench/results/core-extend-transform-slow-slow-1.json000066400000000000000000000001351514545521100271500ustar00rootroot00000000000000{ "defaults": 39.06583285331726, "str": 1452.0763339996338, "obj": 14.533082962036133 }isaacs-minipass-90fd647/bench/results/core-extend-transform-slow-slow-20.json000066400000000000000000000001241514545521100272270ustar00rootroot00000000000000{ "defaults": 271.046875, "str": 30285.33316707611, "obj": 94.80037498474121 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-fast-1.json000066400000000000000000000001331514545521100261370ustar00rootroot00000000000000{ "defaults": 24.39108395576477, "str": 1457.369541168213, "obj": 6.425541877746582 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-fast-100.json000066400000000000000000000000351514545521100263000ustar00rootroot00000000000000{ "obj": 407.321750164032 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-fast-20.json000066400000000000000000000001351514545521100262220ustar00rootroot00000000000000{ "defaults": 246.28545904159546, "str": 30877.510459184647, "obj": 81.12966704368591 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-mixed-1.json000066400000000000000000000001351514545521100263120ustar00rootroot00000000000000{ "defaults": 37.690500020980835, "str": 1469.4447920322418, "obj": 25.87837505340576 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-mixed-100.json000066400000000000000000000000361514545521100264520ustar00rootroot00000000000000{ "obj": 722.3131666183472 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-mixed-20.json000066400000000000000000000001341514545521100263720ustar00rootroot00000000000000{ "defaults": 290.7175419330597, "str": 31910.76212501526, "obj": 128.84325003623962 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-slow-1.json000066400000000000000000000001361514545521100261710ustar00rootroot00000000000000{ "defaults": 35.926417112350464, "str": 1636.9020409584045, "obj": 25.536499977111816 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-slow-100.json000066400000000000000000000000361514545521100263300ustar00rootroot00000000000000{ "obj": 713.4662504196167 }isaacs-minipass-90fd647/bench/results/core-passthrough-fast-slow-20.json000066400000000000000000000001341514545521100262500ustar00rootroot00000000000000{ "defaults": 309.2916250228882, "str": 31383.35754084587, "obj": 126.46375012397766 }isaacs-minipass-90fd647/bench/results/core-passthrough-mixed-1.json000066400000000000000000000000171514545521100253560ustar00rootroot00000000000000{ "obj": {} }isaacs-minipass-90fd647/bench/results/core-passthrough-slow-fast-1.json000066400000000000000000000001341514545521100261670ustar00rootroot00000000000000{ "defaults": 31.042332887649536, "str": 1462.309958934784, "obj": 11.72333288192749 }isaacs-minipass-90fd647/bench/results/core-passthrough-slow-fast-20.json000066400000000000000000000001341514545521100262500ustar00rootroot00000000000000{ "defaults": 263.05920791625977, "str": 30782.21883392334, "obj": 81.56983304023743 }isaacs-minipass-90fd647/bench/results/core-passthrough-slow-slow-1.json000066400000000000000000000001351514545521100262170ustar00rootroot00000000000000{ "defaults": 38.84020781517029, "str": 1576.2104170322418, "obj": 15.817957878112793 }isaacs-minipass-90fd647/bench/results/core-passthrough-slow-slow-100.json000066400000000000000000000000371514545521100263600ustar00rootroot00000000000000{ "obj": 423.62200021743774 }isaacs-minipass-90fd647/bench/results/core-passthrough-slow-slow-20.json000066400000000000000000000001341514545521100262770ustar00rootroot00000000000000{ "defaults": 276.67433404922485, "str": 30440.37458395958, "obj": 95.23049998283386 }isaacs-minipass-90fd647/bench/results/core-transform-fast-fast-20.json000066400000000000000000000002071514545521100256660ustar00rootroot00000000000000{ "obj": { "code": "MODULE_NOT_FOUND", "requireStack": [ "/Users/isaacs/dev/isaacs/minipass/bench/index.js" ] } }isaacs-minipass-90fd647/bench/results/extend-core-passthroughfast-fast-20-obj.json000066400000000000000000000006261514545521100302070ustar00rootroot00000000000000{ "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-90fd647/bench/results/extend-core-transform-fast-fast-20.json000066400000000000000000000002071514545521100271530ustar00rootroot00000000000000{ "obj": { "code": "MODULE_NOT_FOUND", "requireStack": [ "/Users/isaacs/dev/isaacs/minipass/bench/index.js" ] } }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-fast-1.json000066400000000000000000000001331514545521100274320ustar00rootroot00000000000000{ "defaults": 9.193875074386597, "str": 8.732290983200073, "obj": 5.323959112167358 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-fast-20.json000066400000000000000000000001351514545521100275150ustar00rootroot00000000000000{ "defaults": 55.100250005722046, "str": 62.77754187583923, "obj": 31.361207962036133 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-mixed-1.json000066400000000000000000000001351514545521100276050ustar00rootroot00000000000000{ "defaults": 13.097042083740234, "str": 12.528666973114014, "obj": 7.946000099182129 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-mixed-20.json000066400000000000000000000001351514545521100276660ustar00rootroot00000000000000{ "defaults": 113.75462508201599, "str": 122.74500012397766, "obj": 89.51083302497864 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-slow-1.json000066400000000000000000000001351514545521100274630ustar00rootroot00000000000000{ "defaults": 13.048874855041504, "str": 12.627707958221436, "obj": 7.943833112716675 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-fast-slow-20.json000066400000000000000000000001351514545521100275440ustar00rootroot00000000000000{ "defaults": 112.71425008773804, "str": 119.46612501144409, "obj": 88.86787509918213 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-slow-fast-1.json000066400000000000000000000001341514545521100274620ustar00rootroot00000000000000{ "defaults": 13.905959129333496, "str": 15.27899980545044, "obj": 8.198750019073486 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-slow-fast-20.json000066400000000000000000000001341514545521100275430ustar00rootroot00000000000000{ "defaults": 59.27174997329712, "str": 62.621875047683716, "obj": 37.86075019836426 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-slow-slow-1.json000066400000000000000000000001341514545521100275110ustar00rootroot00000000000000{ "defaults": 19.91116714477539, "str": 19.340209007263184, "obj": 17.08750009536743 }isaacs-minipass-90fd647/bench/results/extend-minipass-current-slow-slow-20.json000066400000000000000000000001351514545521100275730ustar00rootroot00000000000000{ "defaults": 115.68562483787537, "str": 123.51199984550476, "obj": 95.79333400726318 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-fast-1.json000066400000000000000000000001341514545521100257530ustar00rootroot00000000000000{ "defaults": 12.583540916442871, "str": 12.105957984924316, "obj": 9.06024980545044 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-fast-20.json000066400000000000000000000001361514545521100260360ustar00rootroot00000000000000{ "defaults": 126.18258285522461, "str": 128.73254108428955, "obj": 105.26249980926514 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-mixed-1.json000066400000000000000000000001341514545521100261240ustar00rootroot00000000000000{ "defaults": 21.804834365844727, "str": 20.67766571044922, "obj": 18.17937469482422 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-mixed-20.json000066400000000000000000000001341514545521100262050ustar00rootroot00000000000000{ "defaults": 284.1690001487732, "str": 296.5096673965454, "obj": 267.44170808792114 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-slow-1.json000066400000000000000000000001341514545521100260020ustar00rootroot00000000000000{ "defaults": 20.50854206085205, "str": 20.54229211807251, "obj": 17.428500175476074 }isaacs-minipass-90fd647/bench/results/extend-minipass-fast-slow-20.json000066400000000000000000000001341514545521100260630ustar00rootroot00000000000000{ "defaults": 276.1806254386902, "str": 293.58387517929077, "obj": 276.8616247177124 }isaacs-minipass-90fd647/bench/results/extend-minipass-slow-fast-1.json000066400000000000000000000001351514545521100260030ustar00rootroot00000000000000{ "defaults": 16.363709449768066, "str": 15.237417221069336, "obj": 12.49150037765503 }isaacs-minipass-90fd647/bench/results/extend-minipass-slow-fast-20.json000066400000000000000000000001361514545521100260650ustar00rootroot00000000000000{ "defaults": 125.16524982452393, "str": 128.87895822525024, "obj": 110.46454191207886 }isaacs-minipass-90fd647/bench/results/extend-minipass-slow-slow-1.json000066400000000000000000000001351514545521100260320ustar00rootroot00000000000000{ "defaults": 27.080874919891357, "str": 26.84391689300537, "obj": 26.955999851226807 }isaacs-minipass-90fd647/bench/results/extend-minipass-slow-slow-20.json000066400000000000000000000001331514545521100261110ustar00rootroot00000000000000{ "defaults": 274.1978340148926, "str": 294.1859998703003, "obj": 277.8759160041809 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-fast-1.json000066400000000000000000000001351514545521100256730ustar00rootroot00000000000000{ "defaults": 24.68295907974243, "str": 1409.8773746490479, "obj": 21.667250156402588 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-fast-20.json000066400000000000000000000001341514545521100257530ustar00rootroot00000000000000{ "defaults": 289.5474581718445, "str": 1649.342541694641, "obj": 235.78379201889038 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-mixed-1.json000066400000000000000000000001361514545521100260450ustar00rootroot00000000000000{ "defaults": 26.036499977111816, "str": 1378.7794170379639, "obj": 16.916458129882812 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-mixed-20.json000066400000000000000000000001331514545521100261230ustar00rootroot00000000000000{ "defaults": 242.00229215621948, "str": 1575.54691696167, "obj": 149.2092089653015 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-slow-1.json000066400000000000000000000001361514545521100257230ustar00rootroot00000000000000{ "defaults": 24.177124977111816, "str": 1384.6977500915527, "obj": 16.081832885742188 }isaacs-minipass-90fd647/bench/results/extend-through2-fast-slow-20.json000066400000000000000000000001361514545521100260040ustar00rootroot00000000000000{ "defaults": 239.68829202651978, "str": 1595.5013337135315, "obj": 154.00483322143555 }isaacs-minipass-90fd647/bench/results/extend-through2-slow-fast-1.json000066400000000000000000000001351514545521100257220ustar00rootroot00000000000000{ "defaults": 30.115875244140625, "str": 1383.3513751029968, "obj": 32.43433332443237 }isaacs-minipass-90fd647/bench/results/extend-through2-slow-fast-20.json000066400000000000000000000001331514545521100260010ustar00rootroot00000000000000{ "defaults": 312.4208331108093, "str": 1739.513334274292, "obj": 239.5954999923706 }isaacs-minipass-90fd647/bench/results/extend-through2-slow-slow-1.json000066400000000000000000000001341514545521100257500ustar00rootroot00000000000000{ "defaults": 35.7008752822876, "str": 1406.1673340797424, "obj": 37.660542011260986 }isaacs-minipass-90fd647/bench/results/extend-through2-slow-slow-20.json000066400000000000000000000001361514545521100260330ustar00rootroot00000000000000{ "defaults": 298.22725009918213, "str": 1673.6373329162598, "obj": 248.40116691589355 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-fast-1.json000066400000000000000000000001351514545521100272620ustar00rootroot00000000000000{ "defaults": 16.789916038513184, "str": 13.664083003997803, "obj": 8.046792030334473 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-fast-20.json000066400000000000000000000001341514545521100273420ustar00rootroot00000000000000{ "defaults": 164.3801248073578, "str": 156.7847089767456, "obj": 125.96362495422363 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-mixed-1.json000066400000000000000000000001361514545521100274340ustar00rootroot00000000000000{ "defaults": 22.599792003631592, "str": 24.439208030700684, "obj": 13.420375108718872 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-mixed-20.json000066400000000000000000000001361514545521100275150ustar00rootroot00000000000000{ "defaults": 167.20274996757507, "str": 161.45175004005432, "obj": 134.34225010871887 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-slow-1.json000066400000000000000000000001361514545521100273120ustar00rootroot00000000000000{ "defaults": 23.611124992370605, "str": 24.252208948135376, "obj": 13.320249795913696 }isaacs-minipass-90fd647/bench/results/minipass-current-async-fast-slow-20.json000066400000000000000000000001351514545521100273720ustar00rootroot00000000000000{ "defaults": 167.81833291053772, "str": 162.2190420627594, "obj": 133.96308302879333 }isaacs-minipass-90fd647/bench/results/minipass-current-async-slow-fast-1.json000066400000000000000000000001351514545521100273110ustar00rootroot00000000000000{ "defaults": 15.29449987411499, "str": 14.680792093276978, "obj": 12.648375034332275 }isaacs-minipass-90fd647/bench/results/minipass-current-async-slow-fast-20.json000066400000000000000000000001331514545521100273700ustar00rootroot00000000000000{ "defaults": 85.04554104804993, "str": 87.39795804023743, "obj": 59.65033411979675 }isaacs-minipass-90fd647/bench/results/minipass-current-async-slow-slow-1.json000066400000000000000000000001341514545521100273370ustar00rootroot00000000000000{ "defaults": 21.52458381652832, "str": 18.75612497329712, "obj": 14.529249906539917 }isaacs-minipass-90fd647/bench/results/minipass-current-async-slow-slow-20.json000066400000000000000000000001351514545521100274210ustar00rootroot00000000000000{ "defaults": 176.85458302497864, "str": 166.02983283996582, "obj": 127.8735420703888 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-fast-1.json000066400000000000000000000001331514545521100261450ustar00rootroot00000000000000{ "defaults": 9.237291097640991, "str": 8.494791984558105, "obj": 5.270291805267334 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-fast-20.json000066400000000000000000000001341514545521100262270ustar00rootroot00000000000000{ "defaults": 55.45591592788696, "str": 60.21724987030029, "obj": 30.116125106811523 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-mixed-1.json000066400000000000000000000001351514545521100263200ustar00rootroot00000000000000{ "defaults": 13.639082908630371, "str": 12.444166898727417, "obj": 7.978666067123413 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-mixed-100.json000066400000000000000000000000361514545521100264600ustar00rootroot00000000000000{ "obj": 676.8444590568542 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-mixed-20.json000066400000000000000000000001341514545521100264000ustar00rootroot00000000000000{ "defaults": 112.22262501716614, "str": 118.59824991226196, "obj": 89.4826250076294 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-slow-1.json000066400000000000000000000001351514545521100261760ustar00rootroot00000000000000{ "defaults": 12.837042093276978, "str": 12.397625207901001, "obj": 8.142207860946655 }isaacs-minipass-90fd647/bench/results/minipass-current-fast-slow-20.json000066400000000000000000000001331514545521100262550ustar00rootroot00000000000000{ "defaults": 112.8249580860138, "str": 119.85637497901917, "obj": 93.4788339138031 }isaacs-minipass-90fd647/bench/results/minipass-current-slow-fast-1.json000066400000000000000000000001351514545521100261760ustar00rootroot00000000000000{ "defaults": 13.317584037780762, "str": 13.745499849319458, "obj": 7.646499872207642 }isaacs-minipass-90fd647/bench/results/minipass-current-slow-fast-20.json000066400000000000000000000001351514545521100262570ustar00rootroot00000000000000{ "defaults": 58.255666971206665, "str": 62.18691611289978, "obj": 38.114166021347046 }isaacs-minipass-90fd647/bench/results/minipass-current-slow-slow-1.json000066400000000000000000000001341514545521100262240ustar00rootroot00000000000000{ "defaults": 19.602458000183105, "str": 19.340165853500366, "obj": 17.1333749294281 }isaacs-minipass-90fd647/bench/results/minipass-current-slow-slow-20.json000066400000000000000000000001341514545521100263050ustar00rootroot00000000000000{ "defaults": 114.9782497882843, "str": 122.02308297157288, "obj": 95.23783302307129 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-fast-1.json000066400000000000000000000001321514545521100257560ustar00rootroot00000000000000{ "defaults": 9.106709003448486, "str": 8.27245807647705, "obj": 5.223582983016968 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-fast-20.json000066400000000000000000000001341514545521100260410ustar00rootroot00000000000000{ "defaults": 55.94037485122681, "str": 57.88187503814697, "obj": 29.797584056854248 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-mixed-1.json000066400000000000000000000001351514545521100261320ustar00rootroot00000000000000{ "defaults": 13.074541091918945, "str": 12.364291906356812, "obj": 7.872082948684692 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-mixed-20.json000066400000000000000000000001341514545521100262120ustar00rootroot00000000000000{ "defaults": 109.3677499294281, "str": 120.48091697692871, "obj": 88.43137502670288 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-slow-1.json000066400000000000000000000001361514545521100260110ustar00rootroot00000000000000{ "defaults": 12.913458108901978, "str": 12.469624996185303, "obj": 7.9867918491363525 }isaacs-minipass-90fd647/bench/results/minipass-latest-fast-slow-20.json000066400000000000000000000001351514545521100260710ustar00rootroot00000000000000{ "defaults": 109.13374996185303, "str": 119.18562507629395, "obj": 88.77216601371765 }isaacs-minipass-90fd647/bench/results/minipass-latest-slow-fast-1.json000066400000000000000000000001361514545521100260110ustar00rootroot00000000000000{ "defaults": 13.740790843963623, "str": 13.026999950408936, "obj": 11.303791046142578 }isaacs-minipass-90fd647/bench/results/minipass-latest-slow-fast-20.json000066400000000000000000000001351514545521100260710ustar00rootroot00000000000000{ "defaults": 58.92799997329712, "str": 61.270041942596436, "obj": 36.384124994277954 }isaacs-minipass-90fd647/bench/results/minipass-latest-slow-slow-1.json000066400000000000000000000001341514545521100260360ustar00rootroot00000000000000{ "defaults": 19.82358407974243, "str": 19.03404211997986, "obj": 16.994542121887207 }isaacs-minipass-90fd647/bench/results/minipass-latest-slow-slow-20.json000066400000000000000000000001341514545521100261170ustar00rootroot00000000000000{ "defaults": 113.54299998283386, "str": 122.18516683578491, "obj": 94.0842502117157 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-fast-1.json000066400000000000000000000001321514545521100250120ustar00rootroot00000000000000{ "defaults": 8.96229100227356, "str": 8.173666954040527, "obj": 5.094624996185303 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-fast-20.json000066400000000000000000000001341514545521100250750ustar00rootroot00000000000000{ "defaults": 56.02125000953674, "str": 59.039124965667725, "obj": 29.18766713142395 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-mixed-1.json000066400000000000000000000001351514545521100251660ustar00rootroot00000000000000{ "defaults": 14.748833894729614, "str": 14.528291940689087, "obj": 8.816375017166138 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-mixed-20.json000066400000000000000000000001341514545521100252460ustar00rootroot00000000000000{ "defaults": 112.7664577960968, "str": 124.79616594314575, "obj": 94.15024995803833 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-slow-1.json000066400000000000000000000001351514545521100250440ustar00rootroot00000000000000{ "defaults": 12.820749998092651, "str": 12.260708093643188, "obj": 7.883208990097046 }isaacs-minipass-90fd647/bench/results/minipass-v3-fast-slow-20.json000066400000000000000000000001351514545521100251250ustar00rootroot00000000000000{ "defaults": 112.68245792388916, "str": 124.49425005912781, "obj": 93.80837512016296 }isaacs-minipass-90fd647/bench/results/minipass-v3-slow-fast-1.json000066400000000000000000000001351514545521100250440ustar00rootroot00000000000000{ "defaults": 13.644958019256592, "str": 13.941625118255615, "obj": 9.986666917800903 }isaacs-minipass-90fd647/bench/results/minipass-v3-slow-fast-20.json000066400000000000000000000001341514545521100251240ustar00rootroot00000000000000{ "defaults": 58.234708070755005, "str": 60.60979080200195, "obj": 36.09575009346008 }isaacs-minipass-90fd647/bench/results/minipass-v3-slow-slow-1.json000066400000000000000000000001351514545521100250730ustar00rootroot00000000000000{ "defaults": 19.341042041778564, "str": 19.677291870117188, "obj": 16.29824995994568 }isaacs-minipass-90fd647/bench/results/minipass-v3-slow-slow-20.json000066400000000000000000000001351514545521100251540ustar00rootroot00000000000000{ "defaults": 108.75849986076355, "str": 119.96637487411499, "obj": 92.20295882225037 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-fast-1.json000066400000000000000000000001341514545521100250150ustar00rootroot00000000000000{ "defaults": 9.067874908447266, "str": 8.513124942779541, "obj": 5.3687920570373535 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-fast-20.json000066400000000000000000000001351514545521100250770ustar00rootroot00000000000000{ "defaults": 55.740999937057495, "str": 57.79591608047485, "obj": 28.896167039871216 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-mixed-1.json000066400000000000000000000001351514545521100251670ustar00rootroot00000000000000{ "defaults": 13.131667137145996, "str": 12.219375133514404, "obj": 7.822416067123413 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-mixed-20.json000066400000000000000000000001351514545521100252500ustar00rootroot00000000000000{ "defaults": 110.00562500953674, "str": 119.71024990081787, "obj": 89.30245780944824 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-slow-1.json000066400000000000000000000001341514545521100250440ustar00rootroot00000000000000{ "defaults": 12.763917207717896, "str": 12.276791095733643, "obj": 7.75220799446106 }isaacs-minipass-90fd647/bench/results/minipass-v4-fast-slow-20.json000066400000000000000000000001351514545521100251260ustar00rootroot00000000000000{ "defaults": 109.29241704940796, "str": 120.14249992370605, "obj": 88.43941688537598 }isaacs-minipass-90fd647/bench/results/minipass-v4-slow-fast-1.json000066400000000000000000000001341514545521100250440ustar00rootroot00000000000000{ "defaults": 12.893832921981812, "str": 13.651708126068115, "obj": 9.69395899772644 }isaacs-minipass-90fd647/bench/results/minipass-v4-slow-fast-20.json000066400000000000000000000001331514545521100251240ustar00rootroot00000000000000{ "defaults": 58.75887489318848, "str": 61.16729211807251, "obj": 36.75349998474121 }isaacs-minipass-90fd647/bench/results/minipass-v4-slow-slow-1.json000066400000000000000000000001361514545521100250750ustar00rootroot00000000000000{ "defaults": 19.634707927703857, "str": 19.170832872390747, "obj": 16.464499950408936 }isaacs-minipass-90fd647/bench/results/minipass-v4-slow-slow-20.json000066400000000000000000000001351514545521100251550ustar00rootroot00000000000000{ "defaults": 114.11229205131531, "str": 123.68508315086365, "obj": 95.43070816993713 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-fast-1.json000066400000000000000000000001331514545521100250150ustar00rootroot00000000000000{ "defaults": 9.045500040054321, "str": 8.363375186920166, "obj": 5.296582937240601 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-fast-20.json000066400000000000000000000001321514545521100250750ustar00rootroot00000000000000{ "defaults": 55.41020894050598, "str": 57.3116250038147, "obj": 29.30795907974243 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-mixed-1.json000066400000000000000000000001351514545521100251700ustar00rootroot00000000000000{ "defaults": 13.159540891647339, "str": 12.466333150863647, "obj": 7.881624937057495 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-mixed-20.json000066400000000000000000000001351514545521100252510ustar00rootroot00000000000000{ "defaults": 110.05741691589355, "str": 119.14762496948242, "obj": 88.40920901298523 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-slow-1.json000066400000000000000000000001341514545521100250450ustar00rootroot00000000000000{ "defaults": 12.69533395767212, "str": 12.118332862854004, "obj": 7.893208026885986 }isaacs-minipass-90fd647/bench/results/minipass-v5-fast-slow-20.json000066400000000000000000000001351514545521100251270ustar00rootroot00000000000000{ "defaults": 109.11375021934509, "str": 119.16074991226196, "obj": 87.87933301925659 }isaacs-minipass-90fd647/bench/results/minipass-v5-slow-fast-1.json000066400000000000000000000001351514545521100250460ustar00rootroot00000000000000{ "defaults": 12.915709018707275, "str": 14.087542057037354, "obj": 9.628709077835083 }isaacs-minipass-90fd647/bench/results/minipass-v5-slow-fast-20.json000066400000000000000000000001331514545521100251250ustar00rootroot00000000000000{ "defaults": 58.45437502861023, "str": 60.98283386230469, "obj": 36.37870812416077 }isaacs-minipass-90fd647/bench/results/minipass-v5-slow-slow-1.json000066400000000000000000000001331514545521100250730ustar00rootroot00000000000000{ "defaults": 19.6010000705719, "str": 19.504374980926514, "obj": 16.68008303642273 }isaacs-minipass-90fd647/bench/results/minipass-v5-slow-slow-20.json000066400000000000000000000001351514545521100251560ustar00rootroot00000000000000{ "defaults": 113.02391600608826, "str": 122.68854212760925, "obj": 93.84029197692871 }isaacs-minipass-90fd647/bench/results/push-through-fast-fast-1.json000066400000000000000000000001341514545521100253000ustar00rootroot00000000000000{ "defaults": 4.571958065032959, "str": 4.329500198364258, "obj": 0.9436254501342773 }isaacs-minipass-90fd647/bench/results/push-through-fast-fast-20.json000066400000000000000000000000561514545521100253640ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-90fd647/bench/results/push-through-fast-mixed-1.json000066400000000000000000000001321514545521100254470ustar00rootroot00000000000000{ "defaults": 8.806500434875488, "str": 7.162916660308838, "obj": 3.48104190826416 }isaacs-minipass-90fd647/bench/results/push-through-fast-mixed-20.json000066400000000000000000000000561514545521100255350ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-90fd647/bench/results/push-through-fast-slow-1.json000066400000000000000000000001341514545521100253270ustar00rootroot00000000000000{ "defaults": 8.510458946228027, "str": 6.624207973480225, "obj": 3.3635826110839844 }isaacs-minipass-90fd647/bench/results/push-through-fast-slow-20.json000066400000000000000000000000561514545521100254130ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-90fd647/bench/results/push-through-slow-fast-1.json000066400000000000000000000001331514545521100253260ustar00rootroot00000000000000{ "defaults": 8.911791801452637, "str": 9.212250232696533, "obj": 6.082250118255615 }isaacs-minipass-90fd647/bench/results/push-through-slow-fast-20.json000066400000000000000000000000561514545521100254130ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-90fd647/bench/results/push-through-slow-slow-1.json000066400000000000000000000001341514545521100253560ustar00rootroot00000000000000{ "defaults": 16.439791202545166, "str": 14.342957973480225, "obj": 11.8979172706604 }isaacs-minipass-90fd647/bench/results/push-through-slow-slow-20.json000066400000000000000000000000561514545521100254420ustar00rootroot00000000000000{ "defaults": {}, "str": {}, "obj": {} }isaacs-minipass-90fd647/bench/results/through2-fast-fast-1.json000066400000000000000000000001361514545521100244070ustar00rootroot00000000000000{ "defaults": 23.358792304992676, "str": 1519.4609580039978, "obj": 18.863791942596436 }isaacs-minipass-90fd647/bench/results/through2-fast-fast-20.json000066400000000000000000000001341514545521100244660ustar00rootroot00000000000000{ "defaults": 269.9025411605835, "str": 30722.50658416748, "obj": 237.11420822143555 }isaacs-minipass-90fd647/bench/results/through2-fast-mixed-1.json000066400000000000000000000001361514545521100245600ustar00rootroot00000000000000{ "defaults": 25.791290760040283, "str": 1463.4079580307007, "obj": 16.932791233062744 }isaacs-minipass-90fd647/bench/results/through2-fast-mixed-20.json000066400000000000000000000001361514545521100246410ustar00rootroot00000000000000{ "defaults": 237.30966711044312, "str": 36814.678584098816, "obj": 142.29699993133545 }isaacs-minipass-90fd647/bench/results/through2-fast-slow-1.json000066400000000000000000000001351514545521100244350ustar00rootroot00000000000000{ "defaults": 23.46716594696045, "str": 1448.8229160308838, "obj": 14.695291996002197 }isaacs-minipass-90fd647/bench/results/through2-fast-slow-20.json000066400000000000000000000001351514545521100245160ustar00rootroot00000000000000{ "defaults": 235.12229204177856, "str": 36618.73558282852, "obj": 148.23050022125244 }isaacs-minipass-90fd647/bench/results/through2-slow-fast-1.json000066400000000000000000000001341514545521100244340ustar00rootroot00000000000000{ "defaults": 30.843832969665527, "str": 1474.772541999817, "obj": 30.43804121017456 }isaacs-minipass-90fd647/bench/results/through2-slow-fast-20.json000066400000000000000000000001351514545521100245160ustar00rootroot00000000000000{ "defaults": 284.6131248474121, "str": 29469.896290779114, "obj": 238.76466703414917 }isaacs-minipass-90fd647/bench/results/through2-slow-slow-1.json000066400000000000000000000001341514545521100244630ustar00rootroot00000000000000{ "defaults": 34.66804075241089, "str": 1452.2015419006348, "obj": 37.72975015640259 }isaacs-minipass-90fd647/bench/results/through2-slow-slow-20.json000066400000000000000000000001361514545521100245460ustar00rootroot00000000000000{ "defaults": 294.61695766448975, "str": 29603.270833015442, "obj": 264.94858407974243 }isaacs-minipass-90fd647/bench/t.js000066400000000000000000000103061514545521100170260ustar00rootroot00000000000000'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-90fd647/package-lock.json000066400000000000000000005004171514545521100203710ustar00rootroot00000000000000{ "name": "minipass", "version": "7.1.3", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "minipass", "version": "7.1.3", "license": "BlueOak-1.0.0", "devDependencies": { "@types/end-of-stream": "^1.4.2", "@types/node": "^25.2.3", "end-of-stream": "^1.4.0", "node-abort-controller": "^3.1.1", "prettier": "^3.8.1", "tap": "^21.6.1", "through2": "^2.0.3", "tshy": "^3.3.2", "typedoc": "^0.28.17" }, "engines": { "node": ">=16 || 14 >=14.17" } }, "node_modules/@alcalzone/ansi-tokenize": { "version": "0.1.3", "resolved": "https://registry.npmjs.org/@alcalzone/ansi-tokenize/-/ansi-tokenize-0.1.3.tgz", "integrity": "sha512-3yWxPTq3UQ/FY9p1ErPxIyfT64elWaMvM9lIHnaqpyft63tkxodF5aUElYHrdisWve5cETkh1+KBw1yJuW0aRw==", "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^4.0.0" }, "engines": { "node": ">=14.13.1" } }, "node_modules/@base2/pretty-print-object": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/@base2/pretty-print-object/-/pretty-print-object-1.0.1.tgz", "integrity": "sha512-4iri8i1AqYHJE2DstZYkyEprg6Pq6sKx3xn5FpySk9sNhH7qN2LLlHJCfDTZRILNwQNPD7mATWM0TBui7uC1pA==", "dev": true, "license": "BSD-2-Clause" }, "node_modules/@bcoe/v8-coverage": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", "dev": true, "license": "MIT", "engines": { "node": ">=18" } }, "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, "license": "MIT", "dependencies": { "@jridgewell/trace-mapping": "0.3.9" }, "engines": { "node": ">=12" } }, "node_modules/@gerrit0/mini-shiki": { "version": "3.22.0", "resolved": "https://registry.npmjs.org/@gerrit0/mini-shiki/-/mini-shiki-3.22.0.tgz", "integrity": "sha512-jMpciqEVUBKE1QwU64S4saNMzpsSza6diNCk4MWAeCxO2+LFi2FIFmL2S0VDLzEJCxuvCbU783xi8Hp/gkM5CQ==", "dev": true, "license": "MIT", "dependencies": { "@shikijs/engine-oniguruma": "^3.22.0", "@shikijs/langs": "^3.22.0", "@shikijs/themes": "^3.22.0", "@shikijs/types": "^3.22.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "node_modules/@isaacs/cliui": { "version": "9.0.0", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-9.0.0.tgz", "integrity": "sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": ">=18" } }, "node_modules/@isaacs/fs-minipass": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz", "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^7.0.4" }, "engines": { "node": ">=18.0.0" } }, "node_modules/@isaacs/ts-node-temp-fork-for-pr-2009": { "version": "10.9.7", "resolved": "https://registry.npmjs.org/@isaacs/ts-node-temp-fork-for-pr-2009/-/ts-node-temp-fork-for-pr-2009-10.9.7.tgz", "integrity": "sha512-9f0bhUr9TnwwpgUhEpr3FjxSaH/OHaARkE2F9fM0lS4nIs2GNerrvGwQz493dk0JKlTaGYVrKbq36vA/whZ34g==", "dev": true, "license": "MIT", "dependencies": { "@cspotcode/source-map-support": "^0.8.0", "@tsconfig/node14": "*", "@tsconfig/node16": "*", "@tsconfig/node18": "*", "@tsconfig/node20": "*", "acorn": "^8.4.1", "acorn-walk": "^8.1.1", "arg": "^4.1.0", "diff": "^4.0.1", "make-error": "^1.1.1", "v8-compile-cache-lib": "^3.0.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" }, "peerDependencies": { "@swc/core": ">=1.2.50", "@swc/wasm": ">=1.2.50", "@types/node": "*", "typescript": ">=4.2" }, "peerDependenciesMeta": { "@swc/core": { "optional": true }, "@swc/wasm": { "optional": true } } }, "node_modules/@isaacs/ts-node-temp-fork-for-pr-2009/node_modules/diff": { "version": "4.0.4", "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.4.tgz", "integrity": "sha512-X07nttJQkwkfKfvTPG/KSnE2OMdcUCao6+eXF3wmnIQRn2aPAHH3VxDbDOdegkd6JbPsXqShpvEOHfAT+nCNwQ==", "dev": true, "license": "BSD-3-Clause", "engines": { "node": ">=0.3.1" } }, "node_modules/@isaacs/which": { "version": "7.0.4", "resolved": "https://registry.npmjs.org/@isaacs/which/-/which-7.0.4.tgz", "integrity": "sha512-qXToWZFY9CKvWsveV3R5VHNJLQkHTIJXO9J4Xa1UgNwVCRA2LEsmvWC84MIdnezFLsjn2Q+GzbL/8yVF1/ozJw==", "dev": true, "license": "ISC", "dependencies": { "isexe": "^4.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/@jridgewell/resolve-uri": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "dev": true, "license": "MIT", "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/sourcemap-codec": { "version": "1.5.5", "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", "dev": true, "license": "MIT" }, "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, "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "node_modules/@npmcli/agent": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@npmcli/agent/-/agent-4.0.0.tgz", "integrity": "sha512-kAQTcEN9E8ERLVg5AsGwLNoFb+oEG6engbqAU2P43gD4JEIkNGMHdVQ096FsOAAYpZPB0RSt0zgInKIAS1l5QA==", "dev": true, "license": "ISC", "dependencies": { "agent-base": "^7.1.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.1", "lru-cache": "^11.2.1", "socks-proxy-agent": "^8.0.3" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/fs": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-5.0.0.tgz", "integrity": "sha512-7OsC1gNORBEawOa5+j2pXN9vsicaIOH5cPXxoR6fJOmH6/EXpJB2CajXOu1fPRFun2m1lktEFX11+P89hqO/og==", "dev": true, "license": "ISC", "dependencies": { "semver": "^7.3.5" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/git": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-7.0.1.tgz", "integrity": "sha512-+XTFxK2jJF/EJJ5SoAzXk3qwIDfvFc5/g+bD274LZ7uY7LE8sTfG6Z8rOanPl2ZEvZWqNvmEdtXC25cE54VcoA==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/promise-spawn": "^9.0.0", "ini": "^6.0.0", "lru-cache": "^11.2.1", "npm-pick-manifest": "^11.0.1", "proc-log": "^6.0.0", "promise-retry": "^2.0.1", "semver": "^7.3.5", "which": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/installed-package-contents": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@npmcli/installed-package-contents/-/installed-package-contents-4.0.0.tgz", "integrity": "sha512-yNyAdkBxB72gtZ4GrwXCM0ZUedo9nIbOMKfGjt6Cu6DXf0p8y1PViZAKDC8q8kv/fufx0WTjRBdSlyrvnP7hmA==", "dev": true, "license": "ISC", "dependencies": { "npm-bundled": "^5.0.0", "npm-normalize-package-bin": "^5.0.0" }, "bin": { "installed-package-contents": "bin/index.js" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/node-gyp": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-5.0.0.tgz", "integrity": "sha512-uuG5HZFXLfyFKqg8QypsmgLQW7smiRjVc45bqD/ofZZcR/uxEjgQU8qDPv0s9TEeMUiAAU/GC5bR6++UdTirIQ==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/package-json": { "version": "7.0.4", "resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-7.0.4.tgz", "integrity": "sha512-0wInJG3j/K40OJt/33ax47WfWMzZTm6OQxB9cDhTt5huCP2a9g2GnlsxmfN+PulItNPIpPrZ+kfwwUil7eHcZQ==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/git": "^7.0.0", "glob": "^13.0.0", "hosted-git-info": "^9.0.0", "json-parse-even-better-errors": "^5.0.0", "proc-log": "^6.0.0", "semver": "^7.5.3", "validate-npm-package-license": "^3.0.4" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/promise-spawn": { "version": "9.0.1", "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-9.0.1.tgz", "integrity": "sha512-OLUaoqBuyxeTqUvjA3FZFiXUfYC1alp3Sa99gW3EUDz3tZ3CbXDdcZ7qWKBzicrJleIgucoWamWH1saAmH/l2Q==", "dev": true, "license": "ISC", "dependencies": { "which": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/redact": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@npmcli/redact/-/redact-4.0.0.tgz", "integrity": "sha512-gOBg5YHMfZy+TfHArfVogwgfBeQnKbbGo3pSUyK/gSI0AVu+pEiDVcKlQb0D8Mg1LNRZILZ6XG8I5dJ4KuAd9Q==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@npmcli/run-script": { "version": "10.0.3", "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-10.0.3.tgz", "integrity": "sha512-ER2N6itRkzWbbtVmZ9WKaWxVlKlOeBFF1/7xx+KA5J1xKa4JjUwBdb6tDpk0v1qA+d+VDwHI9qmLcXSWcmi+Rw==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/node-gyp": "^5.0.0", "@npmcli/package-json": "^7.0.0", "@npmcli/promise-spawn": "^9.0.0", "node-gyp": "^12.1.0", "proc-log": "^6.0.0", "which": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@pkgjs/parseargs": { "version": "0.11.0", "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", "dev": true, "license": "MIT", "optional": true, "engines": { "node": ">=14" } }, "node_modules/@shikijs/engine-oniguruma": { "version": "3.22.0", "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-3.22.0.tgz", "integrity": "sha512-DyXsOG0vGtNtl7ygvabHd7Mt5EY8gCNqR9Y7Lpbbd/PbJvgWrqaKzH1JW6H6qFkuUa8aCxoiYVv8/YfFljiQxA==", "dev": true, "license": "MIT", "dependencies": { "@shikijs/types": "3.22.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "node_modules/@shikijs/langs": { "version": "3.22.0", "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-3.22.0.tgz", "integrity": "sha512-x/42TfhWmp6H00T6uwVrdTJGKgNdFbrEdhaDwSR5fd5zhQ1Q46bHq9EO61SCEWJR0HY7z2HNDMaBZp8JRmKiIA==", "dev": true, "license": "MIT", "dependencies": { "@shikijs/types": "3.22.0" } }, "node_modules/@shikijs/themes": { "version": "3.22.0", "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-3.22.0.tgz", "integrity": "sha512-o+tlOKqsr6FE4+mYJG08tfCFDS+3CG20HbldXeVoyP+cYSUxDhrFf3GPjE60U55iOkkjbpY2uC3It/eeja35/g==", "dev": true, "license": "MIT", "dependencies": { "@shikijs/types": "3.22.0" } }, "node_modules/@shikijs/types": { "version": "3.22.0", "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-3.22.0.tgz", "integrity": "sha512-491iAekgKDBFE67z70Ok5a8KBMsQ2IJwOWw3us/7ffQkIBCyOQfm/aNwVMBUriP02QshIfgHCBSIYAl3u2eWjg==", "dev": true, "license": "MIT", "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "node_modules/@shikijs/vscode-textmate": { "version": "10.0.2", "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz", "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==", "dev": true, "license": "MIT" }, "node_modules/@sigstore/bundle": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-4.0.0.tgz", "integrity": "sha512-NwCl5Y0V6Di0NexvkTqdoVfmjTaQwoLM236r89KEojGmq/jMls8S+zb7yOwAPdXvbwfKDlP+lmXgAL4vKSQT+A==", "dev": true, "license": "Apache-2.0", "dependencies": { "@sigstore/protobuf-specs": "^0.5.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@sigstore/core": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/@sigstore/core/-/core-3.1.0.tgz", "integrity": "sha512-o5cw1QYhNQ9IroioJxpzexmPjfCe7gzafd2RY3qnMpxr4ZEja+Jad/U8sgFpaue6bOaF+z7RVkyKVV44FN+N8A==", "dev": true, "license": "Apache-2.0", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@sigstore/protobuf-specs": { "version": "0.5.0", "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.0.tgz", "integrity": "sha512-MM8XIwUjN2bwvCg1QvrMtbBmpcSHrkhFSCu1D11NyPvDQ25HEc4oG5/OcQfd/Tlf/OxmKWERDj0zGE23jQaMwA==", "dev": true, "license": "Apache-2.0", "engines": { "node": "^18.17.0 || >=20.5.0" } }, "node_modules/@sigstore/sign": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-4.1.0.tgz", "integrity": "sha512-Vx1RmLxLGnSUqx/o5/VsCjkuN5L7y+vxEEwawvc7u+6WtX2W4GNa7b9HEjmcRWohw/d6BpATXmvOwc78m+Swdg==", "dev": true, "license": "Apache-2.0", "dependencies": { "@sigstore/bundle": "^4.0.0", "@sigstore/core": "^3.1.0", "@sigstore/protobuf-specs": "^0.5.0", "make-fetch-happen": "^15.0.3", "proc-log": "^6.1.0", "promise-retry": "^2.0.1" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@sigstore/tuf": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/@sigstore/tuf/-/tuf-4.0.1.tgz", "integrity": "sha512-OPZBg8y5Vc9yZjmWCHrlWPMBqW5yd8+wFNl+thMdtcWz3vjVSoJQutF8YkrzI0SLGnkuFof4HSsWUhXrf219Lw==", "dev": true, "license": "Apache-2.0", "dependencies": { "@sigstore/protobuf-specs": "^0.5.0", "tuf-js": "^4.1.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@sigstore/verify": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/@sigstore/verify/-/verify-3.1.0.tgz", "integrity": "sha512-mNe0Iigql08YupSOGv197YdHpPPr+EzDZmfCgMc7RPNaZTw5aLN01nBl6CHJOh3BGtnMIj83EeN4butBchc8Ag==", "dev": true, "license": "Apache-2.0", "dependencies": { "@sigstore/bundle": "^4.0.0", "@sigstore/core": "^3.1.0", "@sigstore/protobuf-specs": "^0.5.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@tapjs/after": { "version": "3.3.3", "resolved": "https://registry.npmjs.org/@tapjs/after/-/after-3.3.3.tgz", "integrity": "sha512-kGG4zOM1LXfWr1+MvBfzLHUm/azBC1YGQxS7eFNPe67cQjJFG/GcwnRXTqZWEhRv/g0M9IERE8YIEuta9owFpw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "is-actual-promise": "^1.0.1" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/after-each": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/after-each/-/after-each-4.3.3.tgz", "integrity": "sha512-68IPZPVjgMId5LU3Uuo0Kr1MGRPTYffx4gSWkwEIiNc20+j0z5BkPeyq08xm8vQykO/hDxZqX2FoOdGCWtbb0g==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "function-loop": "^4.0.0" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/asserts": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/asserts/-/asserts-4.3.3.tgz", "integrity": "sha512-ZrKW94qQlUcRs+zmSuuxgoTjkSgXvq1G3Qv/4dD0gUatTckCRM+rQIBsPcgAC5jMyBAgQJ+q8U2Wo3h+r9Jrog==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/stack": "4.3.0", "is-actual-promise": "^1.0.1", "tcompare": "9.3.0", "trivial-deferred": "^2.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/before": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/before/-/before-4.3.3.tgz", "integrity": "sha512-tVFrSmlN6nCYgNkkzqLQ/DFrI9b2AsJ5Aka1wa1wQJAy+F0QOmLkAH44wnqkE2pKjEWHSkdYdFUlixyfs8lDRw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "is-actual-promise": "^1.0.1" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/before-each": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/before-each/-/before-each-4.3.3.tgz", "integrity": "sha512-wEvwHCHdCwZZCPHSMJ3kIE/bqrzdSKI/p5PswSAPm+KQmtnhyXjau1bBfz9aK9S/Pwez+NCwJKn5+POVTeUXKw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "function-loop": "^4.0.0" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/chdir": { "version": "3.3.3", "resolved": "https://registry.npmjs.org/@tapjs/chdir/-/chdir-3.3.3.tgz", "integrity": "sha512-METLxtROGpmvGjfT9XZV/qu1q8BjxSAcWsyr8wTvCfDcv0eMi1odvlPpBfUU+WhKGXzVTYCz1go0S1tLaNbQDQ==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/config": { "version": "5.5.1", "resolved": "https://registry.npmjs.org/@tapjs/config/-/config-5.5.1.tgz", "integrity": "sha512-j2pg8+MMlTLX0FKU9cHqc4HkauV0c/ClfMYqkIriOWsibhuFJ0hdoP5b+MQSHgbENctgeI7gVBIW4aaHPa9/bA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/core": "4.5.1", "@tapjs/test": "4.4.1", "chalk": "^5.6.2", "jackspeak": "^4.2.3", "polite-json": "^5.0.0", "tap-yaml": "4.3.0", "walk-up-path": "^4.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1", "@tapjs/test": "4.4.1" } }, "node_modules/@tapjs/core": { "version": "4.5.1", "resolved": "https://registry.npmjs.org/@tapjs/core/-/core-4.5.1.tgz", "integrity": "sha512-fDZ3iwmXkjv+QuMYMmKnqFhIib2hspTfmBieCbMM6YcTL3FJWGebj0+nA0X43EMOgNlLrvCY6X/KolqEeu/+TA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/processinfo": "^3.1.9", "@tapjs/stack": "4.3.0", "@tapjs/test": "4.4.1", "async-hook-domain": "^4.0.1", "diff": "^8.0.2", "is-actual-promise": "^1.0.1", "minipass": "^7.0.4", "signal-exit": "4.1", "tap-parser": "18.3.0", "tap-yaml": "4.3.0", "tcompare": "9.3.0", "trivial-deferred": "^2.0.0" }, "engines": { "node": "20 || >=22" } }, "node_modules/@tapjs/error-serdes": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/@tapjs/error-serdes/-/error-serdes-4.3.0.tgz", "integrity": "sha512-qP266uvPm2G95ClPFpqAN6n4nicLbHrZYbZWl0UO+biOdmvjSSuxeY5f7YFygTl+UuzlyxjlRgHTq8qifnqTcw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "minipass": "^7.0.4" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/@tapjs/filter": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/filter/-/filter-4.3.3.tgz", "integrity": "sha512-qohTjnMtLjU8/VIe24FjvNmZ55NRV/wK/rvI0D4tuPGlcJwe99tDs5hZ/uWGYzZ5jneqqH2s9EoH6j1bxZ74WA==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/fixture": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/fixture/-/fixture-4.3.3.tgz", "integrity": "sha512-uMySXLR1JC/lQp/nxbYTY6wn3ziuS/lkvw/7Ob7/sa47jUHDzGNQuLYN2/Q2Xw+R6xIW061LfxtHBEP6/PRdpA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "mkdirp": "^3.0.0", "rimraf": "^6.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/intercept": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/intercept/-/intercept-4.3.3.tgz", "integrity": "sha512-0uxtyL/PuvjbrnTTJnCektTrVQjdN96luR+1iuWd4uFKMMQEyJz/qCx2Pqh3yIWSLjFSNsuStPvZ2DFIVHrvSA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/after": "3.3.3", "@tapjs/stack": "4.3.0" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/mock": { "version": "4.4.1", "resolved": "https://registry.npmjs.org/@tapjs/mock/-/mock-4.4.1.tgz", "integrity": "sha512-jdn5FE/kgsTWabe8VegnAv4LMYxEKfhvK/9QCLirngjleWLFSZNVhEv0eawpNwnnjKuXbxj1t2j6Q6DblYKi4A==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/after": "3.3.3", "@tapjs/stack": "4.3.0", "resolve-import": "^2.4.0", "walk-up-path": "^4.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/node-serialize": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/node-serialize/-/node-serialize-4.3.3.tgz", "integrity": "sha512-PuXE4xiXjmUIM99z4h+QDyQI8vFZoEvxtFF1vZExE6up7Ab6T+a4g0nGjSbfMSanIgVjbQPr/S0LW4KH6zqcJw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/error-serdes": "4.3.0", "@tapjs/stack": "4.3.0", "tap-parser": "18.3.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/processinfo": { "version": "3.1.9", "resolved": "https://registry.npmjs.org/@tapjs/processinfo/-/processinfo-3.1.9.tgz", "integrity": "sha512-yIbYH9ROI5m5F2B5Hpk6t89OkHBrDbL3qncPO9OfPuSvJsvAIDG91I0hxGQNohdaxmqz5L4QiIYc5Y0KmtLzCQ==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "node-options-to-argv": "^1.0.0", "pirates": "^4.0.5", "process-on-spawn": "^1.0.0", "signal-exit": "^4.0.2", "uuid": "^8.3.2" }, "engines": { "node": ">=16.17" } }, "node_modules/@tapjs/reporter": { "version": "4.4.3", "resolved": "https://registry.npmjs.org/@tapjs/reporter/-/reporter-4.4.3.tgz", "integrity": "sha512-+4TC4w7yGLwGOKf/tDe+4C+Ancs+9bsnMxdqsGT5SPPCdxqB64EgOPUu6dGBA/miAEr6VVyCIxErriW/KFTVBA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/config": "5.5.1", "@tapjs/stack": "4.3.0", "chalk": "^5.6.2", "ink": "^5.2.1", "minipass": "^7.0.4", "ms": "^2.1.3", "patch-console": "^2.0.0", "prismjs-terminal": "^1.2.3", "react": "^18.2.0", "string-length": "^6.0.0", "tap-parser": "18.3.0", "tap-yaml": "4.3.0", "tcompare": "9.3.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/run": { "version": "4.5.1", "resolved": "https://registry.npmjs.org/@tapjs/run/-/run-4.5.1.tgz", "integrity": "sha512-quUh0PUv8gKX9bVL9hiUrI1B2dMj2sybsnRnXyfQ+tnG0zV/nK5rosXQ13J8FyTufsKh5Jwp+2FGAH7+CT3X/A==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/which": "^7.0.4", "@tapjs/after": "3.3.3", "@tapjs/before": "4.3.3", "@tapjs/config": "5.5.1", "@tapjs/processinfo": "^3.1.9", "@tapjs/reporter": "4.4.3", "@tapjs/spawn": "4.3.3", "@tapjs/stdin": "4.3.3", "@tapjs/test": "4.4.1", "c8": "^10.1.3", "chalk": "^5.6.2", "chokidar": "^4.0.2", "foreground-child": "^4.0.0", "glob": "^13.0.2", "minipass": "^7.0.4", "mkdirp": "^3.0.1", "node-options-to-argv": "^1.0.0", "opener": "^1.5.2", "pacote": "^21.0.4", "path-scurry": "^2.0.0", "resolve-import": "^2.4.0", "rimraf": "^6.0.0", "semver": "^7.7.2", "signal-exit": "^4.1.0", "tap-parser": "18.3.0", "tap-yaml": "4.3.0", "tcompare": "9.3.0", "trivial-deferred": "^2.0.0" }, "bin": { "tap-run": "dist/esm/index.js" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/snapshot": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/snapshot/-/snapshot-4.3.3.tgz", "integrity": "sha512-l8cFbXc97GvL1qjnhdvbsDQZ4ze1CT+vfr3gJdXB4ZhBAKRBmfnXrmFcuyTRANWwb27GOTOISP8fc33bNX7bSA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "is-actual-promise": "^1.0.1", "tcompare": "9.3.0", "trivial-deferred": "^2.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/spawn": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/spawn/-/spawn-4.3.3.tgz", "integrity": "sha512-YSwCN+7sooEvICF3T3eB6mJy9kEn7AFDyCVH3M6uHiKNUXKj834nrHfKMZbaRydVFTOTGYupqOdLXsr7Czcljg==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/stack": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/@tapjs/stack/-/stack-4.3.0.tgz", "integrity": "sha512-SFASe4YaVBzMr/FXTm/QsSzbzXZOmgDNpmY3EU0JNiDCN4izHMUnoXY+Kh0EY35hx9C4JDvRjgv2MSIM7bBygg==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/@tapjs/stdin": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/stdin/-/stdin-4.3.3.tgz", "integrity": "sha512-8cAD0h7llgVVeavPUCtentKSzwLeLKDYfF5v6huPEArl6yTqXuj2zTI2VWyYDOEdQl/afkjxagGsGmzWk3K38g==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/test": { "version": "4.4.1", "resolved": "https://registry.npmjs.org/@tapjs/test/-/test-4.4.1.tgz", "integrity": "sha512-yn5eFeg0zzw11Q14Fhwy0WFwEata5ez/LEC33NPOhpPxeqWzhaqjXXNKk+/qaydF8CbEclDUNIILeu605pjI3A==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/ts-node-temp-fork-for-pr-2009": "^10.9.7", "@tapjs/after": "3.3.3", "@tapjs/after-each": "4.3.3", "@tapjs/asserts": "4.3.3", "@tapjs/before": "4.3.3", "@tapjs/before-each": "4.3.3", "@tapjs/chdir": "3.3.3", "@tapjs/filter": "4.3.3", "@tapjs/fixture": "4.3.3", "@tapjs/intercept": "4.3.3", "@tapjs/mock": "4.4.1", "@tapjs/node-serialize": "4.3.3", "@tapjs/snapshot": "4.3.3", "@tapjs/spawn": "4.3.3", "@tapjs/stdin": "4.3.3", "@tapjs/typescript": "3.5.3", "@tapjs/worker": "4.3.3", "glob": "^13.0.2", "jackspeak": "^4.2.3", "mkdirp": "^3.0.0", "package-json-from-dist": "^1.0.0", "resolve-import": "^2.4.0", "rimraf": "^6.0.0", "sync-content": "^2.0.4", "tap-parser": "18.3.0", "tshy": "^3.3.2", "typescript": "5.9", "walk-up-path": "^4.0.0" }, "bin": { "generate-tap-test-class": "dist/esm/build.mjs" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/typescript": { "version": "3.5.3", "resolved": "https://registry.npmjs.org/@tapjs/typescript/-/typescript-3.5.3.tgz", "integrity": "sha512-YrDlDxESUMioAlx5ddfrnnTKCXAe+prX+iKF/sVaSDSzkxQh9eKB1zvFaP3W/CTb+gTR8vp2UeYF3JtApBae8A==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/ts-node-temp-fork-for-pr-2009": "^10.9.7" }, "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tapjs/worker": { "version": "4.3.3", "resolved": "https://registry.npmjs.org/@tapjs/worker/-/worker-4.3.3.tgz", "integrity": "sha512-bQvpqdSJlklfYqxANLvdwU9M2rLu5eSv4x65pSZxWIW3K/oz/8SN+/JG0i8qixioQWZz/QVV82EpfZIgDE1J3g==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" }, "peerDependencies": { "@tapjs/core": "4.5.1" } }, "node_modules/@tsconfig/node14": { "version": "14.1.8", "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-14.1.8.tgz", "integrity": "sha512-SjGT+qPvh8Uhc849yNMD0ZIPr69AyB7Z46nMqhrI3gCVocd6mhI0jP4YE4onO/ufpmengRfTxNMpdpKEp2xRIg==", "dev": true, "license": "MIT" }, "node_modules/@tsconfig/node16": { "version": "16.1.8", "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-16.1.8.tgz", "integrity": "sha512-T/CfdwFry660WjZor56z0F3pxeCllt8KOxWcHFW6ZEuULKUObTDEMdgtctyuJPxwqyWDsvHRfxHaJ4FIICyoqQ==", "dev": true, "license": "MIT" }, "node_modules/@tsconfig/node18": { "version": "18.2.6", "resolved": "https://registry.npmjs.org/@tsconfig/node18/-/node18-18.2.6.tgz", "integrity": "sha512-eAWQzAjPj18tKnDzmWstz4OyWewLUNBm9tdoN9LayzoboRktYx3Enk1ZXPmThj55L7c4VWYq/Bzq0A51znZfhw==", "dev": true, "license": "MIT" }, "node_modules/@tsconfig/node20": { "version": "20.1.9", "resolved": "https://registry.npmjs.org/@tsconfig/node20/-/node20-20.1.9.tgz", "integrity": "sha512-IjlTv1RsvnPtUcjTqtVsZExKVq+KQx4g5pCP5tI7rAs6Xesl2qFwSz/tPDBC4JajkL/MlezBu3gPUwqRHl+RIg==", "dev": true, "license": "MIT" }, "node_modules/@tufjs/canonical-json": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/@tufjs/canonical-json/-/canonical-json-2.0.0.tgz", "integrity": "sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==", "dev": true, "license": "MIT", "engines": { "node": "^16.14.0 || >=18.0.0" } }, "node_modules/@tufjs/models": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/@tufjs/models/-/models-4.1.0.tgz", "integrity": "sha512-Y8cK9aggNRsqJVaKUlEYs4s7CvQ1b1ta2DVPyAimb0I2qhzjNk+A+mxvll/klL0RlfuIUei8BF7YWiua4kQqww==", "dev": true, "license": "MIT", "dependencies": { "@tufjs/canonical-json": "2.0.0", "minimatch": "^10.1.1" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/@types/end-of-stream": { "version": "1.4.4", "resolved": "https://registry.npmjs.org/@types/end-of-stream/-/end-of-stream-1.4.4.tgz", "integrity": "sha512-StWAwZWMI5cK5wBKJHK/0MBJaZKMlN78EeDhBhBz6eEK51StnQzwERHG438/ToRJ/2CGaBW8TpyYxjkB1v9whA==", "dev": true, "license": "MIT", "dependencies": { "@types/node": "*" } }, "node_modules/@types/hast": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", "dev": true, "license": "MIT", "dependencies": { "@types/unist": "*" } }, "node_modules/@types/istanbul-lib-coverage": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==", "dev": true, "license": "MIT" }, "node_modules/@types/node": { "version": "25.2.3", "resolved": "https://registry.npmjs.org/@types/node/-/node-25.2.3.tgz", "integrity": "sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==", "dev": true, "license": "MIT", "dependencies": { "undici-types": "~7.16.0" } }, "node_modules/@types/unist": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", "dev": true, "license": "MIT" }, "node_modules/@typescript/native-preview": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview/-/native-preview-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-hbGRXBk7abFvOQJk/7mc8K9q1kPkiyziyUsS8r8Hc1sLxrDFUbGgsW9p8qg67Xe1K6NUv/9UU2cdeIitUDexIQ==", "dev": true, "license": "Apache-2.0", "bin": { "tsgo": "bin/tsgo.js" }, "optionalDependencies": { "@typescript/native-preview-darwin-arm64": "7.0.0-dev.20260218.1", "@typescript/native-preview-darwin-x64": "7.0.0-dev.20260218.1", "@typescript/native-preview-linux-arm": "7.0.0-dev.20260218.1", "@typescript/native-preview-linux-arm64": "7.0.0-dev.20260218.1", "@typescript/native-preview-linux-x64": "7.0.0-dev.20260218.1", "@typescript/native-preview-win32-arm64": "7.0.0-dev.20260218.1", "@typescript/native-preview-win32-x64": "7.0.0-dev.20260218.1" } }, "node_modules/@typescript/native-preview-darwin-arm64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-darwin-arm64/-/native-preview-darwin-arm64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-ybxez4ClJU12TUvX/IxGPIQfS26+Zia7kbB1L4RH+G8yzYg90RPt4njfJkU2WxP70Hp59zS2copPkaBz5gUJkQ==", "cpu": [ "arm64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "darwin" ] }, "node_modules/@typescript/native-preview-darwin-x64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-darwin-x64/-/native-preview-darwin-x64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-n9Ki8WTW82w6PlBTlrAQAjEUQB2V7C2oXrkN5U7ElwUH4FOostSFzZHuAdnPMbdzMx76P0pEw9FteYrLDA4m9g==", "cpu": [ "x64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "darwin" ] }, "node_modules/@typescript/native-preview-linux-arm": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-linux-arm/-/native-preview-linux-arm-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-WRPMvTztPatQ91UzYWSp82NT45JmjMgo/pVgZjXYEWdF2rwS4ejzR6DnHq30jXhEPnMah1bTeOzSWFF2kvXUmg==", "cpu": [ "arm" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "linux" ] }, "node_modules/@typescript/native-preview-linux-arm64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-linux-arm64/-/native-preview-linux-arm64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-Osus82LSlwi1l3LoxLWKDuxh5E8JyWwkseBjr2n+TMaTuDPcRSzT8Jr4ywIp3NJpCUUV/LzR84i64jA6g8iVIw==", "cpu": [ "arm64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "linux" ] }, "node_modules/@typescript/native-preview-linux-x64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-linux-x64/-/native-preview-linux-x64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-jcDhKCvhWQyMbra4MiqSgyUoSdM9mAiSkIdc80qScpk03aZOU+BZEmHz51S+fEn+8KRWuMuIHXM3sG3oX/EJZA==", "cpu": [ "x64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "linux" ] }, "node_modules/@typescript/native-preview-win32-arm64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-win32-arm64/-/native-preview-win32-arm64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-VmWvJ+TEuTPmZrhWe+buvvUvHbMyiD4ZLgxYPdYcJ3kRQlk2mD5lOq63ZISx1pDB8kYz5/R5xYKy/8gSIU5MgQ==", "cpu": [ "arm64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "win32" ] }, "node_modules/@typescript/native-preview-win32-x64": { "version": "7.0.0-dev.20260218.1", "resolved": "https://registry.npmjs.org/@typescript/native-preview-win32-x64/-/native-preview-win32-x64-7.0.0-dev.20260218.1.tgz", "integrity": "sha512-9zfUrKV3xBog2tpIR9NZOags+QJZSj7v9Ek7KdSkVu978IJqF9RX7oa2xftX+eiHySfV5ZQ8r2fdhdbYBk+kMw==", "cpu": [ "x64" ], "dev": true, "license": "Apache-2.0", "optional": true, "os": [ "win32" ] }, "node_modules/abbrev": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-4.0.0.tgz", "integrity": "sha512-a1wflyaL0tHtJSmLSOVybYhy22vRih4eduhhrkcjgrWGnRfrZtovJ2FRjxuTtkkj47O/baf0R86QU5OuYpz8fA==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/acorn": { "version": "8.15.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", "bin": { "acorn": "bin/acorn" }, "engines": { "node": ">=0.4.0" } }, "node_modules/acorn-walk": { "version": "8.3.4", "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz", "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==", "dev": true, "license": "MIT", "dependencies": { "acorn": "^8.11.0" }, "engines": { "node": ">=0.4.0" } }, "node_modules/agent-base": { "version": "7.1.4", "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==", "dev": true, "license": "MIT", "engines": { "node": ">= 14" } }, "node_modules/ansi-escapes": { "version": "7.3.0", "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz", "integrity": "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==", "dev": true, "license": "MIT", "dependencies": { "environment": "^1.0.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/ansi-regex": { "version": "6.2.2", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "dev": true, "license": "MIT", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/chalk/ansi-regex?sponsor=1" } }, "node_modules/ansi-styles": { "version": "6.2.3", "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", "dev": true, "license": "MIT", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/arg": { "version": "4.1.3", "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", "dev": true, "license": "MIT" }, "node_modules/argparse": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", "dev": true, "license": "Python-2.0" }, "node_modules/async-hook-domain": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/async-hook-domain/-/async-hook-domain-4.0.1.tgz", "integrity": "sha512-bSktexGodAjfHWIrSrrqxqWzf1hWBZBpmPNZv+TYUMyWa2eoefFc6q6H1+KtdHYSz35lrhWdmXt/XK9wNEZvww==", "dev": true, "license": "ISC", "engines": { "node": ">=16" } }, "node_modules/auto-bind": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/auto-bind/-/auto-bind-5.0.1.tgz", "integrity": "sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==", "dev": true, "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/balanced-match": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.3.tgz", "integrity": "sha512-1pHv8LX9CpKut1Zp4EXey7Z8OfH11ONNH6Dhi2WDUt31VVZFXZzKwXcysBgqSumFCmR+0dqjMK5v5JiFHzi0+g==", "dev": true, "license": "MIT", "engines": { "node": "20 || >=22" } }, "node_modules/brace-expansion": { "version": "5.0.2", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.2.tgz", "integrity": "sha512-Pdk8c9poy+YhOgVWw1JNN22/HcivgKWwpxKq04M/jTmHyCZn12WPJebZxdjSa5TmBqISrUSgNYU3eRORljfCCw==", "dev": true, "license": "MIT", "dependencies": { "balanced-match": "^4.0.2" }, "engines": { "node": "20 || >=22" } }, "node_modules/c8": { "version": "10.1.3", "resolved": "https://registry.npmjs.org/c8/-/c8-10.1.3.tgz", "integrity": "sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA==", "dev": true, "license": "ISC", "dependencies": { "@bcoe/v8-coverage": "^1.0.1", "@istanbuljs/schema": "^0.1.3", "find-up": "^5.0.0", "foreground-child": "^3.1.1", "istanbul-lib-coverage": "^3.2.0", "istanbul-lib-report": "^3.0.1", "istanbul-reports": "^3.1.6", "test-exclude": "^7.0.1", "v8-to-istanbul": "^9.0.0", "yargs": "^17.7.2", "yargs-parser": "^21.1.1" }, "bin": { "c8": "bin/c8.js" }, "engines": { "node": ">=18" }, "peerDependencies": { "monocart-coverage-reports": "^2" }, "peerDependenciesMeta": { "monocart-coverage-reports": { "optional": true } } }, "node_modules/c8/node_modules/foreground-child": { "version": "3.3.1", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", "dev": true, "license": "ISC", "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" }, "engines": { "node": ">=14" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/cacache": { "version": "20.0.3", "resolved": "https://registry.npmjs.org/cacache/-/cacache-20.0.3.tgz", "integrity": "sha512-3pUp4e8hv07k1QlijZu6Kn7c9+ZpWWk4j3F8N3xPuCExULobqJydKYOTj1FTq58srkJsXvO7LbGAH4C0ZU3WGw==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/fs": "^5.0.0", "fs-minipass": "^3.0.0", "glob": "^13.0.0", "lru-cache": "^11.1.0", "minipass": "^7.0.3", "minipass-collect": "^2.0.1", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "p-map": "^7.0.2", "ssri": "^13.0.0", "unique-filename": "^5.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/chalk": { "version": "5.6.2", "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", "dev": true, "license": "MIT", "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" }, "funding": { "url": "https://github.com/chalk/chalk?sponsor=1" } }, "node_modules/chokidar": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", "dev": true, "license": "MIT", "dependencies": { "readdirp": "^4.0.1" }, "engines": { "node": ">= 14.16.0" }, "funding": { "url": "https://paulmillr.com/funding/" } }, "node_modules/chownr": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz", "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": ">=18" } }, "node_modules/cli-boxes": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-3.0.0.tgz", "integrity": "sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==", "dev": true, "license": "MIT", "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/cli-cursor": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz", "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==", "dev": true, "license": "MIT", "dependencies": { "restore-cursor": "^4.0.0" }, "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/cli-truncate": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz", "integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==", "dev": true, "license": "MIT", "dependencies": { "slice-ansi": "^5.0.0", "string-width": "^7.0.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/cli-truncate/node_modules/slice-ansi": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz", "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==", "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.0.0", "is-fullwidth-code-point": "^4.0.0" }, "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/chalk/slice-ansi?sponsor=1" } }, "node_modules/cliui": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", "dev": true, "license": "ISC", "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" }, "engines": { "node": ">=12" } }, "node_modules/cliui/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/cliui/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, "license": "MIT", "dependencies": { "color-convert": "^2.0.1" }, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/cliui/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, "license": "MIT" }, "node_modules/cliui/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/cliui/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, "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/cliui/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, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/cliui/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, "license": "MIT", "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/code-excerpt": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/code-excerpt/-/code-excerpt-4.0.0.tgz", "integrity": "sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==", "dev": true, "license": "MIT", "dependencies": { "convert-to-spaces": "^2.0.1" }, "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, "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, "license": "MIT", "dependencies": { "color-name": "~1.1.4" }, "engines": { "node": ">=7.0.0" } }, "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, "license": "MIT" }, "node_modules/convert-source-map": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", "dev": true, "license": "MIT" }, "node_modules/convert-to-spaces": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/convert-to-spaces/-/convert-to-spaces-2.0.1.tgz", "integrity": "sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==", "dev": true, "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, "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, "license": "MIT" }, "node_modules/cross-spawn": { "version": "7.0.6", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dev": true, "license": "MIT", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" }, "engines": { "node": ">= 8" } }, "node_modules/cross-spawn/node_modules/isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", "dev": true, "license": "ISC" }, "node_modules/cross-spawn/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, "license": "ISC", "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/node-which" }, "engines": { "node": ">= 8" } }, "node_modules/debug": { "version": "4.4.3", "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "dev": true, "license": "MIT", "dependencies": { "ms": "^2.1.3" }, "engines": { "node": ">=6.0" }, "peerDependenciesMeta": { "supports-color": { "optional": true } } }, "node_modules/diff": { "version": "8.0.3", "resolved": "https://registry.npmjs.org/diff/-/diff-8.0.3.tgz", "integrity": "sha512-qejHi7bcSD4hQAZE0tNAawRK1ZtafHDmMTMkrrIGgSLl7hTnQHmKCeB45xAcbfTqK2zowkM3j3bHt/4b/ARbYQ==", "dev": true, "license": "BSD-3-Clause", "engines": { "node": ">=0.3.1" } }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", "dev": true, "license": "MIT" }, "node_modules/emoji-regex": { "version": "10.6.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==", "dev": true, "license": "MIT" }, "node_modules/encoding": { "version": "0.1.13", "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", "dev": true, "license": "MIT", "optional": true, "dependencies": { "iconv-lite": "^0.6.2" } }, "node_modules/end-of-stream": { "version": "1.4.5", "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", "dev": true, "license": "MIT", "dependencies": { "once": "^1.4.0" } }, "node_modules/entities": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", "dev": true, "license": "BSD-2-Clause", "engines": { "node": ">=0.12" }, "funding": { "url": "https://github.com/fb55/entities?sponsor=1" } }, "node_modules/env-paths": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", "dev": true, "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/environment": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz", "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==", "dev": true, "license": "MIT", "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/err-code": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==", "dev": true, "license": "MIT" }, "node_modules/es-toolkit": { "version": "1.44.0", "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.44.0.tgz", "integrity": "sha512-6penXeZalaV88MM3cGkFZZfOoLGWshWWfdy0tWw/RlVVyhvMaWSBTOvXNeiW3e5FwdS5ePW0LGEu17zT139ktg==", "dev": true, "license": "MIT", "workspaces": [ "docs", "benchmarks" ] }, "node_modules/escalade": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", "dev": true, "license": "MIT", "engines": { "node": ">=6" } }, "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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/events-to-array": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/events-to-array/-/events-to-array-2.0.3.tgz", "integrity": "sha512-f/qE2gImHRa4Cp2y1stEOSgw8wTFyUdVJX7G//bMwbaV9JqISFxg99NbmVQeP7YLnDUZ2un851jlaDrlpmGehQ==", "dev": true, "license": "ISC", "engines": { "node": ">=12" } }, "node_modules/exponential-backoff": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz", "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==", "dev": true, "license": "Apache-2.0" }, "node_modules/fdir": { "version": "6.5.0", "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", "dev": true, "license": "MIT", "engines": { "node": ">=12.0.0" }, "peerDependencies": { "picomatch": "^3 || ^4" }, "peerDependenciesMeta": { "picomatch": { "optional": true } } }, "node_modules/find-up": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, "license": "MIT", "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/foreground-child": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-4.0.3.tgz", "integrity": "sha512-yeXZaNbCBGaT9giTpLPBdtedzjwhlJBUoL/R4BVQU5mn0TQXOHwVIl1Q2DMuBIdNno4ktA1abZ7dQFVxD6uHxw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "signal-exit": "^4.0.1" }, "engines": { "node": ">=16" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "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" } ], "license": "MIT" }, "node_modules/fs-minipass": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz", "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^7.0.3" }, "engines": { "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, "node_modules/function-loop": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/function-loop/-/function-loop-4.0.0.tgz", "integrity": "sha512-f34iQBedYF3XcI93uewZZOnyscDragxgTK/eTvVB74k3fCD0ZorOi5BV9GS4M8rz/JoNi0Kl3qX5Y9MH3S/CLQ==", "dev": true, "license": "ISC" }, "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, "license": "ISC", "engines": { "node": "6.* || 8.* || >= 10.*" } }, "node_modules/get-east-asian-width": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.5.0.tgz", "integrity": "sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==", "dev": true, "license": "MIT", "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/glob": { "version": "13.0.5", "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.5.tgz", "integrity": "sha512-BzXxZg24Ibra1pbQ/zE7Kys4Ua1ks7Bn6pKLkVPZ9FZe4JQS6/Q7ef3LG1H+k7lUf5l4T3PLSyYyYJVYUvfgTw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "minimatch": "^10.2.1", "minipass": "^7.1.2", "path-scurry": "^2.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/graceful-fs": { "version": "4.2.11", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", "dev": true, "license": "ISC" }, "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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/hosted-git-info": { "version": "9.0.2", "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-9.0.2.tgz", "integrity": "sha512-M422h7o/BR3rmCQ8UHi7cyyMqKltdP9Uo+J2fXK+RSAY+wTcKOIRyhTuKv4qn+DJf3g+PL890AzId5KZpX+CBg==", "dev": true, "license": "ISC", "dependencies": { "lru-cache": "^11.1.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "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, "license": "MIT" }, "node_modules/http-cache-semantics": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==", "dev": true, "license": "BSD-2-Clause" }, "node_modules/http-proxy-agent": { "version": "7.0.2", "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz", "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==", "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" }, "engines": { "node": ">= 14" } }, "node_modules/https-proxy-agent": { "version": "7.0.6", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.2", "debug": "4" }, "engines": { "node": ">= 14" } }, "node_modules/iconv-lite": { "version": "0.6.3", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", "dev": true, "license": "MIT", "optional": true, "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" }, "engines": { "node": ">=0.10.0" } }, "node_modules/ignore-walk": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-8.0.0.tgz", "integrity": "sha512-FCeMZT4NiRQGh+YkeKMtWrOmBgWjHjMJ26WQWrRQyoyzqevdaGSakUaJW5xQYmjLlUVk2qUnCjYVBax9EKKg8A==", "dev": true, "license": "ISC", "dependencies": { "minimatch": "^10.0.3" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/imurmurhash": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "dev": true, "license": "MIT", "engines": { "node": ">=0.8.19" } }, "node_modules/indent-string": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz", "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==", "dev": true, "license": "MIT", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "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, "license": "ISC" }, "node_modules/ini": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/ini/-/ini-6.0.0.tgz", "integrity": "sha512-IBTdIkzZNOpqm7q3dRqJvMaldXjDHWkEDfrwGEQTs5eaQMWV+djAhR+wahyNNMAa+qpbDUhBMVt4ZKNwpPm7xQ==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/ink": { "version": "5.2.1", "resolved": "https://registry.npmjs.org/ink/-/ink-5.2.1.tgz", "integrity": "sha512-BqcUyWrG9zq5HIwW6JcfFHsIYebJkWWb4fczNah1goUO0vv5vneIlfwuS85twyJ5hYR/y18FlAYUxrO9ChIWVg==", "dev": true, "license": "MIT", "dependencies": { "@alcalzone/ansi-tokenize": "^0.1.3", "ansi-escapes": "^7.0.0", "ansi-styles": "^6.2.1", "auto-bind": "^5.0.1", "chalk": "^5.3.0", "cli-boxes": "^3.0.0", "cli-cursor": "^4.0.0", "cli-truncate": "^4.0.0", "code-excerpt": "^4.0.0", "es-toolkit": "^1.22.0", "indent-string": "^5.0.0", "is-in-ci": "^1.0.0", "patch-console": "^2.0.0", "react-reconciler": "^0.29.0", "scheduler": "^0.23.0", "signal-exit": "^3.0.7", "slice-ansi": "^7.1.0", "stack-utils": "^2.0.6", "string-width": "^7.2.0", "type-fest": "^4.27.0", "widest-line": "^5.0.0", "wrap-ansi": "^9.0.0", "ws": "^8.18.0", "yoga-layout": "~3.2.1" }, "engines": { "node": ">=18" }, "peerDependencies": { "@types/react": ">=18.0.0", "react": ">=18.0.0", "react-devtools-core": "^4.19.1" }, "peerDependenciesMeta": { "@types/react": { "optional": true }, "react-devtools-core": { "optional": true } } }, "node_modules/ink/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, "license": "ISC" }, "node_modules/ip-address": { "version": "10.1.0", "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.1.0.tgz", "integrity": "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==", "dev": true, "license": "MIT", "engines": { "node": ">= 12" } }, "node_modules/is-actual-promise": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-actual-promise/-/is-actual-promise-1.0.2.tgz", "integrity": "sha512-xsFiO1of0CLsQnPZ1iXHNTyR9YszOeWKYv+q6n8oSFW3ipooFJ1j1lbRMgiMCr+pp2gLruESI4zb5Ak6eK5OnQ==", "dev": true, "license": "BlueOak-1.0.0" }, "node_modules/is-fullwidth-code-point": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz", "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==", "dev": true, "license": "MIT", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/is-in-ci": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-in-ci/-/is-in-ci-1.0.0.tgz", "integrity": "sha512-eUuAjybVTHMYWm/U+vBO1sY/JOCgoPCXRxzdju0K+K0BiGW0SChEL1MLC0PoCIR1OlPo5YAp8HuQoUlsWEICwg==", "dev": true, "license": "MIT", "bin": { "is-in-ci": "cli.js" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/is-plain-object": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz", "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==", "dev": true, "license": "MIT", "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, "license": "MIT" }, "node_modules/isexe": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz", "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": ">=20" } }, "node_modules/istanbul-lib-coverage": { "version": "3.2.2", "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", "dev": true, "license": "BSD-3-Clause", "engines": { "node": ">=8" } }, "node_modules/istanbul-lib-report": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", "dev": true, "license": "BSD-3-Clause", "dependencies": { "istanbul-lib-coverage": "^3.0.0", "make-dir": "^4.0.0", "supports-color": "^7.1.0" }, "engines": { "node": ">=10" } }, "node_modules/istanbul-reports": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", "dev": true, "license": "BSD-3-Clause", "dependencies": { "html-escaper": "^2.0.0", "istanbul-lib-report": "^3.0.0" }, "engines": { "node": ">=8" } }, "node_modules/jackspeak": { "version": "4.2.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.2.3.tgz", "integrity": "sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/cliui": "^9.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "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, "license": "MIT" }, "node_modules/json-parse-even-better-errors": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-5.0.0.tgz", "integrity": "sha512-ZF1nxZ28VhQouRWhUcVlUIN3qwSgPuswK05s/HIaoetAoE/9tngVmCHjSxmSQPav1nd+lPtTL0YZ/2AFdR/iYQ==", "dev": true, "license": "MIT", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/jsonc-simple-parser": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/jsonc-simple-parser/-/jsonc-simple-parser-3.0.0.tgz", "integrity": "sha512-0qi9Kuj4JPar4/3b9wZteuPZrTeFzXsQyOZj7hksnReCZN3Vr17Doz7w/i3E9XH7vRkVTHhHES+r1h97I+hfww==", "dev": true, "dependencies": { "reghex": "^3.0.2" } }, "node_modules/jsonparse": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", "dev": true, "engines": [ "node >= 0.2.0" ], "license": "MIT" }, "node_modules/linkify-it": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz", "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==", "dev": true, "license": "MIT", "dependencies": { "uc.micro": "^2.0.0" } }, "node_modules/locate-path": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, "license": "MIT", "dependencies": { "p-locate": "^5.0.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/loose-envify": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", "dev": true, "license": "MIT", "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "node_modules/lru-cache": { "version": "11.2.6", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.6.tgz", "integrity": "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": "20 || >=22" } }, "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, "license": "MIT" }, "node_modules/make-dir": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", "dev": true, "license": "MIT", "dependencies": { "semver": "^7.5.3" }, "engines": { "node": ">=10" }, "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, "license": "ISC" }, "node_modules/make-fetch-happen": { "version": "15.0.3", "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-15.0.3.tgz", "integrity": "sha512-iyyEpDty1mwW3dGlYXAJqC/azFn5PPvgKVwXayOGBSmKLxhKZ9fg4qIan2ePpp1vJIwfFiO34LAPZgq9SZW9Aw==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/agent": "^4.0.0", "cacache": "^20.0.1", "http-cache-semantics": "^4.1.1", "minipass": "^7.0.2", "minipass-fetch": "^5.0.0", "minipass-flush": "^1.0.5", "minipass-pipeline": "^1.2.4", "negotiator": "^1.0.0", "proc-log": "^6.0.0", "promise-retry": "^2.0.1", "ssri": "^13.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/markdown-it": { "version": "14.1.1", "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.1.tgz", "integrity": "sha512-BuU2qnTti9YKgK5N+IeMubp14ZUKUUw7yeJbkjtosvHiP0AZ5c8IAgEMk79D0eC8F23r4Ac/q8cAIFdm2FtyoA==", "dev": true, "license": "MIT", "dependencies": { "argparse": "^2.0.1", "entities": "^4.4.0", "linkify-it": "^5.0.0", "mdurl": "^2.0.0", "punycode.js": "^2.3.1", "uc.micro": "^2.1.0" }, "bin": { "markdown-it": "bin/markdown-it.mjs" } }, "node_modules/mdurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz", "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==", "dev": true, "license": "MIT" }, "node_modules/mimic-fn": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", "dev": true, "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/minimatch": { "version": "10.2.1", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.1.tgz", "integrity": "sha512-MClCe8IL5nRRmawL6ib/eT4oLyeKMGCghibcDWK+J0hh0Q8kqSdia6BvbRMVk6mPa6WqUa5uR2oxt6C5jd533A==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "brace-expansion": "^5.0.2" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/minipass": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", "dev": true, "license": "ISC", "engines": { "node": ">=16 || 14 >=14.17" } }, "node_modules/minipass-collect": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz", "integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^7.0.3" }, "engines": { "node": ">=16 || 14 >=14.17" } }, "node_modules/minipass-fetch": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-5.0.1.tgz", "integrity": "sha512-yHK8pb0iCGat0lDrs/D6RZmCdaBT64tULXjdxjSMAqoDi18Q3qKEUTHypHQZQd9+FYpIS+lkvpq6C/R6SbUeRw==", "dev": true, "license": "MIT", "dependencies": { "minipass": "^7.0.3", "minipass-sized": "^2.0.0", "minizlib": "^3.0.1" }, "engines": { "node": "^20.17.0 || >=22.9.0" }, "optionalDependencies": { "encoding": "^0.1.13" } }, "node_modules/minipass-flush": { "version": "1.0.5", "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^3.0.0" }, "engines": { "node": ">= 8" } }, "node_modules/minipass-flush/node_modules/minipass": { "version": "3.3.6", "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", "dev": true, "license": "ISC", "dependencies": { "yallist": "^4.0.0" }, "engines": { "node": ">=8" } }, "node_modules/minipass-flush/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, "license": "ISC" }, "node_modules/minipass-pipeline": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^3.0.0" }, "engines": { "node": ">=8" } }, "node_modules/minipass-pipeline/node_modules/minipass": { "version": "3.3.6", "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", "dev": true, "license": "ISC", "dependencies": { "yallist": "^4.0.0" }, "engines": { "node": ">=8" } }, "node_modules/minipass-pipeline/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, "license": "ISC" }, "node_modules/minipass-sized": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-2.0.0.tgz", "integrity": "sha512-zSsHhto5BcUVM2m1LurnXY6M//cGhVaegT71OfOXoprxT6o780GZd792ea6FfrQkuU4usHZIUczAQMRUE2plzA==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^7.1.2" }, "engines": { "node": ">=8" } }, "node_modules/minizlib": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz", "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==", "dev": true, "license": "MIT", "dependencies": { "minipass": "^7.1.2" }, "engines": { "node": ">= 18" } }, "node_modules/mkdirp": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-3.0.1.tgz", "integrity": "sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==", "dev": true, "license": "MIT", "bin": { "mkdirp": "dist/cjs/src/bin.js" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/ms": { "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "dev": true, "license": "MIT" }, "node_modules/negotiator": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz", "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==", "dev": true, "license": "MIT", "engines": { "node": ">= 0.6" } }, "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, "license": "MIT" }, "node_modules/node-gyp": { "version": "12.2.0", "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-12.2.0.tgz", "integrity": "sha512-q23WdzrQv48KozXlr0U1v9dwO/k59NHeSzn6loGcasyf0UnSrtzs8kRxM+mfwJSf0DkX0s43hcqgnSO4/VNthQ==", "dev": true, "license": "MIT", "dependencies": { "env-paths": "^2.2.0", "exponential-backoff": "^3.1.1", "graceful-fs": "^4.2.6", "make-fetch-happen": "^15.0.0", "nopt": "^9.0.0", "proc-log": "^6.0.0", "semver": "^7.3.5", "tar": "^7.5.4", "tinyglobby": "^0.2.12", "which": "^6.0.0" }, "bin": { "node-gyp": "bin/node-gyp.js" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/node-options-to-argv": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/node-options-to-argv/-/node-options-to-argv-1.0.0.tgz", "integrity": "sha512-99rLlP+Cn/FsSV9kjpk2UmF2Ltmrpv/L9U7fUfws/MVXkeZWPpPDsQkMr79qCvSF/oTKVVJBTm5sHzmK2j6IIg==", "dev": true, "license": "BlueOak-1.0.0" }, "node_modules/nopt": { "version": "9.0.0", "resolved": "https://registry.npmjs.org/nopt/-/nopt-9.0.0.tgz", "integrity": "sha512-Zhq3a+yFKrYwSBluL4H9XP3m3y5uvQkB/09CwDruCiRmR/UJYnn9W4R48ry0uGC70aeTPKLynBtscP9efFFcPw==", "dev": true, "license": "ISC", "dependencies": { "abbrev": "^4.0.0" }, "bin": { "nopt": "bin/nopt.js" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-bundled": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-5.0.0.tgz", "integrity": "sha512-JLSpbzh6UUXIEoqPsYBvVNVmyrjVZ1fzEFbqxKkTJQkWBO3xFzFT+KDnSKQWwOQNbuWRwt5LSD6HOTLGIWzfrw==", "dev": true, "license": "ISC", "dependencies": { "npm-normalize-package-bin": "^5.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-install-checks": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-8.0.0.tgz", "integrity": "sha512-ScAUdMpyzkbpxoNekQ3tNRdFI8SJ86wgKZSQZdUxT+bj0wVFpsEMWnkXP0twVe1gJyNF5apBWDJhhIbgrIViRA==", "dev": true, "license": "BSD-2-Clause", "dependencies": { "semver": "^7.1.1" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-normalize-package-bin": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-5.0.0.tgz", "integrity": "sha512-CJi3OS4JLsNMmr2u07OJlhcrPxCeOeP/4xq67aWNai6TNWWbTrlNDgl8NcFKVlcBKp18GPj+EzbNIgrBfZhsag==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-package-arg": { "version": "13.0.2", "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-13.0.2.tgz", "integrity": "sha512-IciCE3SY3uE84Ld8WZU23gAPPV9rIYod4F+rc+vJ7h7cwAJt9Vk6TVsK60ry7Uj3SRS3bqRRIGuTp9YVlk6WNA==", "dev": true, "license": "ISC", "dependencies": { "hosted-git-info": "^9.0.0", "proc-log": "^6.0.0", "semver": "^7.3.5", "validate-npm-package-name": "^7.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-packlist": { "version": "10.0.3", "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-10.0.3.tgz", "integrity": "sha512-zPukTwJMOu5X5uvm0fztwS5Zxyvmk38H/LfidkOMt3gbZVCyro2cD/ETzwzVPcWZA3JOyPznfUN/nkyFiyUbxg==", "dev": true, "license": "ISC", "dependencies": { "ignore-walk": "^8.0.0", "proc-log": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-pick-manifest": { "version": "11.0.3", "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-11.0.3.tgz", "integrity": "sha512-buzyCfeoGY/PxKqmBqn1IUJrZnUi1VVJTdSSRPGI60tJdUhUoSQFhs0zycJokDdOznQentgrpf8LayEHyyYlqQ==", "dev": true, "license": "ISC", "dependencies": { "npm-install-checks": "^8.0.0", "npm-normalize-package-bin": "^5.0.0", "npm-package-arg": "^13.0.0", "semver": "^7.3.5" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/npm-registry-fetch": { "version": "19.1.1", "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-19.1.1.tgz", "integrity": "sha512-TakBap6OM1w0H73VZVDf44iFXsOS3h+L4wVMXmbWOQroZgFhMch0juN6XSzBNlD965yIKvWg2dfu7NSiaYLxtw==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/redact": "^4.0.0", "jsonparse": "^1.3.1", "make-fetch-happen": "^15.0.0", "minipass": "^7.0.2", "minipass-fetch": "^5.0.0", "minizlib": "^3.0.1", "npm-package-arg": "^13.0.0", "proc-log": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "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, "license": "ISC", "dependencies": { "wrappy": "1" } }, "node_modules/onetime": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", "dev": true, "license": "MIT", "dependencies": { "mimic-fn": "^2.1.0" }, "engines": { "node": ">=6" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "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, "license": "(WTFPL OR MIT)", "bin": { "opener": "bin/opener-bin.js" } }, "node_modules/p-limit": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, "license": "MIT", "dependencies": { "yocto-queue": "^0.1.0" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, "license": "MIT", "dependencies": { "p-limit": "^3.0.2" }, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/p-map": { "version": "7.0.4", "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.4.tgz", "integrity": "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==", "dev": true, "license": "MIT", "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/package-json-from-dist": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", "dev": true, "license": "BlueOak-1.0.0" }, "node_modules/pacote": { "version": "21.3.1", "resolved": "https://registry.npmjs.org/pacote/-/pacote-21.3.1.tgz", "integrity": "sha512-O0EDXi85LF4AzdjG74GUwEArhdvawi/YOHcsW6IijKNj7wm8IvEWNF5GnfuxNpQ/ZpO3L37+v8hqdVh8GgWYhg==", "dev": true, "license": "ISC", "dependencies": { "@npmcli/git": "^7.0.0", "@npmcli/installed-package-contents": "^4.0.0", "@npmcli/package-json": "^7.0.0", "@npmcli/promise-spawn": "^9.0.0", "@npmcli/run-script": "^10.0.0", "cacache": "^20.0.0", "fs-minipass": "^3.0.0", "minipass": "^7.0.2", "npm-package-arg": "^13.0.0", "npm-packlist": "^10.0.1", "npm-pick-manifest": "^11.0.1", "npm-registry-fetch": "^19.0.0", "proc-log": "^6.0.0", "promise-retry": "^2.0.1", "sigstore": "^4.0.0", "ssri": "^13.0.0", "tar": "^7.4.3" }, "bin": { "pacote": "bin/index.js" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/patch-console": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/patch-console/-/patch-console-2.0.0.tgz", "integrity": "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==", "dev": true, "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" } }, "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, "license": "MIT", "engines": { "node": ">=8" } }, "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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/path-scurry": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz", "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/picomatch": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "license": "MIT", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" } }, "node_modules/pirates": { "version": "4.0.7", "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", "dev": true, "license": "MIT", "engines": { "node": ">= 6" } }, "node_modules/polite-json": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/polite-json/-/polite-json-5.0.0.tgz", "integrity": "sha512-OLS/0XeUAcE8a2fdwemNja+udKgXNnY6yKVIXqAD2zVRx1KvY6Ato/rZ2vdzbxqYwPW0u6SCNC/bAMPNzpzxbw==", "dev": true, "license": "MIT", "engines": { "node": "^14.17.0 || ^16.13.0 || >=18.0.0" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/prettier": { "version": "3.8.1", "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz", "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==", "dev": true, "license": "MIT", "bin": { "prettier": "bin/prettier.cjs" }, "engines": { "node": ">=14" }, "funding": { "url": "https://github.com/prettier/prettier?sponsor=1" } }, "node_modules/prismjs": { "version": "1.30.0", "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz", "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==", "dev": true, "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/prismjs-terminal": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/prismjs-terminal/-/prismjs-terminal-1.2.4.tgz", "integrity": "sha512-S2nsjy6s2x2jF4uTW8ulX19rvmRfe9R1wmnNwI5wmBgQEErB0vuKueVPMzN6KsFRCCJ2IQrWUS0BqhcNsrR9xg==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "chalk": "^5.2.0", "prismjs": "^1.30.0", "string-length": "^6.0.0" }, "engines": { "node": ">=16" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/proc-log": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-6.1.0.tgz", "integrity": "sha512-iG+GYldRf2BQ0UDUAd6JQ/RwzaQy6mXmsk/IzlYyal4A4SNFw54MeH4/tLkF4I5WoWG9SQwuqWzS99jaFQHBuQ==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "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, "license": "MIT" }, "node_modules/process-on-spawn": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/process-on-spawn/-/process-on-spawn-1.1.0.tgz", "integrity": "sha512-JOnOPQ/8TZgjs1JIH/m9ni7FfimjNa/PRx7y/Wb5qdItsnhO0jE4AT7fC0HjC28DUQWDr50dwSYZLdRMlqDq3Q==", "dev": true, "license": "MIT", "dependencies": { "fromentries": "^1.2.0" }, "engines": { "node": ">=8" } }, "node_modules/promise-retry": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", "dev": true, "license": "MIT", "dependencies": { "err-code": "^2.0.2", "retry": "^0.12.0" }, "engines": { "node": ">=10" } }, "node_modules/punycode.js": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz", "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==", "dev": true, "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/react": { "version": "18.3.1", "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", "dev": true, "license": "MIT", "dependencies": { "loose-envify": "^1.1.0" }, "engines": { "node": ">=0.10.0" } }, "node_modules/react-dom": { "version": "18.3.1", "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", "dev": true, "license": "MIT", "peer": true, "dependencies": { "loose-envify": "^1.1.0", "scheduler": "^0.23.2" }, "peerDependencies": { "react": "^18.3.1" } }, "node_modules/react-element-to-jsx-string": { "version": "15.0.0", "resolved": "https://registry.npmjs.org/react-element-to-jsx-string/-/react-element-to-jsx-string-15.0.0.tgz", "integrity": "sha512-UDg4lXB6BzlobN60P8fHWVPX3Kyw8ORrTeBtClmIlGdkOOE+GYQSFvmEU5iLLpwp/6v42DINwNcwOhOLfQ//FQ==", "dev": true, "license": "MIT", "dependencies": { "@base2/pretty-print-object": "1.0.1", "is-plain-object": "5.0.0", "react-is": "18.1.0" }, "peerDependencies": { "react": "^0.14.8 || ^15.0.1 || ^16.0.0 || ^17.0.1 || ^18.0.0", "react-dom": "^0.14.8 || ^15.0.1 || ^16.0.0 || ^17.0.1 || ^18.0.0" } }, "node_modules/react-is": { "version": "18.1.0", "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.1.0.tgz", "integrity": "sha512-Fl7FuabXsJnV5Q1qIOQwx/sagGF18kogb4gpfcG4gjLBWO0WDiiz1ko/ExayuxE7InyQkBLkxRFG5oxY6Uu3Kg==", "dev": true, "license": "MIT" }, "node_modules/react-reconciler": { "version": "0.29.2", "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.29.2.tgz", "integrity": "sha512-zZQqIiYgDCTP/f1N/mAR10nJGrPD2ZR+jDSEsKWJHYC7Cm2wodlwbR3upZRdC3cjIjSlTLNVyO7Iu0Yy7t2AYg==", "dev": true, "license": "MIT", "dependencies": { "loose-envify": "^1.1.0", "scheduler": "^0.23.2" }, "engines": { "node": ">=0.10.0" }, "peerDependencies": { "react": "^18.3.1" } }, "node_modules/readable-stream": { "version": "2.3.8", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", "dev": true, "license": "MIT", "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": "4.1.2", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", "dev": true, "license": "MIT", "engines": { "node": ">= 14.18.0" }, "funding": { "type": "individual", "url": "https://paulmillr.com/funding/" } }, "node_modules/reghex": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/reghex/-/reghex-3.0.2.tgz", "integrity": "sha512-Zb9DJ5u6GhgqRSBnxV2QSnLqEwcKxHWFA1N2yUa4ZUAO1P8jlWKYtWZ6/ooV6yylspGXJX0O/uNzEv0xrCtwaA==", "dev": true, "license": "MIT" }, "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, "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/resolve-import": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/resolve-import/-/resolve-import-2.4.0.tgz", "integrity": "sha512-gLWKdA5tiv5j/D7ipR47u3ovbVfzFPrctTdw2Ulnpmr6PPVVSvPKGNWu09jXVNlOSLLAeD6CA13bjIelpWttSw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "glob": "^13.0.0", "walk-up-path": "^4.0.0" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/restore-cursor": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz", "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==", "dev": true, "license": "MIT", "dependencies": { "onetime": "^5.1.0", "signal-exit": "^3.0.2" }, "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/restore-cursor/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, "license": "ISC" }, "node_modules/retry": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==", "dev": true, "license": "MIT", "engines": { "node": ">= 4" } }, "node_modules/rimraf": { "version": "6.1.3", "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.1.3.tgz", "integrity": "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "glob": "^13.0.3", "package-json-from-dist": "^1.0.1" }, "bin": { "rimraf": "dist/esm/bin.mjs" }, "engines": { "node": "20 || >=22" }, "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, "license": "MIT" }, "node_modules/safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", "dev": true, "license": "MIT", "optional": true }, "node_modules/scheduler": { "version": "0.23.2", "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", "dev": true, "license": "MIT", "dependencies": { "loose-envify": "^1.1.0" } }, "node_modules/semver": { "version": "7.7.4", "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "dev": true, "license": "ISC", "bin": { "semver": "bin/semver.js" }, "engines": { "node": ">=10" } }, "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, "license": "MIT", "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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/signal-exit": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", "dev": true, "license": "ISC", "engines": { "node": ">=14" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/sigstore": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/sigstore/-/sigstore-4.1.0.tgz", "integrity": "sha512-/fUgUhYghuLzVT/gaJoeVehLCgZiUxPCPMcyVNY0lIf/cTCz58K/WTI7PefDarXxp9nUKpEwg1yyz3eSBMTtgA==", "dev": true, "license": "Apache-2.0", "dependencies": { "@sigstore/bundle": "^4.0.0", "@sigstore/core": "^3.1.0", "@sigstore/protobuf-specs": "^0.5.0", "@sigstore/sign": "^4.1.0", "@sigstore/tuf": "^4.0.1", "@sigstore/verify": "^3.1.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/slice-ansi": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz", "integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==", "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.2.1", "is-fullwidth-code-point": "^5.0.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/chalk/slice-ansi?sponsor=1" } }, "node_modules/slice-ansi/node_modules/is-fullwidth-code-point": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz", "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==", "dev": true, "license": "MIT", "dependencies": { "get-east-asian-width": "^1.3.1" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/smart-buffer": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", "dev": true, "license": "MIT", "engines": { "node": ">= 6.0.0", "npm": ">= 3.0.0" } }, "node_modules/socks": { "version": "2.8.7", "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz", "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==", "dev": true, "license": "MIT", "dependencies": { "ip-address": "^10.0.1", "smart-buffer": "^4.2.0" }, "engines": { "node": ">= 10.0.0", "npm": ">= 3.0.0" } }, "node_modules/socks-proxy-agent": { "version": "8.0.5", "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz", "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==", "dev": true, "license": "MIT", "dependencies": { "agent-base": "^7.1.2", "debug": "^4.3.4", "socks": "^2.8.3" }, "engines": { "node": ">= 14" } }, "node_modules/spdx-correct": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", "dev": true, "license": "Apache-2.0", "dependencies": { "spdx-expression-parse": "^3.0.0", "spdx-license-ids": "^3.0.0" } }, "node_modules/spdx-exceptions": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==", "dev": true, "license": "CC-BY-3.0" }, "node_modules/spdx-expression-parse": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", "dev": true, "license": "MIT", "dependencies": { "spdx-exceptions": "^2.1.0", "spdx-license-ids": "^3.0.0" } }, "node_modules/spdx-license-ids": { "version": "3.0.22", "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.22.tgz", "integrity": "sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==", "dev": true, "license": "CC0-1.0" }, "node_modules/ssri": { "version": "13.0.1", "resolved": "https://registry.npmjs.org/ssri/-/ssri-13.0.1.tgz", "integrity": "sha512-QUiRf1+u9wPTL/76GTYlKttDEBWV1ga9ZXW8BG6kfdeyyM8LGPix9gROyg9V2+P0xNyF3X2Go526xKFdMZrHSQ==", "dev": true, "license": "ISC", "dependencies": { "minipass": "^7.0.3" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "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, "license": "MIT", "dependencies": { "escape-string-regexp": "^2.0.0" }, "engines": { "node": ">=10" } }, "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, "license": "MIT", "dependencies": { "safe-buffer": "~5.1.0" } }, "node_modules/string-length": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/string-length/-/string-length-6.0.0.tgz", "integrity": "sha512-1U361pxZHEQ+FeSjzqRpV+cu2vTzYeWeafXFLykiFlv4Vc0n3njgU8HrMbyik5uwm77naWMuVG8fhEF+Ovb1Kg==", "dev": true, "license": "MIT", "dependencies": { "strip-ansi": "^7.1.0" }, "engines": { "node": ">=16" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/string-width": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", "dev": true, "license": "MIT", "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/string-width-cjs": { "name": "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, "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/string-width-cjs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/string-width-cjs/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, "license": "MIT" }, "node_modules/string-width-cjs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/string-width-cjs/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, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/strip-ansi": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "dev": true, "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" }, "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/chalk/strip-ansi?sponsor=1" } }, "node_modules/strip-ansi-cjs": { "name": "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, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/strip-ansi-cjs/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, "license": "MIT", "engines": { "node": ">=8" } }, "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, "license": "MIT", "dependencies": { "has-flag": "^4.0.0" }, "engines": { "node": ">=8" } }, "node_modules/sync-content": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/sync-content/-/sync-content-2.0.4.tgz", "integrity": "sha512-w3ioiBmbaogob33WdLnuwFk+8tpePI58CTWKqtdAgEqc2hfGuSwP02gPETqNX/3PLS5skv5a1wQR0gbaa2W0XQ==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "glob": "^13.0.1", "mkdirp": "^3.0.1", "path-scurry": "^2.0.0", "rimraf": "^6.0.0" }, "bin": { "sync-content": "dist/esm/bin.mjs" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/tap": { "version": "21.6.1", "resolved": "https://registry.npmjs.org/tap/-/tap-21.6.1.tgz", "integrity": "sha512-QKKZg/2oWGCMRRCBq4AVeaJSNwxZqIkasNMdKQLge3CR5hRbRMEN3Hh8qN+V9EoHKOS8OBMabM9pPCqtLKyTjg==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@tapjs/after": "3.3.3", "@tapjs/after-each": "4.3.3", "@tapjs/asserts": "4.3.3", "@tapjs/before": "4.3.3", "@tapjs/before-each": "4.3.3", "@tapjs/chdir": "3.3.3", "@tapjs/core": "4.5.1", "@tapjs/filter": "4.3.3", "@tapjs/fixture": "4.3.3", "@tapjs/intercept": "4.3.3", "@tapjs/mock": "4.4.1", "@tapjs/node-serialize": "4.3.3", "@tapjs/run": "4.5.1", "@tapjs/snapshot": "4.3.3", "@tapjs/spawn": "4.3.3", "@tapjs/stdin": "4.3.3", "@tapjs/test": "4.4.1", "@tapjs/typescript": "3.5.3", "@tapjs/worker": "4.3.3", "resolve-import": "^2.4.0" }, "bin": { "tap": "dist/esm/run.mjs" }, "engines": { "node": "20 || >=22" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/tap-parser": { "version": "18.3.0", "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-18.3.0.tgz", "integrity": "sha512-sa0M18e6RARfO0Lrm1zbQvb+7G4G/ThkFIJFvjeH1DKenl4xwyUgpRUCb5Jq64Xe086p4auiLvRzfpRjGd3Zow==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "events-to-array": "^2.0.3", "tap-yaml": "4.3.0" }, "bin": { "tap-parser": "bin/cmd.cjs" }, "engines": { "node": "20 || >=22" } }, "node_modules/tap-yaml": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/tap-yaml/-/tap-yaml-4.3.0.tgz", "integrity": "sha512-48BiwXj3cUa1Lt6BLzfawJGZVihfRCY19gyjaHftQpe8ulEmB9gZW9kChQkdb0+L4YUlGWUJMpWRAJ/9bPSgVA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "yaml": "^2.8.1", "yaml-types": "^0.4.0" }, "engines": { "node": "20 || >=22" } }, "node_modules/tar": { "version": "7.5.9", "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.9.tgz", "integrity": "sha512-BTLcK0xsDh2+PUe9F6c2TlRp4zOOBMTkoQHQIWSIzI0R7KG46uEwq4OPk2W7bZcprBMsuaeFsqwYr7pjh6CuHg==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" }, "engines": { "node": ">=18" } }, "node_modules/tcompare": { "version": "9.3.0", "resolved": "https://registry.npmjs.org/tcompare/-/tcompare-9.3.0.tgz", "integrity": "sha512-6kFTU2xlXNFU88/DAAIQvjBu5znTGx8QPnFtaKiLin2OtspHXyevSu0iUTZt4UrSfuRC6fIahRCqaQIhXlsTVQ==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "diff": "^8.0.2", "react-element-to-jsx-string": "^15.0.0" }, "engines": { "node": "20 || >=22" } }, "node_modules/test-exclude": { "version": "7.0.1", "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz", "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==", "dev": true, "license": "ISC", "dependencies": { "@istanbuljs/schema": "^0.1.2", "glob": "^10.4.1", "minimatch": "^9.0.4" }, "engines": { "node": ">=18" } }, "node_modules/test-exclude/node_modules/@isaacs/cliui": { "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", "dev": true, "license": "ISC", "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" }, "engines": { "node": ">=12" } }, "node_modules/test-exclude/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, "license": "MIT" }, "node_modules/test-exclude/node_modules/brace-expansion": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "dev": true, "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" } }, "node_modules/test-exclude/node_modules/emoji-regex": { "version": "9.2.2", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", "dev": true, "license": "MIT" }, "node_modules/test-exclude/node_modules/foreground-child": { "version": "3.3.1", "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", "dev": true, "license": "ISC", "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" }, "engines": { "node": ">=14" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/test-exclude/node_modules/glob": { "version": "10.5.0", "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz", "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==", "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me", "dev": true, "license": "ISC", "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": { "glob": "dist/esm/bin.mjs" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/test-exclude/node_modules/jackspeak": { "version": "3.4.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/cliui": "^8.0.2" }, "funding": { "url": "https://github.com/sponsors/isaacs" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "node_modules/test-exclude/node_modules/lru-cache": { "version": "10.4.3", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", "dev": true, "license": "ISC" }, "node_modules/test-exclude/node_modules/minimatch": { "version": "9.0.5", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", "dev": true, "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" }, "engines": { "node": ">=16 || 14 >=14.17" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/test-exclude/node_modules/path-scurry": { "version": "1.11.1", "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" }, "engines": { "node": ">=16 || 14 >=14.18" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/test-exclude/node_modules/string-width": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", "dev": true, "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" }, "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/test-exclude/node_modules/wrap-ansi": { "version": "8.1.0", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" }, "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, "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, "license": "MIT", "dependencies": { "readable-stream": "~2.3.6", "xtend": "~4.0.1" } }, "node_modules/tinyglobby": { "version": "0.2.15", "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", "dev": true, "license": "MIT", "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" }, "engines": { "node": ">=12.0.0" }, "funding": { "url": "https://github.com/sponsors/SuperchupuDev" } }, "node_modules/trivial-deferred": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/trivial-deferred/-/trivial-deferred-2.0.0.tgz", "integrity": "sha512-iGbM7X2slv9ORDVj2y2FFUq3cP/ypbtu2nQ8S38ufjL0glBABvmR9pTdsib1XtS2LUhhLMbelaBUaf/s5J3dSw==", "dev": true, "license": "ISC", "engines": { "node": ">= 8" } }, "node_modules/tshy": { "version": "3.3.2", "resolved": "https://registry.npmjs.org/tshy/-/tshy-3.3.2.tgz", "integrity": "sha512-vOIXkqMtBWNjKUR/c99+6N50LhWdnKG1xE3+5wf8IPdzxx2lcIFPvbGgFdBBgoTMbdNb8mz06MUm7hY+TFnJcw==", "dev": true, "license": "BlueOak-1.0.0", "dependencies": { "@typescript/native-preview": "^7.0.0-dev.20260218.1", "chalk": "^5.6.2", "chokidar": "^4.0.3", "foreground-child": "^4.0.0", "jsonc-simple-parser": "^3.0.0", "minimatch": "^10.0.3", "mkdirp": "^3.0.1", "polite-json": "^5.0.0", "resolve-import": "^2.4.0", "rimraf": "^6.1.2", "sync-content": "^2.0.3", "typescript": "^5.9.3", "walk-up-path": "^4.0.0" }, "bin": { "tshy": "dist/esm/bin-min.mjs" }, "engines": { "node": "20 || >=22" } }, "node_modules/tuf-js": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-4.1.0.tgz", "integrity": "sha512-50QV99kCKH5P/Vs4E2Gzp7BopNV+KzTXqWeaxrfu5IQJBOULRsTIS9seSsOVT8ZnGXzCyx55nYWAi4qJzpZKEQ==", "dev": true, "license": "MIT", "dependencies": { "@tufjs/models": "4.1.0", "debug": "^4.4.3", "make-fetch-happen": "^15.0.1" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/type-fest": { "version": "4.41.0", "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz", "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==", "dev": true, "license": "(MIT OR CC0-1.0)", "engines": { "node": ">=16" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/typedoc": { "version": "0.28.17", "resolved": "https://registry.npmjs.org/typedoc/-/typedoc-0.28.17.tgz", "integrity": "sha512-ZkJ2G7mZrbxrKxinTQMjFqsCoYY6a5Luwv2GKbTnBCEgV2ihYm5CflA9JnJAwH0pZWavqfYxmDkFHPt4yx2oDQ==", "dev": true, "license": "Apache-2.0", "dependencies": { "@gerrit0/mini-shiki": "^3.17.0", "lunr": "^2.3.9", "markdown-it": "^14.1.0", "minimatch": "^9.0.5", "yaml": "^2.8.1" }, "bin": { "typedoc": "bin/typedoc" }, "engines": { "node": ">= 18", "pnpm": ">= 10" }, "peerDependencies": { "typescript": "5.0.x || 5.1.x || 5.2.x || 5.3.x || 5.4.x || 5.5.x || 5.6.x || 5.7.x || 5.8.x || 5.9.x" } }, "node_modules/typedoc/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, "license": "MIT" }, "node_modules/typedoc/node_modules/brace-expansion": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "dev": true, "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" } }, "node_modules/typedoc/node_modules/minimatch": { "version": "9.0.5", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", "dev": true, "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" }, "engines": { "node": ">=16 || 14 >=14.17" }, "funding": { "url": "https://github.com/sponsors/isaacs" } }, "node_modules/typescript": { "version": "5.9.3", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "dev": true, "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" }, "engines": { "node": ">=14.17" } }, "node_modules/uc.micro": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz", "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A==", "dev": true, "license": "MIT" }, "node_modules/undici-types": { "version": "7.16.0", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", "dev": true, "license": "MIT" }, "node_modules/unique-filename": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-5.0.0.tgz", "integrity": "sha512-2RaJTAvAb4owyjllTfXzFClJ7WsGxlykkPvCr9pA//LD9goVq+m4PPAeBgNodGZ7nSrntT/auWpJ6Y5IFXcfjg==", "dev": true, "license": "ISC", "dependencies": { "unique-slug": "^6.0.0" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/unique-slug": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-6.0.0.tgz", "integrity": "sha512-4Lup7Ezn8W3d52/xBhZBVdx323ckxa7DEvd9kPQHppTkLoJXw6ltrBCyj5pnrxj0qKDxYMJ56CoxNuFCscdTiw==", "dev": true, "license": "ISC", "dependencies": { "imurmurhash": "^0.1.4" }, "engines": { "node": "^20.17.0 || >=22.9.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, "license": "MIT" }, "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, "license": "MIT", "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, "license": "MIT" }, "node_modules/v8-to-istanbul": { "version": "9.3.0", "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz", "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==", "dev": true, "license": "ISC", "dependencies": { "@jridgewell/trace-mapping": "^0.3.12", "@types/istanbul-lib-coverage": "^2.0.1", "convert-source-map": "^2.0.0" }, "engines": { "node": ">=10.12.0" } }, "node_modules/v8-to-istanbul/node_modules/@jridgewell/trace-mapping": { "version": "0.3.31", "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "dev": true, "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "node_modules/validate-npm-package-license": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", "dev": true, "license": "Apache-2.0", "dependencies": { "spdx-correct": "^3.0.0", "spdx-expression-parse": "^3.0.0" } }, "node_modules/validate-npm-package-name": { "version": "7.0.2", "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-7.0.2.tgz", "integrity": "sha512-hVDIBwsRruT73PbK7uP5ebUt+ezEtCmzZz3F59BSr2F6OVFnJ/6h8liuvdLrQ88Xmnk6/+xGGuq+pG9WwTuy3A==", "dev": true, "license": "ISC", "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/walk-up-path": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/walk-up-path/-/walk-up-path-4.0.0.tgz", "integrity": "sha512-3hu+tD8YzSLGuFYtPRb48vdhKMi0KQV5sn+uWr8+7dMEq/2G/dtLrdDinkLjqq5TIbIBjYJ4Ax/n3YiaW7QM8A==", "dev": true, "license": "ISC", "engines": { "node": "20 || >=22" } }, "node_modules/which": { "version": "6.0.1", "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz", "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==", "dev": true, "license": "ISC", "dependencies": { "isexe": "^4.0.0" }, "bin": { "node-which": "bin/which.js" }, "engines": { "node": "^20.17.0 || >=22.9.0" } }, "node_modules/widest-line": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-5.0.0.tgz", "integrity": "sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==", "dev": true, "license": "MIT", "dependencies": { "string-width": "^7.0.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/wrap-ansi": { "version": "9.0.2", "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz", "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==", "dev": true, "license": "MIT", "dependencies": { "ansi-styles": "^6.2.1", "string-width": "^7.0.0", "strip-ansi": "^7.1.0" }, "engines": { "node": ">=18" }, "funding": { "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, "node_modules/wrap-ansi-cjs": { "name": "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, "license": "MIT", "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-cjs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/wrap-ansi-cjs/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, "license": "MIT", "dependencies": { "color-convert": "^2.0.1" }, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, "node_modules/wrap-ansi-cjs/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, "license": "MIT" }, "node_modules/wrap-ansi-cjs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/wrap-ansi-cjs/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, "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/wrap-ansi-cjs/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, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "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, "license": "ISC" }, "node_modules/ws": { "version": "8.19.0", "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", "dev": true, "license": "MIT", "engines": { "node": ">=10.0.0" }, "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "peerDependenciesMeta": { "bufferutil": { "optional": true }, "utf-8-validate": { "optional": true } } }, "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, "license": "MIT", "engines": { "node": ">=0.4" } }, "node_modules/y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true, "license": "ISC", "engines": { "node": ">=10" } }, "node_modules/yallist": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz", "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==", "dev": true, "license": "BlueOak-1.0.0", "engines": { "node": ">=18" } }, "node_modules/yaml": { "version": "2.8.2", "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz", "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==", "dev": true, "license": "ISC", "bin": { "yaml": "bin.mjs" }, "engines": { "node": ">= 14.6" }, "funding": { "url": "https://github.com/sponsors/eemeli" } }, "node_modules/yaml-types": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/yaml-types/-/yaml-types-0.4.0.tgz", "integrity": "sha512-XfbA30NUg4/LWUiplMbiufUiwYhgB9jvBhTWel7XQqjV+GaB79c2tROu/8/Tu7jO0HvDvnKWtBk5ksWRrhQ/0g==", "dev": true, "license": "ISC", "engines": { "node": ">= 16", "npm": ">= 7" }, "peerDependencies": { "yaml": "^2.3.0" } }, "node_modules/yargs": { "version": "17.7.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", "dev": true, "license": "MIT", "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" }, "engines": { "node": ">=12" } }, "node_modules/yargs-parser": { "version": "21.1.1", "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", "dev": true, "license": "ISC", "engines": { "node": ">=12" } }, "node_modules/yargs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/yargs/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, "license": "MIT" }, "node_modules/yargs/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, "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/yargs/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, "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/yargs/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, "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, "engines": { "node": ">=8" } }, "node_modules/yocto-queue": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, "license": "MIT", "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/yoga-layout": { "version": "3.2.1", "resolved": "https://registry.npmjs.org/yoga-layout/-/yoga-layout-3.2.1.tgz", "integrity": "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==", "dev": true, "license": "MIT" } } } isaacs-minipass-90fd647/package.json000066400000000000000000000035601514545521100174400ustar00rootroot00000000000000{ "name": "minipass", "version": "7.1.3", "description": "minimal implementation of a PassThrough stream", "main": "./dist/commonjs/index.js", "types": "./dist/commonjs/index.d.ts", "module": "./dist/esm/index.js", "type": "module", "tshy": { "selfLink": false, "compiler": "tsgo", "exports": { "./package.json": "./package.json", ".": "./src/index.ts" } }, "exports": { "./package.json": "./package.json", ".": { "import": { "types": "./dist/esm/index.d.ts", "default": "./dist/esm/index.js" }, "require": { "types": "./dist/commonjs/index.d.ts", "default": "./dist/commonjs/index.js" } } }, "files": [ "dist" ], "scripts": { "preversion": "npm test", "postversion": "npm publish", "prepublishOnly": "git push origin --follow-tags", "prepare": "tshy", "pretest": "npm run prepare", "presnap": "npm run prepare", "test": "tap", "snap": "tap", "format": "prettier --write . --loglevel warn", "typedoc": "typedoc --tsconfig .tshy/esm.json ./src/*.ts" }, "prettier": { "semi": false, "printWidth": 75, "tabWidth": 2, "useTabs": false, "singleQuote": true, "jsxSingleQuote": false, "bracketSameLine": true, "arrowParens": "avoid", "endOfLine": "lf" }, "devDependencies": { "@types/end-of-stream": "^1.4.2", "@types/node": "^25.2.3", "end-of-stream": "^1.4.0", "node-abort-controller": "^3.1.1", "prettier": "^3.8.1", "tap": "^21.6.1", "through2": "^2.0.3", "tshy": "^3.3.2", "typedoc": "^0.28.17" }, "repository": "https://github.com/isaacs/minipass", "keywords": [ "passthrough", "stream" ], "author": "Isaac Z. Schlueter (http://blog.izs.me/)", "license": "BlueOak-1.0.0", "engines": { "node": ">=16 || 14 >=14.17" } } isaacs-minipass-90fd647/scripts/000077500000000000000000000000001514545521100166355ustar00rootroot00000000000000isaacs-minipass-90fd647/scripts/transpile-to-esm.js000066400000000000000000000007121514545521100223760ustar00rootroot00000000000000#!/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-90fd647/src/000077500000000000000000000000001514545521100157355ustar00rootroot00000000000000isaacs-minipass-90fd647/src/index.ts000066400000000000000000001117311514545521100174200ustar00rootroot00000000000000const proc = typeof process === 'object' && process ? process : { stdout: null, stderr: null, } import { EventEmitter } from 'node:events' import Stream from 'node:stream' import { StringDecoder } from 'node:string_decoder' /** * Same as StringDecoder, but exposing the `lastNeed` flag on the type */ type SD = StringDecoder & { lastNeed: boolean } export type { SD, Pipe, PipeProxyErrors } /** * Return true if the argument is a Minipass stream, Node stream, or something * else that Minipass can interact with. */ export const isStream = ( s: any ): s is Minipass.Readable | Minipass.Writable => !!s && typeof s === 'object' && (s instanceof Minipass || s instanceof Stream || isReadable(s) || isWritable(s)) /** * Return true if the argument is a valid {@link Minipass.Readable} */ export const isReadable = (s: any): s is Minipass.Readable => !!s && typeof s === 'object' && s instanceof EventEmitter && typeof (s as Minipass.Readable).pipe === 'function' && // node core Writable streams have a pipe() method, but it throws (s as Minipass.Readable).pipe !== Stream.Writable.prototype.pipe /** * Return true if the argument is a valid {@link Minipass.Writable} */ export const isWritable = (s: any): s is Minipass.Readable => !!s && typeof s === 'object' && s instanceof EventEmitter && typeof (s as Minipass.Writable).write === 'function' && typeof (s as Minipass.Writable).end === 'function' 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 DATALISTENERS = Symbol('dataListeners') const DISCARDED = Symbol('discarded') const defer = (fn: (...a: any[]) => any) => Promise.resolve().then(fn) const nodefer = (fn: (...a: any[]) => any) => fn() // events that mean 'the stream is over' // these are treated specially, and re-emitted // if they are listened for after emitting. type EndishEvent = 'end' | 'finish' | 'prefinish' const isEndish = (ev: any): ev is EndishEvent => ev === 'end' || ev === 'finish' || ev === 'prefinish' const isArrayBufferLike = (b: any): b is ArrayBufferLike => b instanceof ArrayBuffer || (!!b && typeof b === 'object' && b.constructor && b.constructor.name === 'ArrayBuffer' && b.byteLength >= 0) const isArrayBufferView = (b: any): b is ArrayBufferView => !Buffer.isBuffer(b) && ArrayBuffer.isView(b) /** * Options that may be passed to stream.pipe() */ export interface PipeOptions { /** * end the destination stream when the source stream ends */ end?: boolean /** * proxy errors from the source stream to the destination stream */ proxyErrors?: boolean } /** * Internal class representing a pipe to a destination stream. * * @internal */ class Pipe { src: Minipass dest: Minipass opts: PipeOptions ondrain: () => any constructor( src: Minipass, dest: Minipass.Writable, opts: PipeOptions ) { this.src = src this.dest = dest as Minipass this.opts = opts this.ondrain = () => src[RESUME]() this.dest.on('drain', this.ondrain) } unpipe() { this.dest.removeListener('drain', this.ondrain) } // only here for the prototype /* c8 ignore start */ proxyErrors(_er: any) {} /* c8 ignore stop */ end() { this.unpipe() if (this.opts.end) this.dest.end() } } /** * Internal class representing a pipe to a destination stream where * errors are proxied. * * @internal */ class PipeProxyErrors extends Pipe { unpipe() { this.src.removeListener('error', this.proxyErrors) super.unpipe() } constructor( src: Minipass, dest: Minipass.Writable, opts: PipeOptions ) { super(src, dest, opts) this.proxyErrors = (er: Error) => this.dest.emit('error', er) src.on('error', this.proxyErrors) } } export namespace Minipass { /** * Encoding used to create a stream that outputs strings rather than * Buffer objects. */ export type Encoding = BufferEncoding | 'buffer' | null /** * Any stream that Minipass can pipe into */ export type Writable = | Minipass | NodeJS.WriteStream | (NodeJS.WriteStream & { fd: number }) | (EventEmitter & { end(): any write(chunk: any, ...args: any[]): any }) /** * Any stream that can be read from */ export type Readable = | Minipass | NodeJS.ReadStream | (NodeJS.ReadStream & { fd: number }) | (EventEmitter & { pause(): any resume(): any pipe(...destArgs: any[]): any }) /** * Utility type that can be iterated sync or async */ export type DualIterable = Iterable & AsyncIterable type EventArguments = Record /** * The listing of events that a Minipass class can emit. * Extend this when extending the Minipass class, and pass as * the third template argument. The key is the name of the event, * and the value is the argument list. * * Any undeclared events will still be allowed, but the handler will get * arguments as `unknown[]`. */ export interface Events extends EventArguments { readable: [] data: [chunk: RType] error: [er: unknown] abort: [reason: unknown] drain: [] resume: [] end: [] finish: [] prefinish: [] close: [] [DESTROYED]: [er?: unknown] [ERROR]: [er: unknown] } /** * String or buffer-like data that can be joined and sliced */ export type ContiguousData = | Buffer | ArrayBufferLike | ArrayBufferView | string export type BufferOrString = Buffer | string /** * Options passed to the Minipass constructor. */ export type SharedOptions = { /** * Defer all data emission and other events until the end of the * current tick, similar to Node core streams */ async?: boolean /** * A signal which will abort the stream */ signal?: AbortSignal /** * Output string encoding. Set to `null` or `'buffer'` (or omit) to * emit Buffer objects rather than strings. * * Conflicts with `objectMode` */ encoding?: BufferEncoding | null | 'buffer' /** * Output data exactly as it was written, supporting non-buffer/string * data (such as arbitrary objects, falsey values, etc.) * * Conflicts with `encoding` */ objectMode?: boolean } /** * Options for a string encoded output */ export type EncodingOptions = SharedOptions & { encoding: BufferEncoding objectMode?: false } /** * Options for contiguous data buffer output */ export type BufferOptions = SharedOptions & { encoding?: null | 'buffer' objectMode?: false } /** * Options for objectMode arbitrary output */ export type ObjectModeOptions = SharedOptions & { objectMode: true encoding?: null } /** * Utility type to determine allowed options based on read type */ export type Options = | ObjectModeOptions | (T extends string ? EncodingOptions : T extends Buffer ? BufferOptions : SharedOptions) } const isObjectModeOptions = ( o: Minipass.SharedOptions ): o is Minipass.ObjectModeOptions => !!o.objectMode const isEncodingOptions = ( o: Minipass.SharedOptions ): o is Minipass.EncodingOptions => !o.objectMode && !!o.encoding && o.encoding !== 'buffer' /** * Main export, the Minipass class * * `RType` is the type of data emitted, defaults to Buffer * * `WType` is the type of data to be written, if RType is buffer or string, * then any {@link Minipass.ContiguousData} is allowed. * * `Events` is the set of event handler signatures that this object * will emit, see {@link Minipass.Events} */ export class Minipass< RType extends unknown = Buffer, WType extends unknown = RType extends Minipass.BufferOrString ? Minipass.ContiguousData : RType, Events extends Minipass.Events = Minipass.Events > extends EventEmitter implements Minipass.DualIterable { [FLOWING]: boolean = false; [PAUSED]: boolean = false; [PIPES]: Pipe[] = []; [BUFFER]: RType[] = []; [OBJECTMODE]: boolean; [ENCODING]: BufferEncoding | null; [ASYNC]: boolean; [DECODER]: SD | null; [EOF]: boolean = false; [EMITTED_END]: boolean = false; [EMITTING_END]: boolean = false; [CLOSED]: boolean = false; [EMITTED_ERROR]: unknown = null; [BUFFERLENGTH]: number = 0; [DESTROYED]: boolean = false; [SIGNAL]?: AbortSignal; [ABORTED]: boolean = false; [DATALISTENERS]: number = 0; [DISCARDED]: boolean = false /** * true if the stream can be written */ writable: boolean = true /** * true if the stream can be read */ readable: boolean = true /** * If `RType` is Buffer, then options do not need to be provided. * Otherwise, an options object must be provided to specify either * {@link Minipass.SharedOptions.objectMode} or * {@link Minipass.SharedOptions.encoding}, as appropriate. */ constructor( ...args: | [Minipass.ObjectModeOptions] | (RType extends Buffer ? [] | [Minipass.Options] : [Minipass.Options]) ) { const options: Minipass.Options = (args[0] || {}) as Minipass.Options super() if (options.objectMode && typeof options.encoding === 'string') { throw new TypeError( 'Encoding and objectMode may not be used together' ) } if (isObjectModeOptions(options)) { this[OBJECTMODE] = true this[ENCODING] = null } else if (isEncodingOptions(options)) { this[ENCODING] = options.encoding this[OBJECTMODE] = false } else { this[OBJECTMODE] = false this[ENCODING] = null } this[ASYNC] = !!options.async this[DECODER] = this[ENCODING] ? (new StringDecoder(this[ENCODING]) as SD) : null //@ts-ignore - private option for debugging and testing if (options && options.debugExposeBuffer === true) { Object.defineProperty(this, 'buffer', { get: () => this[BUFFER] }) } //@ts-ignore - private option for debugging and testing if (options && options.debugExposePipes === true) { Object.defineProperty(this, 'pipes', { get: () => this[PIPES] }) } const { signal } = options if (signal) { this[SIGNAL] = signal if (signal.aborted) { this[ABORT]() } else { signal.addEventListener('abort', () => this[ABORT]()) } } } /** * The amount of data stored in the buffer waiting to be read. * * For Buffer strings, this will be the total byte length. * For string encoding streams, this will be the string character length, * according to JavaScript's `string.length` logic. * For objectMode streams, this is a count of the items waiting to be * emitted. */ get bufferLength() { return this[BUFFERLENGTH] } /** * The `BufferEncoding` currently in use, or `null` */ get encoding() { return this[ENCODING] } /** * @deprecated - This is a read only property */ set encoding(_enc) { throw new Error('Encoding must be set at instantiation time') } /** * @deprecated - Encoding may only be set at instantiation time */ setEncoding(_enc: Minipass.Encoding) { throw new Error('Encoding must be set at instantiation time') } /** * True if this is an objectMode stream */ get objectMode() { return this[OBJECTMODE] } /** * @deprecated - This is a read-only property */ set objectMode(_om) { throw new Error('objectMode must be set at instantiation time') } /** * true if this is an async stream */ get ['async'](): boolean { return this[ASYNC] } /** * Set to true to make this stream async. * * Once set, it cannot be unset, as this would potentially cause incorrect * behavior. Ie, a sync stream can be made async, but an async stream * cannot be safely made sync. */ set ['async'](a: boolean) { 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) } /** * True if the stream has been aborted. */ get aborted() { return this[ABORTED] } /** * No-op setter. Stream aborted status is set via the AbortSignal provided * in the constructor options. */ set aborted(_) {} /** * Write data into the stream * * If the chunk written is a string, and encoding is not specified, then * `utf8` will be assumed. If the stream encoding matches the encoding of * a written string, and the state of the string decoder allows it, then * the string will be passed through to either the output or the internal * buffer without any processing. Otherwise, it will be turned into a * Buffer object for processing into the desired encoding. * * If provided, `cb` function is called immediately before return for * sync streams, or on next tick for async streams, because for this * base class, a chunk is considered "processed" once it is accepted * and either emitted or buffered. That is, the callback does not indicate * that the chunk has been eventually emitted, though of course child * classes can override this function to do whatever processing is required * and call `super.write(...)` only once processing is completed. */ write(chunk: WType, cb?: () => void): boolean write( chunk: WType, encoding?: Minipass.Encoding, cb?: () => void ): boolean write( chunk: WType, encoding?: Minipass.Encoding | (() => void), cb?: () => void ): boolean { 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 : nodefer // 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 is only allowed if in object mode, so throw if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) { if (isArrayBufferView(chunk)) { //@ts-ignore - sinful unsafe type changing chunk = Buffer.from( chunk.buffer, chunk.byteOffset, chunk.byteLength ) } else if (isArrayBufferLike(chunk)) { //@ts-ignore - sinful unsafe type changing chunk = Buffer.from(chunk) } else if (typeof chunk !== 'string') { throw new Error( 'Non-contiguous data written to non-objectMode stream' ) } } // handle object mode up front, since it's simpler // this yields better performance, fewer checks later. if (this[OBJECTMODE]) { // maybe impossible? /* c8 ignore start */ if (this[FLOWING] && this[BUFFERLENGTH] !== 0) this[FLUSH](true) /* c8 ignore stop */ if (this[FLOWING]) this.emit('data', chunk as unknown as RType) else this[BUFFERPUSH](chunk as unknown as RType) 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 as Minipass.BufferOrString).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) ) { //@ts-ignore - sinful unsafe type change chunk = Buffer.from(chunk, encoding) } if (Buffer.isBuffer(chunk) && this[ENCODING]) { //@ts-ignore - sinful unsafe type change 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 as unknown as RType) else this[BUFFERPUSH](chunk as unknown as RType) if (this[BUFFERLENGTH] !== 0) this.emit('readable') if (cb) fn(cb) return this[FLOWING] } /** * Low-level explicit read method. * * In objectMode, the argument is ignored, and one item is returned if * available. * * `n` is the number of bytes (or in the case of encoding streams, * characters) to consume. If `n` is not provided, then the entire buffer * is returned, or `null` is returned if no data is available. * * If `n` is greater that the amount of data in the internal buffer, * then `null` is returned. */ read(n?: number | null): RType | null { if (this[DESTROYED]) return null this[DISCARDED] = false if ( this[BUFFERLENGTH] === 0 || n === 0 || (n && n > this[BUFFERLENGTH]) ) { this[MAYBE_EMIT_END]() return null } if (this[OBJECTMODE]) n = null if (this[BUFFER].length > 1 && !this[OBJECTMODE]) { // not object mode, so if we have an encoding, then RType is string // otherwise, must be Buffer this[BUFFER] = [ (this[ENCODING] ? this[BUFFER].join('') : Buffer.concat( this[BUFFER] as Buffer[], this[BUFFERLENGTH] )) as RType, ] } const ret = this[READ](n || null, this[BUFFER][0] as RType) this[MAYBE_EMIT_END]() return ret } [READ](n: number | null, chunk: RType) { if (this[OBJECTMODE]) this[BUFFERSHIFT]() else { const c = chunk as Minipass.BufferOrString if (n === c.length || n === null) this[BUFFERSHIFT]() else if (typeof c === 'string') { this[BUFFER][0] = c.slice(n) as RType chunk = c.slice(0, n) as RType this[BUFFERLENGTH] -= n } else { this[BUFFER][0] = c.subarray(n) as RType chunk = c.subarray(0, n) as RType this[BUFFERLENGTH] -= n } } this.emit('data', chunk) if (!this[BUFFER].length && !this[EOF]) this.emit('drain') return chunk } /** * End the stream, optionally providing a final write. * * See {@link Minipass#write} for argument descriptions */ end(cb?: () => void): this end(chunk: WType, cb?: () => void): this end(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): this end( chunk?: WType | (() => void), encoding?: Minipass.Encoding | (() => void), cb?: () => void ): this { if (typeof chunk === 'function') { cb = chunk as () => void chunk = undefined } if (typeof encoding === 'function') { cb = encoding encoding = 'utf8' } if (chunk !== undefined) 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 if (!this[DATALISTENERS] && !this[PIPES].length) { this[DISCARDED] = true } 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 the stream if it is currently in a paused state * * If called when there are no pipe destinations or `data` event listeners, * this will place the stream in a "discarded" state, where all data will * be thrown away. The discarded state is removed if a pipe destination or * data handler is added, if pause() is called, or if any synchronous or * asynchronous iteration is started. */ resume() { return this[RESUME]() } /** * Pause the stream */ pause() { this[FLOWING] = false this[PAUSED] = true this[DISCARDED] = false } /** * true if the stream has been forcibly destroyed */ get destroyed() { return this[DESTROYED] } /** * true if the stream is currently in a flowing state, meaning that * any writes will be immediately emitted. */ get flowing() { return this[FLOWING] } /** * true if the stream is currently in a paused state */ get paused() { return this[PAUSED] } [BUFFERPUSH](chunk: RType) { if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1 else this[BUFFERLENGTH] += (chunk as Minipass.BufferOrString).length this[BUFFER].push(chunk) } [BUFFERSHIFT](): RType { if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1 else this[BUFFERLENGTH] -= ( this[BUFFER][0] as Minipass.BufferOrString ).length return this[BUFFER].shift() as RType } [FLUSH](noDrain: boolean = false) { do {} while ( this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length ) if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit('drain') } [FLUSHCHUNK](chunk: RType) { this.emit('data', chunk) return this[FLOWING] } /** * Pipe all data emitted by this stream into the destination provided. * * Triggers the flow of data. */ pipe(dest: W, opts?: PipeOptions): W { if (this[DESTROYED]) return dest this[DISCARDED] = false 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 { // "as" here just ignores the WType, which pipes don't care about, // since they're only consuming from us, and writing to the dest this[PIPES].push( !opts.proxyErrors ? new Pipe(this as Minipass, dest, opts) : new PipeProxyErrors(this as Minipass, dest, opts) ) if (this[ASYNC]) defer(() => this[RESUME]()) else this[RESUME]() } return dest } /** * Fully unhook a piped destination stream. * * If the destination stream was the only consumer of this stream (ie, * there are no other piped destinations or `'data'` event listeners) * then the flow of data will stop until there is another consumer or * {@link Minipass#resume} is explicitly called. */ unpipe(dest: W) { const p = this[PIPES].find(p => p.dest === dest) if (p) { if (this[PIPES].length === 1) { if (this[FLOWING] && this[DATALISTENERS] === 0) { this[FLOWING] = false } this[PIPES] = [] } else this[PIPES].splice(this[PIPES].indexOf(p), 1) p.unpipe() } } /** * Alias for {@link Minipass#on} */ addListener( ev: Event, handler: (...args: Events[Event]) => any ): this { return this.on(ev, handler) } /** * Mostly identical to `EventEmitter.on`, with the following * behavior differences to prevent data loss and unnecessary hangs: * * - Adding a 'data' event handler will trigger the flow of data * * - Adding a 'readable' event handler when there is data waiting to be read * will cause 'readable' to be emitted immediately. * * - Adding an 'endish' event handler ('end', 'finish', etc.) which has * already passed will cause the event to be emitted immediately and all * handlers removed. * * - Adding an 'error' event handler after an error has been emitted will * cause the event to be re-emitted immediately with the error previously * raised. */ on( ev: Event, handler: (...args: Events[Event]) => any ): this { const ret = super.on( ev as string | symbol, handler as (...a: any[]) => any ) if (ev === 'data') { this[DISCARDED] = false this[DATALISTENERS]++ if (!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]) { const h = handler as (...a: Events['error']) => any if (this[ASYNC]) defer(() => h.call(this, this[EMITTED_ERROR])) else h.call(this, this[EMITTED_ERROR]) } return ret } /** * Alias for {@link Minipass#off} */ removeListener( ev: Event, handler: (...args: Events[Event]) => any ) { return this.off(ev, handler) } /** * Mostly identical to `EventEmitter.off` * * If a 'data' event handler is removed, and it was the last consumer * (ie, there are no pipe destinations or other 'data' event listeners), * then the flow of data will stop until there is another consumer or * {@link Minipass#resume} is explicitly called. */ off( ev: Event, handler: (...args: Events[Event]) => any ) { const ret = super.off( ev as string | symbol, handler as (...a: any[]) => any ) // if we previously had listeners, and now we don't, and we don't // have any pipes, then stop the flow, unless it's been explicitly // put in a discarded flowing state via stream.resume(). if (ev === 'data') { this[DATALISTENERS] = this.listeners('data').length if ( this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length ) { this[FLOWING] = false } } return ret } /** * Mostly identical to `EventEmitter.removeAllListeners` * * If all 'data' event handlers are removed, and they were the last consumer * (ie, there are no pipe destinations), then the flow of data will stop * until there is another consumer or {@link Minipass#resume} is explicitly * called. */ removeAllListeners(ev?: Event) { const ret = super.removeAllListeners(ev as string | symbol | undefined) if (ev === 'data' || ev === undefined) { this[DATALISTENERS] = 0 if (!this[DISCARDED] && !this[PIPES].length) { this[FLOWING] = false } } return ret } /** * true if the 'end' event has been emitted */ 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 } } /** * Mostly identical to `EventEmitter.emit`, with the following * behavior differences to prevent data loss and unnecessary hangs: * * If the stream has been destroyed, and the event is something other * than 'close' or 'error', then `false` is returned and no handlers * are called. * * If the event is 'end', and has already been emitted, then the event * is ignored. If the stream is in a paused or non-flowing state, then * the event will be deferred until data flow resumes. If the stream is * async, then handlers will be called on the next tick rather than * immediately. * * If the event is 'close', and 'end' has not yet been emitted, then * the event will be deferred until after 'end' is emitted. * * If the event is 'error', and an AbortSignal was provided for the stream, * and there are no listeners, then the event is ignored, matching the * behavior of node core streams in the presense of an AbortSignal. * * If the event is 'finish' or 'prefinish', then all listeners will be * removed after emitting the event, to prevent double-firing. */ emit( ev: Event, ...args: Events[Event] ): boolean { const data = args[0] // error and close are only events allowed after calling destroy() if ( ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED] ) { return false } else if (ev === 'data') { return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data as RType)), true) : this[EMITDATA](data as RType) } 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 false 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 as string, ...args) this[MAYBE_EMIT_END]() return ret } [EMITDATA](data: RType) { for (const p of this[PIPES]) { if (p.dest.write(data as RType) === false) this.pause() } const ret = this[DISCARDED] ? false : super.emit('data', data) this[MAYBE_EMIT_END]() return ret } [EMITEND]() { if (this[EMITTED_END]) return false this[EMITTED_END] = true this.readable = false return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]() } [EMITEND2]() { if (this[DECODER]) { const data = this[DECODER].end() if (data) { for (const p of this[PIPES]) { p.dest.write(data as RType) } if (!this[DISCARDED]) super.emit('data', data) } } for (const p of this[PIPES]) { p.end() } const ret = super.emit('end') this.removeAllListeners('end') return ret } /** * Return a Promise that resolves to an array of all emitted data once * the stream ends. */ async collect(): Promise { const buf: RType[] & { dataLength: number } = Object.assign([], { dataLength: 0, }) 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 as Minipass.BufferOrString).length }) await p return buf } /** * Return a Promise that resolves to the concatenation of all emitted data * once the stream ends. * * Not allowed on objectMode streams. */ async concat(): Promise { if (this[OBJECTMODE]) { throw new Error('cannot concat in objectMode') } const buf = await this.collect() return ( this[ENCODING] ? buf.join('') : Buffer.concat(buf as Buffer[], buf.dataLength) ) as RType } /** * Return a void Promise that resolves once the stream ends. */ async promise(): Promise { return new Promise((resolve, reject) => { this.on(DESTROYED, () => reject(new Error('stream destroyed'))) this.on('error', er => reject(er)) this.on('end', () => resolve()) }) } /** * Asynchronous `for await of` iteration. * * This will continue emitting all chunks until the stream terminates. */ [Symbol.asyncIterator](): AsyncGenerator { // set this up front, in case the consumer doesn't call next() // right away. this[DISCARDED] = false let stopped = false const stop = async (): Promise> => { this.pause() stopped = true return { value: undefined, done: true } } const next = (): Promise> => { 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!: (res: IteratorResult) => void let reject!: (er: unknown) => void const onerr = (er: unknown) => { this.off('data', ondata) this.off('end', onend) this.off(DESTROYED, ondestroy) stop() reject(er) } const ondata = (value: RType) => { this.off('error', onerr) this.off('end', onend) this.off(DESTROYED, ondestroy) this.pause() resolve({ value, done: !!this[EOF] }) } const onend = () => { this.off('error', onerr) this.off('data', ondata) this.off(DESTROYED, ondestroy) stop() resolve({ done: true, value: undefined }) } 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, [Symbol.asyncIterator]() { return this }, [Symbol.asyncDispose]: async () => {}, } } /** * Synchronous `for of` iteration. * * The iteration will terminate when the internal buffer runs out, even * if the stream has not yet terminated. */ [Symbol.iterator](): Generator { // set this up front, in case the consumer doesn't call next() // right away. this[DISCARDED] = false let stopped = false const stop = (): IteratorReturnResult => { this.pause() this.off(ERROR, stop) this.off(DESTROYED, stop) this.off('end', stop) stopped = true return { done: true, value: undefined } } const next = (): IteratorResult => { if (stopped) return stop() const value = this.read() return value === null ? stop() : { done: false, value } } this.once('end', stop) this.once(ERROR, stop) this.once(DESTROYED, stop) return { next, throw: stop, return: stop, [Symbol.iterator]() { return this }, [Symbol.dispose]: () => {}, } } /** * Destroy a stream, preventing it from being used for any further purpose. * * If the stream has a `close()` method, then it will be called on * destruction. * * After destruction, any attempt to write data, read data, or emit most * events will be ignored. * * If an error argument is provided, then it will be emitted in an * 'error' event. */ destroy(er?: unknown) { if (this[DESTROYED]) { if (er) this.emit('error', er) else this.emit(DESTROYED) return this } this[DESTROYED] = true this[DISCARDED] = true // throw away all buffered data, it's never coming out this[BUFFER].length = 0 this[BUFFERLENGTH] = 0 const wc = this as Minipass & { close?: () => void } if (typeof wc.close === 'function' && !this[CLOSED]) wc.close() if (er) this.emit('error', er) // if no error to emit, still reject pending promises else this.emit(DESTROYED) return this } /** * Alias for {@link isStream} * * Former export location, maintained for backwards compatibility. * * @deprecated */ static get isStream() { return isStream } } isaacs-minipass-90fd647/tap-snapshots/000077500000000000000000000000001514545521100177525ustar00rootroot00000000000000isaacs-minipass-90fd647/tap-snapshots/test/000077500000000000000000000000001514545521100207315ustar00rootroot00000000000000isaacs-minipass-90fd647/tap-snapshots/test/basic.ts.test.cjs000066400000000000000000000007061514545521100241210ustar00rootroot00000000000000/* 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.ts > TAP > objectMode allows falsey values for data > must match snapshot 1`] = ` Array [ "", null, undefined, 0, NaN, Array [], ] ` isaacs-minipass-90fd647/test/000077500000000000000000000000001514545521100161255ustar00rootroot00000000000000isaacs-minipass-90fd647/test/abort.ts000066400000000000000000000032241514545521100176050ustar00rootroot00000000000000import { Minipass as MM } from '../src/index.js' import t from '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) //@ts-expect-error 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) //@ts-expect-error 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-90fd647/test/array-buffers.ts000066400000000000000000000035261514545521100212530ustar00rootroot00000000000000import t from 'tap' const stringToArrayBuffer = (s: string) => { 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] as number } return ab } import { Minipass as MP } from '../src/index.js' const e = { encoding: 'utf8' } as const t.test('write array buffer', async t => { const ab = stringToArrayBuffer('hello world') const mp = new MP(e).end(ab) t.equal(mp.objectMode, false, 'array buffer does not trigger objectMode') const s = await mp.concat() t.equal(s, 'hello world') }) t.test('write uint8 typed array', async 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') const s = await mp.concat() t.equal(s, 'hello') }) import { runInNewContext } from 'vm' const { ArrayBuffer: VMArrayBuffer, Uint8Array: VMUint8Array } = runInNewContext('({ArrayBuffer,Uint8Array})') const stringToVMArrayBuffer = (s: string) => { 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', async t => { const ab = stringToVMArrayBuffer('hello world') const mp = new MP(e).end(ab) t.equal(mp.objectMode, false, 'array buffer does not trigger objectMode') const s = await mp.concat() t.equal(s, 'hello world') }) t.test('write uint8 typed array', async 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') const s = await mp.concat() t.equal(s, 'hello') }) isaacs-minipass-90fd647/test/async-duplicate-end.ts000066400000000000000000000006141514545521100223270ustar00rootroot00000000000000import { Minipass } from '../src/index.js' import t from '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++ d.end = Minipass.prototype.end return d.end() } m.pipe(d) m.end() m.end() m.end() setTimeout(() => { t.equal(ended, 1) t.end() }) }) isaacs-minipass-90fd647/test/async-stream.ts000066400000000000000000000045641514545521100211140ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test('pipe', async 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() const result = await Promise.all([d1.concat(), d2.concat()]) t.strictSame(result, ['hello, world', 'hello, world']) }) t.test('pipe split', async t => { const m = new MP({ encoding: 'utf8' }) t.equal(m.async, false) m.async = true t.equal(m.async, true) //@ts-expect-error 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() }) const result = await Promise.all([d1.concat(), d2.concat()]) t.strictSame(result, ['hello, world', 'hello, world']) }) t.test('data event', async t => { const m = new MP({ encoding: 'utf8', async: true }) const d1 = new MP({ encoding: 'utf8' }) const out1: string[] = [] m.on('data', c => out1.push(c)) m.write('hello, ') const out2: string[] = [] m.on('data', c => out2.push(c)) m.pipe(d1) m.end('world!') const res = await d1.concat() t.equal(res, 'hello, world!') t.equal(out1.join(''), 'hello, world!') t.equal(out2.join(''), 'hello, world!') }) t.test('data event split', async t => { const m = new MP({ encoding: 'utf8', async: true }) const d1 = new MP({ encoding: 'utf8' }) const out1: string[] = [] m.on('data', c => out1.push(c)) m.write('hello, ') const out2: string[] = [] m.on('data', c => out2.push(c)) m.pipe(d1) setTimeout(() => m.end('world!')) const res = await d1.concat() 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-90fd647/test/auto-end-deferred-when-paused.ts000066400000000000000000000005231514545521100242050ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test('do not auto-end empty stream if explicitly paused', async t => { const mp = new MP() let waitedForEnd = false mp.pause() setTimeout(() => { waitedForEnd = true mp.resume() }) await mp.end().promise() t.ok(waitedForEnd, 'waited for end') }) isaacs-minipass-90fd647/test/basic.ts000066400000000000000000000352271514545521100175670ustar00rootroot00000000000000import { spawn } from 'child_process' import eos from 'end-of-stream' import EE from 'events' import { unlinkSync, writeFileSync } from 'fs' import t from 'tap' import { fileURLToPath } from 'url' import { Minipass } from '../src/index.js' t.test('some basic piping and writing', async t => { let mp = new Minipass({ encoding: 'base64', //@ts-expect-error debugExposeBuffer: true, }) t.notOk(mp.flowing) t.equal(mp.encoding, 'base64') t.throws(() => (mp.encoding = null), { message: 'Encoding must be set at instantiation time', }) t.throws(() => mp.setEncoding(null), { message: 'Encoding must be set at instantiation time', }) t.equal(mp.readable, true) t.equal(mp.writable, true) t.equal(mp.write('hello'), false) //@ts-expect-error let dest = new Minipass({ debugExposeBuffer: true }) let sawDestData = false dest.on('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.flowing, true, 'pipe() triggers flowing state') 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') //@ts-expect-error t.equal(dest.buffer.length, 1, '1 item is buffered in dest') //@ts-expect-error t.equal(mp.buffer.length, 1, '1 item buffered in src') dest.resume() //@ts-expect-error t.equal(dest.buffer.length, 0, 'nothing is buffered in dest') //@ts-expect-error 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.subarray(0, 1)) mp.write(butterbuf.subarray(1, 2)) mp.write(butterbuf.subarray(2, 3)) mp.write(butterbuf.subarray(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.subarray(0, 2)) mp.write(butterbuf.subarray(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.subarray(0, 2)) mp.write(butterfly.subarray(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] as string) mp.write(butterfly[1] as string) 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.subarray(0, 1)) mp.write(butterbuf.subarray(1, 2)) mp.write(butterbuf.subarray(2, 3)) mp.write(butterbuf.subarray(3, 4)) t.equal(mp.read(5), null) t.equal(mp.read(0), null) t.same(mp.read(2), butterbuf.subarray(0, 2)) t.same(mp.read(2), butterbuf.subarray(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.equal(sawEnd, 1, 'should not get end event again (handler done)') mp.on('end', () => sawEnd++) t.equal(sawEnd, 2, 'should get end event again for second handler') }) 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 module = JSON.stringify( String(new URL('../dist/esm/index.js', import.meta.url)) ) const file = fileURLToPath(new URL('./prog.js', import.meta.url)) writeFileSync( file, ` import { Minipass as MP } from ${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: string) => (err += c)) child.on( 'close', (code: number | null, signal: NodeJS.Signals | null) => { t.equal(code, 0) t.equal(signal, null) t.equal(err, 'hello') 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({ //@ts-expect-error debugExposeBuffer: true, encoding: 'utf8', }) const chunks: (string | Buffer)[] = [] class SlowStream extends EE { write(chunk: string | Buffer | null) { if (chunk) chunks.push(chunk) setTimeout(() => this.emit('drain')) return false } end() { return this.write(null) } } const ss = new SlowStream() mp.pipe(ss) t.ok(mp.flowing, 'flowing, because piped') t.equal(mp.write('foo'), false, 'write() returns false, backpressure') //@ts-expect-error 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 mp = new Minipass() eos(mp, (er?: Error | null) => { if (er) throw er t.end() }) mp.emit('close') mp.end('foo') mp.resume() }) t.test('bufferLength property', t => { 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('no changing into objectMode mid-stream', t => { const s = new Minipass() const message = 'Non-contiguous data written to non-objectMode stream' const d = [ { ok: 'not really' }, null, 99, true, /patterns everywhere/, Symbol('hello, world'), ] t.plan(d.length) for (const chunk of d) { t.throws( () => { //@ts-expect-error s.write(chunk) }, { message }, { chunk } ) } t.end() }) t.test('objectMode', t => { const mp = new Minipass({ objectMode: true }) t.equal(mp.objectMode, true, 'objectMode getter returns value') t.throws(() => (mp.objectMode = false), { message: 'objectMode must be set at instantiation time', }) const a = { a: 1 } const b = { b: 1 } const out: any[] = [] 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, }) t.equal(mp.encoding, null) const a = { a: 1 } const b = { b: 1 } const out: any[] = [] 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( //@ts-expect-error () => new Minipass({ objectMode: true, encoding: 'utf8' }), new Error('Encoding and objectMode may not be used together') ) ) t.test('end:false', async t => { t.plan(1) const mp = new Minipass({ encoding: 'utf8' }) const d = new Minipass({ encoding: 'utf8' }) d.end = () => { throw 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: any[] = [] 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() }) t.test('partial read string', t => { const mp = new Minipass({ encoding: 'utf8' }) mp.write('Here at Milk Farm, we know one thing\n') mp.write('Milk has calcium\n') mp.write('We pride ourselves on changing the lives and DNA structures\n') mp.write('Of each our our special initiates\n') mp.write('Milk farm has One Mission\n') mp.write('To bring you closer to God through the power of calcium\n') mp.write('Milk has calcium\n') let i = 0 let s = '' let c while ((c = mp.read(++i)) !== null) s += c c = mp.read() t.not(c, null) s += c t.equal( s, `Here at Milk Farm, we know one thing Milk has calcium We pride ourselves on changing the lives and DNA structures Of each our our special initiates Milk farm has One Mission To bring you closer to God through the power of calcium Milk has calcium ` ) t.end() }) t.test('partial read buffer', t => { const mp = new Minipass() mp.write('Here at Milk Farm, we know one thing\n') mp.write('Milk has calcium\n') mp.write('We pride ourselves on changing the lives and DNA structures\n') mp.write('Of each our our special initiates\n') mp.write('Milk farm has One Mission\n') mp.write('To bring you closer to God through the power of calcium\n') mp.write('Milk has calcium\n') let i = 0 const s: Buffer[] = [] let c while ((c = mp.read(++i)) !== null) s.push(c) c = mp.read() t.not(c, null) s.push(c as Buffer) t.equal( Buffer.concat(s).toString(), `Here at Milk Farm, we know one thing Milk has calcium We pride ourselves on changing the lives and DNA structures Of each our our special initiates Milk farm has One Mission To bring you closer to God through the power of calcium Milk has calcium ` ) t.end() }) isaacs-minipass-90fd647/test/buffer-chunk-when-flowing-stops.ts000066400000000000000000000027351514545521100246330ustar00rootroot00000000000000// 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 import t from 'tap' import { Minipass } from '../src/index.js' class Pauser extends Minipass { write( chunk: Minipass.ContiguousData, cb?: (() => void) | undefined ): boolean write( chunk: Minipass.ContiguousData, encoding?: Minipass.Encoding | undefined, cb?: (() => void) | undefined ): boolean write( chunk: Minipass.ContiguousData, encoding?: Minipass.Encoding | (() => void) | undefined, cb?: (() => void) | undefined ): boolean { if (typeof encoding === 'function') super.write(chunk, encoding) else super.write(chunk, encoding, cb) 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-90fd647/test/collect-with-error-end.ts000066400000000000000000000004101514545521100227610ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' const mp = new MP() const poop = new Error('poop') mp.on('end', () => mp.emit('error', poop)) mp.end('foo') t.test('promise catches error emitted on end', t => t.rejects(mp.collect(), poop) ) isaacs-minipass-90fd647/test/collect.ts000066400000000000000000000025121514545521100201220ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test('basic', async t => { const mp = new MP({ encoding: 'utf8' }) let i = 5 const interval = setInterval(() => { if (i-- > 0) mp.write('foo\n') else { clearInterval(interval) mp.end() } }) 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')) }) t.test('collect does not set bodyLength in objectMode', t => new MP({ objectMode: true }) .end({ a: 1 }) .collect() .then(data => { t.equal(data.dataLength, 0) t.same(data, [{ a: 1 }]) }) ) isaacs-minipass-90fd647/test/dest-write-returns-nonboolean.ts000066400000000000000000000023061514545521100244150ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test( 'writing to a non-bool returning write() does not pause', async t => { const booleyStream = new (class extends MP { //@ts-ignore write( chunk: MP.ContiguousData, encoding?: MP.Encoding | (() => void) | undefined, cb?: (() => void) | undefined ): void { // no return! super.write( chunk, typeof encoding === 'function' ? undefined : encoding, typeof encoding === 'function' ? encoding : cb ) } })() const booleyStream2 = new (class extends MP { //@ts-ignore write( chunk: MP.ContiguousData, encoding?: MP.Encoding | (() => void) | undefined, cb?: (() => void) | undefined ): void { // no return! super.write( chunk, typeof encoding === 'function' ? undefined : encoding, typeof encoding === 'function' ? encoding : cb ) } })() const src = new MP() src.end('hello') const d = await src.pipe(booleyStream).pipe(booleyStream2).concat() t.equal(d.toString(), 'hello', 'got data all the way through') } ) isaacs-minipass-90fd647/test/destroy.ts000066400000000000000000000050031514545521100201640ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' 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() as MP & { close(): void } 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', () => 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-90fd647/test/emit-during-end-event.ts000066400000000000000000000007251514545521100226100ustar00rootroot00000000000000import t from 'tap' import { Minipass } from '../src/index.js' class FancyEnder extends Minipass { emit>( ev: Event, ...args: Minipass.Events[Event] ): boolean { if (ev === 'end') this.emit('foo') return super.emit(ev, ...args) } } 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-90fd647/test/empty-buffer-end-with-encoding.ts000066400000000000000000000021541514545521100244050ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' const enc = { encoding: 'utf8' } as const 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', async t => { const mp = new MP(enc) mp.write('ok') const s = await mp.end(Buffer.alloc(0)).concat() t.equal(s, 'ok') }) t.test('encoding and write then end with empty string', async t => { const mp = new MP(enc) mp.write('ok') const s = await mp.end('').concat() t.equal(s, 'ok') }) t.test('empty write with cb', t => new MP(enc).write(Buffer.from(''), t.end) ) isaacs-minipass-90fd647/test/empty-stream-emits-end-without-read.ts000066400000000000000000000002261514545521100254210ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test('empty end emits end without reading', () => new MP().end().promise() ) isaacs-minipass-90fd647/test/end-missed.ts000066400000000000000000000014221514545521100205240ustar00rootroot00000000000000'use strict' import t from 'tap' import { Minipass as MP } from '../src/index.js' 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-90fd647/test/end-returns-this.ts000066400000000000000000000002031514545521100217030ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' const mp = new MP() t.equal(mp.end(), mp, 'end returns this') isaacs-minipass-90fd647/test/end-twice.ts000066400000000000000000000017321514545521100203570ustar00rootroot00000000000000'use strict' import t from 'tap' import { Minipass as MP } from '../src/index.js' 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.subarray(3)) }) mp.end(butterfly.subarray(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-90fd647/test/error-before-promise.ts000066400000000000000000000030571514545521100225470ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' 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) } }) as MP['emit'] 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-90fd647/test/esm.mjs000066400000000000000000000004431514545521100174250ustar00rootroot00000000000000import { Minipass } from '../dist/esm/index.js' 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-90fd647/test/flowing-after-removing-consumers.ts000066400000000000000000000040221514545521100250770ustar00rootroot00000000000000import t from 'tap' import { Minipass } from '../src/index.js' t.test('removing last data listener stops data flow', t => { const s = new Minipass() t.equal(s.flowing, false) const h = () => {} s.on('data', h) t.equal(s.flowing, true) s.off('data', h) t.equal(s.flowing, false) s.on('data', h) t.equal(s.flowing, true) s.removeAllListeners('data') t.equal(s.flowing, false) s.on('data', h) t.equal(s.flowing, true) s.removeAllListeners() t.equal(s.flowing, false) t.end() }) t.test('discarding works, undiscards on pipe or listener', t => { const s = new Minipass() s.resume() t.equal(s.flowing, true) s.pause() t.equal(s.flowing, false) s.resume() t.equal(s.flowing, true) const d = new Minipass() s.pipe(d) t.equal(s.flowing, true) t.equal(s.write('x'), false) t.equal(s.flowing, false) s.unpipe(d) t.equal(s.flowing, false) s.resume() t.equal(s.flowing, true) s.on('data', () => {}) t.equal(s.flowing, true) s.resume() s.removeAllListeners('data') t.equal(s.flowing, false) t.end() }) t.test('unpipe triggers a stop to the flow if it was the only dest', t => { const src = new Minipass({ encoding: 'utf8' }) const dest = new Minipass({ encoding: 'utf8' }) dest.resume() src.write('hello') t.equal(src.flowing, false) src.pipe(dest) t.equal(src.flowing, true) t.equal(src.read(), null) src.unpipe(dest) t.equal(src.flowing, false) src.write('second write') t.equal(src.read(), 'second write') t.end() }) t.test('flowing continues if there is a data listener', t => { const src = new Minipass({ encoding: 'utf8' }) const dest = new Minipass({ encoding: 'utf8' }) const d: string[] = [] src.on('data', c => d.push(c)) dest.resume() src.write('hello') t.equal(src.flowing, true) src.pipe(dest) t.equal(src.flowing, true) t.equal(src.read(), null) src.unpipe(dest) t.equal(src.flowing, true) src.write('second write') t.equal(src.read(), null) t.strictSame(d, ['hello', 'second write']) t.end() }) isaacs-minipass-90fd647/test/flush-buffer-before-flowing.ts000066400000000000000000000033611514545521100237730ustar00rootroot00000000000000// 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. import t from 'tap' import { Minipass } from '../src/index.js' const src = new Minipass({ encoding: 'utf8' }) const mid = new Minipass({ encoding: 'utf8' }) const proxy = new Minipass({ encoding: 'utf8' }) mid.write = function (this: Minipass, chunk, encoding, cb) { Minipass.prototype.write.call(this, chunk, encoding, cb) return proxy.write(chunk, encoding, cb) } as Minipass['write'] proxy.on('drain', () => 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: Minipass.EncodingOptions) { super(opt) dest.on('data', c => super.write(c)) dest.on('end', () => super.end()) } emit>( ev: Event, ...args: Minipass.Events[Event] ): boolean { 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-90fd647/test/is-stream.ts000066400000000000000000000077601514545521100204130ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP, isStream, isReadable, isWritable } from '../src/index.js' import Stream from 'stream' import EE from 'events' t.equal(MP.isStream, isStream, 'old export location is same function') t.equal(isStream(new MP()), true, 'a MiniPass is a stream') t.equal(isReadable(new MP()), true, 'a MiniPass is a readable') t.equal(isWritable(new MP()), true, 'a MiniPass is a writable') t.equal(isStream(new Stream()), true, 'a Stream is a stream') t.equal(isReadable(new Stream()), true, 'a Stream is a readable') t.equal(isWritable(new Stream()), false, 'a Stream is not a writable') const w = new EE() as EE & { write(): any, end(): any } w.write = () => {} w.end = () => {} t.equal(isStream(w), true, 'EE with write() and end() is a stream') t.equal(isWritable(w), true, 'EE with write() and end() is a writable') t.equal( isReadable(w), false, 'EE with write() and end() is not a readable' ) const r = new EE() as EE & { pipe(): any } r.pipe = () => {} t.equal(isStream(r), true, 'EE with pipe() is a stream') t.equal(isWritable(r), false, 'EE with pipe() is not a writable') t.equal(isReadable(r), true, 'EE with pipe() is a readable') t.equal( isStream(new Stream.Readable()), true, 'Stream.Readable() is a stream' ) t.equal( isReadable(new Stream.Readable()), true, 'Stream.Readable() is a readable' ) t.equal( isWritable(new Stream.Readable()), false, 'Stream.Readable() is not a writable' ) t.equal( isStream(new Stream.Writable()), true, 'Stream.Writable() is a stream' ) t.equal( isWritable(new Stream.Writable()), true, 'Stream.Writable() is a writable' ) t.equal( isReadable(new Stream.Writable()), false, 'Stream.Writable() is not a readable' ) t.equal(isStream(new Stream.Duplex()), true, 'Stream.Duplex() is a stream') t.equal( isReadable(new Stream.Duplex()), true, 'Stream.Duplex() is a readable' ) t.equal( isWritable(new Stream.Duplex()), true, 'Stream.Duplex() is a writable' ) t.equal( isStream(new Stream.Transform()), true, 'Stream.Transform() is a stream' ) t.equal( isReadable(new Stream.Transform()), true, 'Stream.Transform() is a readable' ) t.equal( isWritable(new Stream.Transform()), true, 'Stream.Transform() is a writable' ) t.equal( isStream(new Stream.PassThrough()), true, 'Stream.PassThrough() is a stream' ) t.equal( isReadable(new Stream.PassThrough()), true, 'Stream.PassThrough() is a readable' ) t.equal( isWritable(new Stream.PassThrough()), true, 'Stream.PassThrough() is a writable' ) t.equal( isStream(new (class extends MP {})()), true, 'extends MP is a stream' ) t.equal( isReadable(new (class extends MP {})()), true, 'extends MP is a readable' ) t.equal( isWritable(new (class extends MP {})()), true, 'extends MP is a writable' ) t.equal( isStream(new EE()), false, 'EE without streaminess is not a stream' ) t.equal( isReadable(new EE()), false, 'EE without streaminess is not a readable' ) t.equal( isWritable(new EE()), false, 'EE without streaminess is not a writable' ) const ns = { write() {}, end() {}, pipe() {}, } t.equal(isStream(ns), false, 'non-EE is not a stream') t.equal(isReadable(ns), false, 'non-EE is not a readable') t.equal(isWritable(ns), false, 'non-EE is not a writable') t.equal(isStream('hello'), false, 'string is not a stream') t.equal(isReadable('hello'), false, 'string is not a readable') t.equal(isWritable('hello'), false, 'string is not a writable') t.equal(isStream(99), false, 'number is not a stream') t.equal(isReadable(99), false, 'number is not a readable') t.equal(isReadable(99), false, 'number is not a writable') t.equal( isStream(() => {}), false, 'function is not a stream' ) t.equal( isReadable(() => {}), false, 'function is not a readable' ) t.equal( isWritable(() => {}), false, 'function is not a writable' ) t.equal(isStream(null), false, 'null is not a stream') t.equal(isReadable(null), false, 'null is not a readable') t.equal(isWritable(null), false, 'null is not a writable') isaacs-minipass-90fd647/test/iterate-max-listener-test.ts000066400000000000000000000033361514545521100235220ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' // make warnings throw Object.defineProperty(process, 'emitWarning', { value: (...args: any[]) => { throw new Error('got warning: ' + args.join(', ')) } }) // create a stream that emits a bunch of things in chunks const chunks: string[] = [] for (let i = 0; i < 10000; i++) { chunks.push(String(i)) } class EmitterStream extends MP { i: number p: Promise resolve!: () => void interval: any 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++] as string) } 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: string[] = [] 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-90fd647/test/iteration.ts000066400000000000000000000161121514545521100204740ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' t.test('sync iteration', t => { const runTest = < O extends undefined | MP.EncodingOptions | MP.ObjectModeOptions >( c: 'buffer' | 'object' | 'string', opt: O, expect: Buffer[] | string[] ) => { t.test(c, t => { const result = [] const mp = new MP( opt as unknown as MP.ObjectModeOptions ) 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() }) } runTest('buffer', undefined, [ Buffer.from('ab'), Buffer.from('cd'), Buffer.from('e'), ]) runTest('string', { encoding: 'utf8' }, ['ab', 'cd', 'e']) runTest('object', { objectMode: true }, ['a', 'b', 'c', 'd', 'e']) 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'), { value: undefined, done: true }) t.same( await ait.next(), { value: undefined, done: true }, 'stopped by throw' ) }) isaacs-minipass-90fd647/test/no-process-ok.ts000066400000000000000000000005321514545521100211740ustar00rootroot00000000000000import t from 'tap' t.test('run without a process global', async t => { t.intercept(global, 'process', { value: null }) const { Minipass: MP } = await import('../src/index.js') const src = new MP() const dest = new MP({ encoding: 'utf8' }) src.pipe(dest) src.end('ok') const result = dest.read() t.equal(result, 'ok') }) isaacs-minipass-90fd647/test/pipe-ended-stream.ts000066400000000000000000000013361514545521100220030ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' 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', async () => { const from = new MP() await from.end().promise() await 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-90fd647/test/pipe-stdio-end-false.ts000066400000000000000000000014261514545521100224110ustar00rootroot00000000000000import t from 'tap' import type { Minipass } from '../src/index.js' t.test('pipe to stdout', async t => { const proc: { stdout?: Minipass, stderr?: Minipass } = {} t.intercept(global, 'process', { value: proc }) const { Minipass } = await t.mockImport('../src/index.js') as typeof import('../src/index.js') proc.stdout = new Minipass({ encoding: 'utf8' }) proc.stdout.on('end', () => { throw new Error('stdout should not end') }) proc.stderr = new Minipass({ encoding: 'utf8' }) proc.stderr.on('end', () => { throw new Error('stderr should not end') }) const src = new Minipass({encoding:'utf8'}) src.pipe(proc.stdout) src.pipe(proc.stderr) src.end('hello, stdio') await new Promise(r => setTimeout(r)) }) isaacs-minipass-90fd647/test/proxy-errors.ts000066400000000000000000000032301514545521100211660ustar00rootroot00000000000000import t from 'tap' import { Minipass } from '../src/index.js' 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-90fd647/test/readable-emits-immediately.ts000066400000000000000000000006021514545521100236520ustar00rootroot00000000000000// https://github.com/isaacs/minipass/issues/36 import t from 'tap' import { Minipass } from '../src/index.js' 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-90fd647/test/readable-only-when-buffering.ts000066400000000000000000000004641514545521100241230ustar00rootroot00000000000000import t from 'tap' import { Minipass as MP } from '../src/index.js' const mp = new MP() let readables = 0 mp.on('readable', () => readables++) const ondata = () => {} 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-90fd647/test/unpipe.ts000066400000000000000000000021461514545521100200000ustar00rootroot00000000000000import t from 'tap' import { Minipass } from '../src/index.js' const dest = new Minipass({ encoding: 'utf8' }) const dest2 = new Minipass({ encoding: 'utf8' }) const destOut: string[] = [] const dest2Out: string[] = [] const srcOut: string[] = [] const src = new Minipass({ encoding: 'utf8', //@ts-expect-error debugExposePipes: true, }) as Minipass 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']) //@ts-expect-error t.match(src.pipes, [{ dest }, { dest: dest2 }]) src.unpipe(dest) //@ts-expect-error t.match(src.pipes, [{ dest: dest2 }]) src.unpipe(dest) // no-op //@ts-expect-error 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-90fd647/test/writable-type-check.ts000066400000000000000000000014611514545521100223420ustar00rootroot00000000000000import { Minipass } from '../src/index.js' let tester: NodeJS.WritableStream tester = new Minipass() tester = new Minipass() tester = new Minipass() tester = new Minipass() tester = new Minipass({ encoding: 'hex' }) tester = new Minipass({ encoding: 'hex' }) tester = new Minipass() // We expect this one to be an error, because the NodeJS.WritableStream // does not allow objectMode streams, so it would be a problem to use an // OM minipass in contexts where a NodeJS.WritableStream is expected. //@ts-expect-error tester = new Minipass<{ a: 1 }>({ objectMode: true }) // so the linter doesn't complain about unused variable tester import { pass } from 'tap' pass(`just making sure TS doesn't complain`) isaacs-minipass-90fd647/test/write-returns-true-when-readable-triggers-flow.ts000066400000000000000000000030721514545521100275730ustar00rootroot00000000000000// 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. import t from 'tap' import { Minipass } from '../src/index.js' 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-90fd647/tsconfig.json000066400000000000000000000006551514545521100176630ustar00rootroot00000000000000{ "compilerOptions": { "declaration": true, "declarationMap": true, "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "inlineSources": true, "jsx": "react", "module": "nodenext", "moduleResolution": "nodenext", "noUncheckedIndexedAccess": true, "resolveJsonModule": true, "skipLibCheck": true, "sourceMap": true, "strict": true, "target": "es2022" } } isaacs-minipass-90fd647/typedoc.json000066400000000000000000000002061514545521100175060ustar00rootroot00000000000000{ "navigationLinks": { "GitHub": "https://github.com/isaacs/minipass", "isaacs projects": "https://isaacs.github.io/" } }