diff --git a/mock-registry/package.json b/mock-registry/package.json
index 80dc35423c46..f23a2dcfa930 100644
--- a/mock-registry/package.json
+++ b/mock-registry/package.json
@@ -48,8 +48,8 @@
"@npmcli/eslint-config": "^4.0.1",
"@npmcli/template-oss": "4.11.0",
"nock": "^13.2.9",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.6",
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7",
"tap": "^16.3.0"
}
}
diff --git a/node_modules/.gitignore b/node_modules/.gitignore
index de73c53a6771..c8b71252bfa4 100644
--- a/node_modules/.gitignore
+++ b/node_modules/.gitignore
@@ -85,6 +85,9 @@
!/events
!/fastest-levenshtein
!/fs-minipass
+!/fs-minipass/node_modules/
+/fs-minipass/node_modules/*
+!/fs-minipass/node_modules/minipass
!/fs.realpath
!/function-bind
!/gauge
@@ -135,13 +138,34 @@
!/make-fetch-happen
!/minimatch
!/minipass-collect
+!/minipass-collect/node_modules/
+/minipass-collect/node_modules/*
+!/minipass-collect/node_modules/minipass
!/minipass-fetch
+!/minipass-fetch/node_modules/
+/minipass-fetch/node_modules/*
+!/minipass-fetch/node_modules/minipass
!/minipass-flush
+!/minipass-flush/node_modules/
+/minipass-flush/node_modules/*
+!/minipass-flush/node_modules/minipass
!/minipass-json-stream
+!/minipass-json-stream/node_modules/
+/minipass-json-stream/node_modules/*
+!/minipass-json-stream/node_modules/minipass
!/minipass-pipeline
+!/minipass-pipeline/node_modules/
+/minipass-pipeline/node_modules/*
+!/minipass-pipeline/node_modules/minipass
!/minipass-sized
+!/minipass-sized/node_modules/
+/minipass-sized/node_modules/*
+!/minipass-sized/node_modules/minipass
!/minipass
!/minizlib
+!/minizlib/node_modules/
+/minizlib/node_modules/*
+!/minizlib/node_modules/minipass
!/mkdirp
!/ms
!/mute-stream
@@ -167,6 +191,7 @@
!/node-gyp/node_modules/make-fetch-happen
!/node-gyp/node_modules/minimatch
!/node-gyp/node_modules/minipass-fetch
+!/node-gyp/node_modules/minipass
!/node-gyp/node_modules/nopt
!/node-gyp/node_modules/npmlog
!/node-gyp/node_modules/ssri
diff --git a/node_modules/cacache/package.json b/node_modules/cacache/package.json
index db6778ed4c03..6ab0d2a9dd8a 100644
--- a/node_modules/cacache/package.json
+++ b/node_modules/cacache/package.json
@@ -1,6 +1,6 @@
{
"name": "cacache",
- "version": "17.0.2",
+ "version": "17.0.3",
"cache-version": {
"content": "2",
"index": "5"
@@ -49,7 +49,7 @@
"fs-minipass": "^2.1.0",
"glob": "^8.0.1",
"lru-cache": "^7.7.1",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-collect": "^1.0.2",
"minipass-flush": "^1.0.5",
"minipass-pipeline": "^1.2.4",
@@ -61,7 +61,7 @@
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.8.0",
+ "@npmcli/template-oss": "4.10.0",
"tap": "^16.0.0"
},
"engines": {
@@ -70,7 +70,7 @@
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
"windowsCI": false,
- "version": "4.8.0"
+ "version": "4.10.0"
},
"author": "GitHub Inc.",
"tap": {
diff --git a/node_modules/fs-minipass/node_modules/minipass/LICENSE b/node_modules/fs-minipass/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/fs-minipass/node_modules/minipass/index.d.ts b/node_modules/fs-minipass/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/fs-minipass/node_modules/minipass/index.js b/node_modules/fs-minipass/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/fs-minipass/node_modules/minipass/package.json b/node_modules/fs-minipass/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/make-fetch-happen/package.json b/node_modules/make-fetch-happen/package.json
index 656349a92563..1690c932f75c 100644
--- a/node_modules/make-fetch-happen/package.json
+++ b/node_modules/make-fetch-happen/package.json
@@ -1,6 +1,6 @@
{
"name": "make-fetch-happen",
- "version": "11.0.1",
+ "version": "11.0.2",
"description": "Opinionated, caching, retrying fetch client",
"main": "lib/index.js",
"files": [
@@ -40,7 +40,7 @@
"https-proxy-agent": "^5.0.0",
"is-lambda": "^1.0.1",
"lru-cache": "^7.7.1",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-collect": "^1.0.2",
"minipass-fetch": "^3.0.0",
"minipass-flush": "^1.0.5",
@@ -52,7 +52,7 @@
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.5.1",
+ "@npmcli/template-oss": "4.10.0",
"mkdirp": "^1.0.4",
"nock": "^13.2.4",
"rimraf": "^3.0.2",
@@ -75,6 +75,6 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.5.1"
+ "version": "4.10.0"
}
}
diff --git a/node_modules/minipass-collect/node_modules/minipass/LICENSE b/node_modules/minipass-collect/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-collect/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-collect/node_modules/minipass/index.d.ts b/node_modules/minipass-collect/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-collect/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-collect/node_modules/minipass/index.js b/node_modules/minipass-collect/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-collect/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-collect/node_modules/minipass/package.json b/node_modules/minipass-collect/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-collect/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass-fetch/node_modules/minipass/LICENSE b/node_modules/minipass-fetch/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-fetch/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-fetch/node_modules/minipass/index.d.ts b/node_modules/minipass-fetch/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-fetch/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-fetch/node_modules/minipass/index.js b/node_modules/minipass-fetch/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-fetch/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-fetch/node_modules/minipass/package.json b/node_modules/minipass-fetch/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-fetch/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass-flush/node_modules/minipass/LICENSE b/node_modules/minipass-flush/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-flush/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-flush/node_modules/minipass/index.d.ts b/node_modules/minipass-flush/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-flush/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-flush/node_modules/minipass/index.js b/node_modules/minipass-flush/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-flush/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-flush/node_modules/minipass/package.json b/node_modules/minipass-flush/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-flush/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass-json-stream/node_modules/minipass/LICENSE b/node_modules/minipass-json-stream/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-json-stream/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-json-stream/node_modules/minipass/index.d.ts b/node_modules/minipass-json-stream/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-json-stream/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-json-stream/node_modules/minipass/index.js b/node_modules/minipass-json-stream/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-json-stream/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-json-stream/node_modules/minipass/package.json b/node_modules/minipass-json-stream/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-json-stream/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass-pipeline/node_modules/minipass/LICENSE b/node_modules/minipass-pipeline/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-pipeline/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-pipeline/node_modules/minipass/index.d.ts b/node_modules/minipass-pipeline/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-pipeline/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-pipeline/node_modules/minipass/index.js b/node_modules/minipass-pipeline/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-pipeline/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-pipeline/node_modules/minipass/package.json b/node_modules/minipass-pipeline/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-pipeline/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass-sized/node_modules/minipass/LICENSE b/node_modules/minipass-sized/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minipass-sized/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minipass-sized/node_modules/minipass/index.d.ts b/node_modules/minipass-sized/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minipass-sized/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minipass-sized/node_modules/minipass/index.js b/node_modules/minipass-sized/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minipass-sized/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minipass-sized/node_modules/minipass/package.json b/node_modules/minipass-sized/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minipass-sized/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/minipass/index.d.ts b/node_modules/minipass/index.d.ts
index edbef5482480..f68ce8a259c4 100644
--- a/node_modules/minipass/index.d.ts
+++ b/node_modules/minipass/index.d.ts
@@ -1,40 +1,70 @@
///
+
+// Note: marking anything protected or private in the exported
+// class will limit Minipass's ability to be used as the base
+// for mixin classes.
import { EventEmitter } from 'events'
import { Stream } from 'stream'
-export type Encoding = BufferEncoding | 'buffer' | null
-
-interface Writable extends EventEmitter {
- end(): any
- write(chunk: any, ...args: any[]): any
-}
-
-interface Readable extends EventEmitter {
- pause(): any
- resume(): any
- pipe(): any
-}
-
-interface Pipe {
- src: Minipass
- dest: Writable
- opts: PipeOptions
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
}
-type DualIterable = Iterable & AsyncIterable
-
-type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
-
-type BufferOrString = Buffer | string
-
-export default class Minipass<
+declare class Minipass<
RType extends any = Buffer,
- WType extends any = RType extends BufferOrString ? ContiguousData : RType
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
>
extends Stream
- implements DualIterable
+ implements Minipass.DualIterable
{
- static isStream(stream: any): stream is Readable | Writable
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
readonly bufferLength: number
readonly flowing: boolean
@@ -44,12 +74,6 @@ export default class Minipass<
readonly emittedEnd: boolean
readonly destroyed: boolean
- /**
- * Not technically private or readonly, but not safe to mutate.
- */
- private readonly buffer: RType[]
- private readonly pipes: Pipe[]
-
/**
* Technically writable, but mutating it can change the type,
* so is not safe to do in TypeScript.
@@ -70,31 +94,31 @@ export default class Minipass<
* TypeScript does not provide many options for changing the type of
* an object at run-time, which is what changing the encoding does.
*/
- readonly encoding: Encoding
+ readonly encoding: Minipass.Encoding
// setEncoding(encoding: Encoding): void
// Options required if not reading buffers
constructor(
...args: RType extends Buffer
- ? [] | [Options]
- : [Options]
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
)
write(chunk: WType, cb?: () => void): boolean
- write(chunk: WType, encoding?: Encoding, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
read(size?: number): RType
end(cb?: () => void): this
end(chunk: any, cb?: () => void): this
- end(chunk: any, encoding?: Encoding, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
pause(): void
resume(): void
promise(): Promise
collect(): Promise
- concat(): RType extends BufferOrString ? Promise : never
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
destroy(er?: any): void
- pipe(dest: W, opts?: PipeOptions): W
- unpipe(dest: W): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
/**
* alias for on()
@@ -120,30 +144,4 @@ export default class Minipass<
[Symbol.asyncIterator](): AsyncIterator
}
-interface StringOptions {
- encoding: BufferEncoding
- objectMode?: boolean
- async?: boolean
-}
-
-interface BufferOptions {
- encoding?: null | 'buffer'
- objectMode?: boolean
- async?: boolean
-}
-
-interface ObjectModeOptions {
- objectMode: true
- async?: boolean
-}
-
-export declare interface PipeOptions {
- end?: boolean
- proxyErrors?: boolean
-}
-
-export declare type Options = T extends string
- ? StringOptions
- : T extends Buffer
- ? BufferOptions
- : ObjectModeOptions
+export = Minipass
diff --git a/node_modules/minipass/index.js b/node_modules/minipass/index.js
index e8797aab6cc2..d5003ed9a575 100644
--- a/node_modules/minipass/index.js
+++ b/node_modules/minipass/index.js
@@ -21,6 +21,8 @@ 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')
@@ -94,8 +96,8 @@ module.exports = class Minipass extends Stream {
this[FLOWING] = false
// whether we're explicitly paused
this[PAUSED] = false
- this.pipes = []
- this.buffer = []
+ this[PIPES] = []
+ this[BUFFER] = []
this[OBJECTMODE] = options && options.objectMode || false
if (this[OBJECTMODE])
this[ENCODING] = null
@@ -114,6 +116,12 @@ module.exports = class Minipass extends Stream {
this.readable = true
this[BUFFERLENGTH] = 0
this[DESTROYED] = false
+ if (options && options.debugExposeBuffer === true) {
+ Object.defineProperty(this, 'buffer', { get: () => this[BUFFER] })
+ }
+ if (options && options.debugExposePipes === true) {
+ Object.defineProperty(this, 'pipes', { get: () => this[PIPES] })
+ }
}
get bufferLength () { return this[BUFFERLENGTH] }
@@ -129,8 +137,8 @@ module.exports = class Minipass extends Stream {
if (this[ENCODING] !== enc) {
this[DECODER] = enc ? new SD(enc) : null
- if (this.buffer.length)
- this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ if (this[BUFFER].length)
+ this[BUFFER] = this[BUFFER].map(chunk => this[DECODER].write(chunk))
}
this[ENCODING] = enc
@@ -252,14 +260,14 @@ module.exports = class Minipass extends Stream {
if (this[OBJECTMODE])
n = null
- if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
if (this.encoding)
- this.buffer = [this.buffer.join('')]
+ this[BUFFER] = [this[BUFFER].join('')]
else
- this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ this[BUFFER] = [Buffer.concat(this[BUFFER], this[BUFFERLENGTH])]
}
- const ret = this[READ](n || null, this.buffer[0])
+ const ret = this[READ](n || null, this[BUFFER][0])
this[MAYBE_EMIT_END]()
return ret
}
@@ -268,14 +276,14 @@ module.exports = class Minipass extends Stream {
if (n === chunk.length || n === null)
this[BUFFERSHIFT]()
else {
- this.buffer[0] = chunk.slice(n)
+ this[BUFFER][0] = chunk.slice(n)
chunk = chunk.slice(0, n)
this[BUFFERLENGTH] -= n
}
this.emit('data', chunk)
- if (!this.buffer.length && !this[EOF])
+ if (!this[BUFFER].length && !this[EOF])
this.emit('drain')
return chunk
@@ -310,7 +318,7 @@ module.exports = class Minipass extends Stream {
this[PAUSED] = false
this[FLOWING] = true
this.emit('resume')
- if (this.buffer.length)
+ if (this[BUFFER].length)
this[FLUSH]()
else if (this[EOF])
this[MAYBE_EMIT_END]()
@@ -344,23 +352,23 @@ module.exports = class Minipass extends Stream {
this[BUFFERLENGTH] += 1
else
this[BUFFERLENGTH] += chunk.length
- this.buffer.push(chunk)
+ this[BUFFER].push(chunk)
}
[BUFFERSHIFT] () {
- if (this.buffer.length) {
+ if (this[BUFFER].length) {
if (this[OBJECTMODE])
this[BUFFERLENGTH] -= 1
else
- this[BUFFERLENGTH] -= this.buffer[0].length
+ this[BUFFERLENGTH] -= this[BUFFER][0].length
}
- return this.buffer.shift()
+ return this[BUFFER].shift()
}
[FLUSH] (noDrain) {
do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
- if (!noDrain && !this.buffer.length && !this[EOF])
+ if (!noDrain && !this[BUFFER].length && !this[EOF])
this.emit('drain')
}
@@ -385,7 +393,7 @@ module.exports = class Minipass extends Stream {
if (opts.end)
dest.end()
} else {
- this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts)
: new PipeProxyErrors(this, dest, opts))
if (this[ASYNC])
defer(() => this[RESUME]())
@@ -397,9 +405,9 @@ module.exports = class Minipass extends Stream {
}
unpipe (dest) {
- const p = this.pipes.find(p => p.dest === dest)
+ const p = this[PIPES].find(p => p.dest === dest)
if (p) {
- this.pipes.splice(this.pipes.indexOf(p), 1)
+ this[PIPES].splice(this[PIPES].indexOf(p), 1)
p.unpipe()
}
}
@@ -410,7 +418,7 @@ module.exports = class Minipass extends Stream {
on (ev, fn) {
const ret = super.on(ev, fn)
- if (ev === 'data' && !this.pipes.length && !this.flowing)
+ if (ev === 'data' && !this[PIPES].length && !this.flowing)
this[RESUME]()
else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
super.emit('readable')
@@ -434,7 +442,7 @@ module.exports = class Minipass extends Stream {
if (!this[EMITTING_END] &&
!this[EMITTED_END] &&
!this[DESTROYED] &&
- this.buffer.length === 0 &&
+ this[BUFFER].length === 0 &&
this[EOF]) {
this[EMITTING_END] = true
this.emit('end')
@@ -486,7 +494,7 @@ module.exports = class Minipass extends Stream {
}
[EMITDATA] (data) {
- for (const p of this.pipes) {
+ for (const p of this[PIPES]) {
if (p.dest.write(data) === false)
this.pause()
}
@@ -511,14 +519,14 @@ module.exports = class Minipass extends Stream {
if (this[DECODER]) {
const data = this[DECODER].end()
if (data) {
- for (const p of this.pipes) {
+ for (const p of this[PIPES]) {
p.dest.write(data)
}
super.emit('data', data)
}
}
- for (const p of this.pipes) {
+ for (const p of this[PIPES]) {
p.end()
}
const ret = super.emit('end')
@@ -625,7 +633,7 @@ module.exports = class Minipass extends Stream {
this[DESTROYED] = true
// throw away all buffered data, it's never coming out
- this.buffer.length = 0
+ this[BUFFER].length = 0
this[BUFFERLENGTH] = 0
if (typeof this.close === 'function' && !this[CLOSED])
diff --git a/node_modules/minipass/package.json b/node_modules/minipass/package.json
index 47c90a4fcf4a..ca30e694aa44 100644
--- a/node_modules/minipass/package.json
+++ b/node_modules/minipass/package.json
@@ -1,8 +1,9 @@
{
"name": "minipass",
- "version": "3.3.4",
+ "version": "4.0.0",
"description": "minimal implementation of a PassThrough stream",
"main": "index.js",
+ "types": "index.d.ts",
"dependencies": {
"yallist": "^4.0.0"
},
@@ -18,7 +19,7 @@
"scripts": {
"test": "tap",
"preversion": "npm test",
- "postversion": "npm publish --tag=next",
+ "postversion": "npm publish",
"postpublish": "git push origin --follow-tags"
},
"repository": {
diff --git a/node_modules/minizlib/node_modules/minipass/LICENSE b/node_modules/minizlib/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/minizlib/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/minizlib/node_modules/minipass/index.d.ts b/node_modules/minizlib/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/minizlib/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/minizlib/node_modules/minipass/index.js b/node_modules/minizlib/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/minizlib/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/minizlib/node_modules/minipass/package.json b/node_modules/minizlib/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/minizlib/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/node-gyp/node_modules/minipass/LICENSE b/node_modules/node-gyp/node_modules/minipass/LICENSE
new file mode 100644
index 000000000000..bf1dece2e1f1
--- /dev/null
+++ b/node_modules/node-gyp/node_modules/minipass/LICENSE
@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2017-2022 npm, Inc., Isaac Z. Schlueter, and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/node_modules/node-gyp/node_modules/minipass/index.d.ts b/node_modules/node-gyp/node_modules/minipass/index.d.ts
new file mode 100644
index 000000000000..65faf63686c2
--- /dev/null
+++ b/node_modules/node-gyp/node_modules/minipass/index.d.ts
@@ -0,0 +1,155 @@
+///
+import { EventEmitter } from 'events'
+import { Stream } from 'stream'
+
+declare namespace Minipass {
+ type Encoding = BufferEncoding | 'buffer' | null
+
+ interface Writable extends EventEmitter {
+ end(): any
+ write(chunk: any, ...args: any[]): any
+ }
+
+ interface Readable extends EventEmitter {
+ pause(): any
+ resume(): any
+ pipe(): any
+ }
+
+ interface Pipe {
+ src: Minipass
+ dest: Writable
+ opts: PipeOptions
+ }
+
+ type DualIterable = Iterable & AsyncIterable
+
+ type ContiguousData = Buffer | ArrayBufferLike | ArrayBufferView | string
+
+ type BufferOrString = Buffer | string
+
+ interface StringOptions {
+ encoding: BufferEncoding
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface BufferOptions {
+ encoding?: null | 'buffer'
+ objectMode?: boolean
+ async?: boolean
+ }
+
+ interface ObjectModeOptions {
+ objectMode: true
+ async?: boolean
+ }
+
+ interface PipeOptions {
+ end?: boolean
+ proxyErrors?: boolean
+ }
+
+ type Options = T extends string
+ ? StringOptions
+ : T extends Buffer
+ ? BufferOptions
+ : ObjectModeOptions
+}
+
+declare class Minipass<
+ RType extends any = Buffer,
+ WType extends any = RType extends Minipass.BufferOrString
+ ? Minipass.ContiguousData
+ : RType
+ >
+ extends Stream
+ implements Minipass.DualIterable
+{
+ static isStream(stream: any): stream is Minipass.Readable | Minipass.Writable
+
+ readonly bufferLength: number
+ readonly flowing: boolean
+ readonly writable: boolean
+ readonly readable: boolean
+ readonly paused: boolean
+ readonly emittedEnd: boolean
+ readonly destroyed: boolean
+
+ /**
+ * Not technically private or readonly, but not safe to mutate.
+ */
+ private readonly buffer: RType[]
+ private readonly pipes: Minipass.Pipe[]
+
+ /**
+ * Technically writable, but mutating it can change the type,
+ * so is not safe to do in TypeScript.
+ */
+ readonly objectMode: boolean
+ async: boolean
+
+ /**
+ * Note: encoding is not actually read-only, and setEncoding(enc)
+ * exists. However, this type definition will insist that TypeScript
+ * programs declare the type of a Minipass stream up front, and if
+ * that type is string, then an encoding MUST be set in the ctor. If
+ * the type is Buffer, then the encoding must be missing, or set to
+ * 'buffer' or null. If the type is anything else, then objectMode
+ * must be set in the constructor options. So there is effectively
+ * no allowed way that a TS program can set the encoding after
+ * construction, as doing so will destroy any hope of type safety.
+ * TypeScript does not provide many options for changing the type of
+ * an object at run-time, which is what changing the encoding does.
+ */
+ readonly encoding: Minipass.Encoding
+ // setEncoding(encoding: Encoding): void
+
+ // Options required if not reading buffers
+ constructor(
+ ...args: RType extends Buffer
+ ? [] | [Minipass.Options]
+ : [Minipass.Options]
+ )
+
+ write(chunk: WType, cb?: () => void): boolean
+ write(chunk: WType, encoding?: Minipass.Encoding, cb?: () => void): boolean
+ read(size?: number): RType
+ end(cb?: () => void): this
+ end(chunk: any, cb?: () => void): this
+ end(chunk: any, encoding?: Minipass.Encoding, cb?: () => void): this
+ pause(): void
+ resume(): void
+ promise(): Promise
+ collect(): Promise
+
+ concat(): RType extends Minipass.BufferOrString ? Promise : never
+ destroy(er?: any): void
+ pipe(dest: W, opts?: Minipass.PipeOptions): W
+ unpipe(dest: W): void
+
+ /**
+ * alias for on()
+ */
+ addEventHandler(event: string, listener: (...args: any[]) => any): this
+
+ on(event: string, listener: (...args: any[]) => any): this
+ on(event: 'data', listener: (chunk: RType) => any): this
+ on(event: 'error', listener: (error: any) => any): this
+ on(
+ event:
+ | 'readable'
+ | 'drain'
+ | 'resume'
+ | 'end'
+ | 'prefinish'
+ | 'finish'
+ | 'close',
+ listener: () => any
+ ): this
+
+ [Symbol.iterator](): Iterator
+ [Symbol.asyncIterator](): AsyncIterator
+}
+
+export = Minipass
diff --git a/node_modules/node-gyp/node_modules/minipass/index.js b/node_modules/node-gyp/node_modules/minipass/index.js
new file mode 100644
index 000000000000..e8797aab6cc2
--- /dev/null
+++ b/node_modules/node-gyp/node_modules/minipass/index.js
@@ -0,0 +1,649 @@
+'use strict'
+const proc = typeof process === 'object' && process ? process : {
+ stdout: null,
+ stderr: null,
+}
+const EE = require('events')
+const Stream = require('stream')
+const SD = require('string_decoder').StringDecoder
+
+const EOF = Symbol('EOF')
+const MAYBE_EMIT_END = Symbol('maybeEmitEnd')
+const EMITTED_END = Symbol('emittedEnd')
+const EMITTING_END = Symbol('emittingEnd')
+const EMITTED_ERROR = Symbol('emittedError')
+const CLOSED = Symbol('closed')
+const READ = Symbol('read')
+const FLUSH = Symbol('flush')
+const FLUSHCHUNK = Symbol('flushChunk')
+const ENCODING = Symbol('encoding')
+const DECODER = Symbol('decoder')
+const FLOWING = Symbol('flowing')
+const PAUSED = Symbol('paused')
+const RESUME = Symbol('resume')
+const BUFFERLENGTH = Symbol('bufferLength')
+const BUFFERPUSH = Symbol('bufferPush')
+const BUFFERSHIFT = Symbol('bufferShift')
+const OBJECTMODE = Symbol('objectMode')
+const DESTROYED = Symbol('destroyed')
+const EMITDATA = Symbol('emitData')
+const EMITEND = Symbol('emitEnd')
+const EMITEND2 = Symbol('emitEnd2')
+const ASYNC = Symbol('async')
+
+const defer = fn => Promise.resolve().then(fn)
+
+// TODO remove when Node v8 support drops
+const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== '1'
+const ASYNCITERATOR = doIter && Symbol.asyncIterator
+ || Symbol('asyncIterator not implemented')
+const ITERATOR = doIter && Symbol.iterator
+ || Symbol('iterator not implemented')
+
+// events that mean 'the stream is over'
+// these are treated specially, and re-emitted
+// if they are listened for after emitting.
+const isEndish = ev =>
+ ev === 'end' ||
+ ev === 'finish' ||
+ ev === 'prefinish'
+
+const isArrayBuffer = b => b instanceof ArrayBuffer ||
+ typeof b === 'object' &&
+ b.constructor &&
+ b.constructor.name === 'ArrayBuffer' &&
+ b.byteLength >= 0
+
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
+
+class Pipe {
+ constructor (src, dest, opts) {
+ this.src = src
+ this.dest = dest
+ this.opts = opts
+ this.ondrain = () => src[RESUME]()
+ dest.on('drain', this.ondrain)
+ }
+ unpipe () {
+ this.dest.removeListener('drain', this.ondrain)
+ }
+ // istanbul ignore next - only here for the prototype
+ proxyErrors () {}
+ end () {
+ this.unpipe()
+ if (this.opts.end)
+ this.dest.end()
+ }
+}
+
+class PipeProxyErrors extends Pipe {
+ unpipe () {
+ this.src.removeListener('error', this.proxyErrors)
+ super.unpipe()
+ }
+ constructor (src, dest, opts) {
+ super(src, dest, opts)
+ this.proxyErrors = er => dest.emit('error', er)
+ src.on('error', this.proxyErrors)
+ }
+}
+
+module.exports = class Minipass extends Stream {
+ constructor (options) {
+ super()
+ this[FLOWING] = false
+ // whether we're explicitly paused
+ this[PAUSED] = false
+ this.pipes = []
+ this.buffer = []
+ this[OBJECTMODE] = options && options.objectMode || false
+ if (this[OBJECTMODE])
+ this[ENCODING] = null
+ else
+ this[ENCODING] = options && options.encoding || null
+ if (this[ENCODING] === 'buffer')
+ this[ENCODING] = null
+ this[ASYNC] = options && !!options.async || false
+ this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
+ this[EOF] = false
+ this[EMITTED_END] = false
+ this[EMITTING_END] = false
+ this[CLOSED] = false
+ this[EMITTED_ERROR] = null
+ this.writable = true
+ this.readable = true
+ this[BUFFERLENGTH] = 0
+ this[DESTROYED] = false
+ }
+
+ get bufferLength () { return this[BUFFERLENGTH] }
+
+ get encoding () { return this[ENCODING] }
+ set encoding (enc) {
+ if (this[OBJECTMODE])
+ throw new Error('cannot set encoding in objectMode')
+
+ if (this[ENCODING] && enc !== this[ENCODING] &&
+ (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH]))
+ throw new Error('cannot change encoding')
+
+ if (this[ENCODING] !== enc) {
+ this[DECODER] = enc ? new SD(enc) : null
+ if (this.buffer.length)
+ this.buffer = this.buffer.map(chunk => this[DECODER].write(chunk))
+ }
+
+ this[ENCODING] = enc
+ }
+
+ setEncoding (enc) {
+ this.encoding = enc
+ }
+
+ get objectMode () { return this[OBJECTMODE] }
+ set objectMode (om) { this[OBJECTMODE] = this[OBJECTMODE] || !!om }
+
+ get ['async'] () { return this[ASYNC] }
+ set ['async'] (a) { this[ASYNC] = this[ASYNC] || !!a }
+
+ write (chunk, encoding, cb) {
+ if (this[EOF])
+ throw new Error('write after end')
+
+ if (this[DESTROYED]) {
+ this.emit('error', Object.assign(
+ new Error('Cannot call write after a stream was destroyed'),
+ { code: 'ERR_STREAM_DESTROYED' }
+ ))
+ return true
+ }
+
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+
+ if (!encoding)
+ encoding = 'utf8'
+
+ const fn = this[ASYNC] ? defer : f => f()
+
+ // convert array buffers and typed array views into buffers
+ // at some point in the future, we may want to do the opposite!
+ // leave strings and buffers as-is
+ // anything else switches us into object mode
+ if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+ if (isArrayBufferView(chunk))
+ chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+ else if (isArrayBuffer(chunk))
+ chunk = Buffer.from(chunk)
+ else if (typeof chunk !== 'string')
+ // use the setter so we throw if we have encoding set
+ this.objectMode = true
+ }
+
+ // handle object mode up front, since it's simpler
+ // this yields better performance, fewer checks later.
+ if (this[OBJECTMODE]) {
+ /* istanbul ignore if - maybe impossible? */
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ // at this point the chunk is a buffer or string
+ // don't buffer it up or send it to the decoder
+ if (!chunk.length) {
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+ if (cb)
+ fn(cb)
+ return this.flowing
+ }
+
+ // fast-path writing strings of same encoding to a stream with
+ // an empty buffer, skipping the buffer/decoder dance
+ if (typeof chunk === 'string' &&
+ // unless it is a string already ready for us to use
+ !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+ chunk = Buffer.from(chunk, encoding)
+ }
+
+ if (Buffer.isBuffer(chunk) && this[ENCODING])
+ chunk = this[DECODER].write(chunk)
+
+ // Note: flushing CAN potentially switch us into not-flowing mode
+ if (this.flowing && this[BUFFERLENGTH] !== 0)
+ this[FLUSH](true)
+
+ if (this.flowing)
+ this.emit('data', chunk)
+ else
+ this[BUFFERPUSH](chunk)
+
+ if (this[BUFFERLENGTH] !== 0)
+ this.emit('readable')
+
+ if (cb)
+ fn(cb)
+
+ return this.flowing
+ }
+
+ read (n) {
+ if (this[DESTROYED])
+ return null
+
+ if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+ this[MAYBE_EMIT_END]()
+ return null
+ }
+
+ if (this[OBJECTMODE])
+ n = null
+
+ if (this.buffer.length > 1 && !this[OBJECTMODE]) {
+ if (this.encoding)
+ this.buffer = [this.buffer.join('')]
+ else
+ this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]
+ }
+
+ const ret = this[READ](n || null, this.buffer[0])
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [READ] (n, chunk) {
+ if (n === chunk.length || n === null)
+ this[BUFFERSHIFT]()
+ else {
+ this.buffer[0] = chunk.slice(n)
+ chunk = chunk.slice(0, n)
+ this[BUFFERLENGTH] -= n
+ }
+
+ this.emit('data', chunk)
+
+ if (!this.buffer.length && !this[EOF])
+ this.emit('drain')
+
+ return chunk
+ }
+
+ end (chunk, encoding, cb) {
+ if (typeof chunk === 'function')
+ cb = chunk, chunk = null
+ if (typeof encoding === 'function')
+ cb = encoding, encoding = 'utf8'
+ if (chunk)
+ this.write(chunk, encoding)
+ if (cb)
+ this.once('end', cb)
+ this[EOF] = true
+ this.writable = false
+
+ // if we haven't written anything, then go ahead and emit,
+ // even if we're not reading.
+ // we'll re-emit if a new 'end' listener is added anyway.
+ // This makes MP more suitable to write-only use cases.
+ if (this.flowing || !this[PAUSED])
+ this[MAYBE_EMIT_END]()
+ return this
+ }
+
+ // don't let the internal resume be overwritten
+ [RESUME] () {
+ if (this[DESTROYED])
+ return
+
+ this[PAUSED] = false
+ this[FLOWING] = true
+ this.emit('resume')
+ if (this.buffer.length)
+ this[FLUSH]()
+ else if (this[EOF])
+ this[MAYBE_EMIT_END]()
+ else
+ this.emit('drain')
+ }
+
+ resume () {
+ return this[RESUME]()
+ }
+
+ pause () {
+ this[FLOWING] = false
+ this[PAUSED] = true
+ }
+
+ get destroyed () {
+ return this[DESTROYED]
+ }
+
+ get flowing () {
+ return this[FLOWING]
+ }
+
+ get paused () {
+ return this[PAUSED]
+ }
+
+ [BUFFERPUSH] (chunk) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] += 1
+ else
+ this[BUFFERLENGTH] += chunk.length
+ this.buffer.push(chunk)
+ }
+
+ [BUFFERSHIFT] () {
+ if (this.buffer.length) {
+ if (this[OBJECTMODE])
+ this[BUFFERLENGTH] -= 1
+ else
+ this[BUFFERLENGTH] -= this.buffer[0].length
+ }
+ return this.buffer.shift()
+ }
+
+ [FLUSH] (noDrain) {
+ do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
+
+ if (!noDrain && !this.buffer.length && !this[EOF])
+ this.emit('drain')
+ }
+
+ [FLUSHCHUNK] (chunk) {
+ return chunk ? (this.emit('data', chunk), this.flowing) : false
+ }
+
+ pipe (dest, opts) {
+ if (this[DESTROYED])
+ return
+
+ const ended = this[EMITTED_END]
+ opts = opts || {}
+ if (dest === proc.stdout || dest === proc.stderr)
+ opts.end = false
+ else
+ opts.end = opts.end !== false
+ opts.proxyErrors = !!opts.proxyErrors
+
+ // piping an ended stream ends immediately
+ if (ended) {
+ if (opts.end)
+ dest.end()
+ } else {
+ this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts)
+ : new PipeProxyErrors(this, dest, opts))
+ if (this[ASYNC])
+ defer(() => this[RESUME]())
+ else
+ this[RESUME]()
+ }
+
+ return dest
+ }
+
+ unpipe (dest) {
+ const p = this.pipes.find(p => p.dest === dest)
+ if (p) {
+ this.pipes.splice(this.pipes.indexOf(p), 1)
+ p.unpipe()
+ }
+ }
+
+ addListener (ev, fn) {
+ return this.on(ev, fn)
+ }
+
+ on (ev, fn) {
+ const ret = super.on(ev, fn)
+ if (ev === 'data' && !this.pipes.length && !this.flowing)
+ this[RESUME]()
+ else if (ev === 'readable' && this[BUFFERLENGTH] !== 0)
+ super.emit('readable')
+ else if (isEndish(ev) && this[EMITTED_END]) {
+ super.emit(ev)
+ this.removeAllListeners(ev)
+ } else if (ev === 'error' && this[EMITTED_ERROR]) {
+ if (this[ASYNC])
+ defer(() => fn.call(this, this[EMITTED_ERROR]))
+ else
+ fn.call(this, this[EMITTED_ERROR])
+ }
+ return ret
+ }
+
+ get emittedEnd () {
+ return this[EMITTED_END]
+ }
+
+ [MAYBE_EMIT_END] () {
+ if (!this[EMITTING_END] &&
+ !this[EMITTED_END] &&
+ !this[DESTROYED] &&
+ this.buffer.length === 0 &&
+ this[EOF]) {
+ this[EMITTING_END] = true
+ this.emit('end')
+ this.emit('prefinish')
+ this.emit('finish')
+ if (this[CLOSED])
+ this.emit('close')
+ this[EMITTING_END] = false
+ }
+ }
+
+ emit (ev, data, ...extra) {
+ // error and close are only events allowed after calling destroy()
+ if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
+ return
+ else if (ev === 'data') {
+ return !data ? false
+ : this[ASYNC] ? defer(() => this[EMITDATA](data))
+ : this[EMITDATA](data)
+ } else if (ev === 'end') {
+ return this[EMITEND]()
+ } else if (ev === 'close') {
+ this[CLOSED] = true
+ // don't emit close before 'end' and 'finish'
+ if (!this[EMITTED_END] && !this[DESTROYED])
+ return
+ const ret = super.emit('close')
+ this.removeAllListeners('close')
+ return ret
+ } else if (ev === 'error') {
+ this[EMITTED_ERROR] = data
+ const ret = super.emit('error', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'resume') {
+ const ret = super.emit('resume')
+ this[MAYBE_EMIT_END]()
+ return ret
+ } else if (ev === 'finish' || ev === 'prefinish') {
+ const ret = super.emit(ev)
+ this.removeAllListeners(ev)
+ return ret
+ }
+
+ // Some other unknown event
+ const ret = super.emit(ev, data, ...extra)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITDATA] (data) {
+ for (const p of this.pipes) {
+ if (p.dest.write(data) === false)
+ this.pause()
+ }
+ const ret = super.emit('data', data)
+ this[MAYBE_EMIT_END]()
+ return ret
+ }
+
+ [EMITEND] () {
+ if (this[EMITTED_END])
+ return
+
+ this[EMITTED_END] = true
+ this.readable = false
+ if (this[ASYNC])
+ defer(() => this[EMITEND2]())
+ else
+ this[EMITEND2]()
+ }
+
+ [EMITEND2] () {
+ if (this[DECODER]) {
+ const data = this[DECODER].end()
+ if (data) {
+ for (const p of this.pipes) {
+ p.dest.write(data)
+ }
+ super.emit('data', data)
+ }
+ }
+
+ for (const p of this.pipes) {
+ p.end()
+ }
+ const ret = super.emit('end')
+ this.removeAllListeners('end')
+ return ret
+ }
+
+ // const all = await stream.collect()
+ collect () {
+ const buf = []
+ if (!this[OBJECTMODE])
+ buf.dataLength = 0
+ // set the promise first, in case an error is raised
+ // by triggering the flow here.
+ const p = this.promise()
+ this.on('data', c => {
+ buf.push(c)
+ if (!this[OBJECTMODE])
+ buf.dataLength += c.length
+ })
+ return p.then(() => buf)
+ }
+
+ // const data = await stream.concat()
+ concat () {
+ return this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this.collect().then(buf =>
+ this[OBJECTMODE]
+ ? Promise.reject(new Error('cannot concat in objectMode'))
+ : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
+ }
+
+ // stream.promise().then(() => done, er => emitted error)
+ promise () {
+ return new Promise((resolve, reject) => {
+ this.on(DESTROYED, () => reject(new Error('stream destroyed')))
+ this.on('error', er => reject(er))
+ this.on('end', () => resolve())
+ })
+ }
+
+ // for await (let chunk of stream)
+ [ASYNCITERATOR] () {
+ const next = () => {
+ const res = this.read()
+ if (res !== null)
+ return Promise.resolve({ done: false, value: res })
+
+ if (this[EOF])
+ return Promise.resolve({ done: true })
+
+ let resolve = null
+ let reject = null
+ const onerr = er => {
+ this.removeListener('data', ondata)
+ this.removeListener('end', onend)
+ reject(er)
+ }
+ const ondata = value => {
+ this.removeListener('error', onerr)
+ this.removeListener('end', onend)
+ this.pause()
+ resolve({ value: value, done: !!this[EOF] })
+ }
+ const onend = () => {
+ this.removeListener('error', onerr)
+ this.removeListener('data', ondata)
+ resolve({ done: true })
+ }
+ const ondestroy = () => onerr(new Error('stream destroyed'))
+ return new Promise((res, rej) => {
+ reject = rej
+ resolve = res
+ this.once(DESTROYED, ondestroy)
+ this.once('error', onerr)
+ this.once('end', onend)
+ this.once('data', ondata)
+ })
+ }
+
+ return { next }
+ }
+
+ // for (let chunk of stream)
+ [ITERATOR] () {
+ const next = () => {
+ const value = this.read()
+ const done = value === null
+ return { value, done }
+ }
+ return { next }
+ }
+
+ destroy (er) {
+ if (this[DESTROYED]) {
+ if (er)
+ this.emit('error', er)
+ else
+ this.emit(DESTROYED)
+ return this
+ }
+
+ this[DESTROYED] = true
+
+ // throw away all buffered data, it's never coming out
+ this.buffer.length = 0
+ this[BUFFERLENGTH] = 0
+
+ if (typeof this.close === 'function' && !this[CLOSED])
+ this.close()
+
+ if (er)
+ this.emit('error', er)
+ else // if no error to emit, still reject pending promises
+ this.emit(DESTROYED)
+
+ return this
+ }
+
+ static isStream (s) {
+ return !!s && (s instanceof Minipass || s instanceof Stream ||
+ s instanceof EE && (
+ typeof s.pipe === 'function' || // readable
+ (typeof s.write === 'function' && typeof s.end === 'function') // writable
+ ))
+ }
+}
diff --git a/node_modules/node-gyp/node_modules/minipass/package.json b/node_modules/node-gyp/node_modules/minipass/package.json
new file mode 100644
index 000000000000..548d03fa6d5d
--- /dev/null
+++ b/node_modules/node-gyp/node_modules/minipass/package.json
@@ -0,0 +1,56 @@
+{
+ "name": "minipass",
+ "version": "3.3.6",
+ "description": "minimal implementation of a PassThrough stream",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "devDependencies": {
+ "@types/node": "^17.0.41",
+ "end-of-stream": "^1.4.0",
+ "prettier": "^2.6.2",
+ "tap": "^16.2.0",
+ "through2": "^2.0.3",
+ "ts-node": "^10.8.1",
+ "typescript": "^4.7.3"
+ },
+ "scripts": {
+ "test": "tap",
+ "preversion": "npm test",
+ "postversion": "npm publish",
+ "postpublish": "git push origin --follow-tags"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/isaacs/minipass.git"
+ },
+ "keywords": [
+ "passthrough",
+ "stream"
+ ],
+ "author": "Isaac Z. Schlueter (http://blog.izs.me/)",
+ "license": "ISC",
+ "files": [
+ "index.d.ts",
+ "index.js"
+ ],
+ "tap": {
+ "check-coverage": true
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "prettier": {
+ "semi": false,
+ "printWidth": 80,
+ "tabWidth": 2,
+ "useTabs": false,
+ "singleQuote": true,
+ "jsxSingleQuote": false,
+ "bracketSameLine": true,
+ "arrowParens": "avoid",
+ "endOfLine": "lf"
+ }
+}
diff --git a/node_modules/npm-package-arg/lib/npa.js b/node_modules/npm-package-arg/lib/npa.js
index 10af67be538f..36bd18cd9f9a 100644
--- a/node_modules/npm-package-arg/lib/npa.js
+++ b/node_modules/npm-package-arg/lib/npa.js
@@ -1,6 +1,7 @@
'use strict'
module.exports = npa
module.exports.resolve = resolve
+module.exports.toPurl = toPurl
module.exports.Result = Result
const url = require('url')
@@ -87,6 +88,24 @@ function resolve (name, spec, where, arg) {
}
}
+const defaultRegistry = 'https://registry.npmjs.org'
+
+function toPurl (arg, reg = defaultRegistry) {
+ const res = npa(arg)
+
+ if (res.type !== 'version') {
+ throw invalidPurlType(res.type, res.raw)
+ }
+
+ // URI-encode leading @ of scoped packages
+ let purl = 'pkg:npm/' + res.name.replace(/^@/, '%40') + '@' + res.rawSpec
+ if (reg !== defaultRegistry) {
+ purl += '?repository_url=' + reg
+ }
+
+ return purl
+}
+
function invalidPackageName (name, valid, raw) {
// eslint-disable-next-line max-len
const err = new Error(`Invalid package name "${name}" of package "${raw}": ${valid.errors.join('; ')}.`)
@@ -101,6 +120,13 @@ function invalidTagName (name, raw) {
return err
}
+function invalidPurlType (type, raw) {
+ // eslint-disable-next-line max-len
+ const err = new Error(`Invalid type "${type}" of package "${raw}": Purl can only be generated for "version" types.`)
+ err.code = 'EINVALIDPURLTYPE'
+ return err
+}
+
function Result (opts) {
this.type = opts.type
this.registry = opts.registry
diff --git a/node_modules/npm-package-arg/package.json b/node_modules/npm-package-arg/package.json
index 9ade534a2d88..bb9e71b258a9 100644
--- a/node_modules/npm-package-arg/package.json
+++ b/node_modules/npm-package-arg/package.json
@@ -1,6 +1,6 @@
{
"name": "npm-package-arg",
- "version": "10.0.0",
+ "version": "10.1.0",
"description": "Parse the things that can be arguments to `npm install`",
"main": "./lib/npa.js",
"directories": {
@@ -18,7 +18,7 @@
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.6.1",
+ "@npmcli/template-oss": "4.10.0",
"tap": "^16.0.1"
},
"scripts": {
@@ -54,6 +54,6 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.6.1"
+ "version": "4.10.0"
}
}
diff --git a/node_modules/npm-registry-fetch/package.json b/node_modules/npm-registry-fetch/package.json
index 1cb6bf4e47a4..89550cee29ae 100644
--- a/node_modules/npm-registry-fetch/package.json
+++ b/node_modules/npm-registry-fetch/package.json
@@ -1,6 +1,6 @@
{
"name": "npm-registry-fetch",
- "version": "14.0.2",
+ "version": "14.0.3",
"description": "Fetch-based http client for use with npm registry APIs",
"main": "lib",
"files": [
@@ -32,7 +32,7 @@
"license": "ISC",
"dependencies": {
"make-fetch-happen": "^11.0.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-fetch": "^3.0.0",
"minipass-json-stream": "^1.0.1",
"minizlib": "^2.1.2",
@@ -41,7 +41,7 @@
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.6.1",
+ "@npmcli/template-oss": "4.10.0",
"cacache": "^17.0.0",
"mkdirp": "^1.0.4",
"nock": "^13.2.4",
@@ -63,6 +63,6 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.6.1"
+ "version": "4.10.0"
}
}
diff --git a/node_modules/pacote/package.json b/node_modules/pacote/package.json
index e595e80f39e8..776751340998 100644
--- a/node_modules/pacote/package.json
+++ b/node_modules/pacote/package.json
@@ -1,6 +1,6 @@
{
"name": "pacote",
- "version": "15.0.6",
+ "version": "15.0.7",
"description": "JavaScript package downloader",
"author": "GitHub Inc.",
"bin": {
@@ -27,7 +27,7 @@
"devDependencies": {
"@npmcli/arborist": "^6.0.0 || ^6.0.0-pre.0",
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.8.0",
+ "@npmcli/template-oss": "4.10.0",
"hosted-git-info": "^6.0.0",
"mutate-fs": "^2.1.1",
"nock": "^13.2.4",
@@ -50,7 +50,7 @@
"@npmcli/run-script": "^6.0.0",
"cacache": "^17.0.0",
"fs-minipass": "^2.1.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"npm-package-arg": "^10.0.0",
"npm-packlist": "^7.0.0",
"npm-pick-manifest": "^8.0.0",
@@ -71,7 +71,7 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.8.0",
+ "version": "4.10.0",
"windowsCI": false
}
}
diff --git a/node_modules/ssri/package.json b/node_modules/ssri/package.json
index 156d50ee6939..65b14bc5a797 100644
--- a/node_modules/ssri/package.json
+++ b/node_modules/ssri/package.json
@@ -1,6 +1,6 @@
{
"name": "ssri",
- "version": "10.0.0",
+ "version": "10.0.1",
"description": "Standard Subresource Integrity library -- parses, serializes, generates, and verifies integrity metadata according to the SRI spec.",
"main": "lib/index.js",
"files": [
@@ -47,11 +47,11 @@
"author": "GitHub Inc.",
"license": "ISC",
"dependencies": {
- "minipass": "^3.1.1"
+ "minipass": "^4.0.0"
},
"devDependencies": {
- "@npmcli/eslint-config": "^3.0.1",
- "@npmcli/template-oss": "4.5.1",
+ "@npmcli/eslint-config": "^4.0.0",
+ "@npmcli/template-oss": "4.10.0",
"tap": "^16.0.1"
},
"engines": {
@@ -59,6 +59,6 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.5.1"
+ "version": "4.10.0"
}
}
diff --git a/node_modules/tar/package.json b/node_modules/tar/package.json
index 3a02105c159e..e6d6b9334049 100644
--- a/node_modules/tar/package.json
+++ b/node_modules/tar/package.json
@@ -2,7 +2,7 @@
"author": "GitHub Inc.",
"name": "tar",
"description": "tar for node",
- "version": "6.1.12",
+ "version": "6.1.13",
"repository": {
"type": "git",
"url": "https://github.com/npm/node-tar.git"
@@ -20,17 +20,17 @@
"dependencies": {
"chownr": "^2.0.0",
"fs-minipass": "^2.0.0",
- "minipass": "^3.0.0",
+ "minipass": "^4.0.0",
"minizlib": "^2.1.1",
"mkdirp": "^1.0.3",
"yallist": "^4.0.0"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
- "@npmcli/template-oss": "4.8.0",
+ "@npmcli/template-oss": "4.10.0",
"chmodr": "^1.2.0",
"end-of-stream": "^1.4.3",
- "events-to-array": "^1.1.2",
+ "events-to-array": "^2.0.3",
"mutate-fs": "^2.1.1",
"nock": "^13.2.9",
"rimraf": "^3.0.2",
@@ -55,7 +55,7 @@
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
- "version": "4.8.0",
+ "version": "4.10.0",
"content": "scripts/template-oss",
"engines": ">=10",
"distPaths": [
diff --git a/package-lock.json b/package-lock.json
index 62531d9a9dc2..b65f2653c445 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -93,7 +93,7 @@
"@npmcli/run-script": "^6.0.0",
"abbrev": "^2.0.0",
"archy": "~1.0.0",
- "cacache": "^17.0.2",
+ "cacache": "^17.0.3",
"chalk": "^4.1.2",
"ci-info": "^3.6.1",
"cli-columns": "^4.0.0",
@@ -119,9 +119,9 @@
"libnpmsearch": "^6.0.0",
"libnpmteam": "^5.0.0",
"libnpmversion": "^4.0.1",
- "make-fetch-happen": "^11.0.1",
+ "make-fetch-happen": "^11.0.2",
"minimatch": "^5.1.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-pipeline": "^1.2.4",
"mkdirp": "^1.0.4",
"ms": "^2.1.2",
@@ -129,14 +129,14 @@
"nopt": "^7.0.0",
"npm-audit-report": "^4.0.0",
"npm-install-checks": "^6.0.0",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npm-pick-manifest": "^8.0.1",
"npm-profile": "^7.0.1",
- "npm-registry-fetch": "^14.0.2",
+ "npm-registry-fetch": "^14.0.3",
"npm-user-validate": "^1.0.1",
"npmlog": "^7.0.1",
"p-map": "^4.0.0",
- "pacote": "^15.0.6",
+ "pacote": "^15.0.7",
"parse-conflict-json": "^3.0.0",
"proc-log": "^3.0.0",
"qrcode-terminal": "^0.12.0",
@@ -145,8 +145,8 @@
"read-package-json-fast": "^3.0.1",
"rimraf": "^3.0.2",
"semver": "^7.3.8",
- "ssri": "^10.0.0",
- "tar": "^6.1.12",
+ "ssri": "^10.0.1",
+ "tar": "^6.1.13",
"text-table": "~0.2.0",
"tiny-relative-date": "^1.3.0",
"treeverse": "^3.0.0",
@@ -213,8 +213,8 @@
"@npmcli/eslint-config": "^4.0.1",
"@npmcli/template-oss": "4.11.0",
"nock": "^13.2.9",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.6",
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7",
"tap": "^16.3.0"
},
"engines": {
@@ -3076,16 +3076,16 @@
}
},
"node_modules/cacache": {
- "version": "17.0.2",
- "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.0.2.tgz",
- "integrity": "sha512-rYUs2x4OjSgCQND7nTrh21AHIBFgd7s/ctAYvU3a8u+nK+R5YaX/SFPDYz4Azz7SGL6+6L9ZZWI4Kawpb7grzQ==",
+ "version": "17.0.3",
+ "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.0.3.tgz",
+ "integrity": "sha512-pwsIK/grdM0cHpfVaNFxMdzElBtLJGsVPE+JnxqXP1l40O01Z1mfDE8MbRTuwomGq/UwEtGisOylutOEVJxEqg==",
"inBundle": true,
"dependencies": {
"@npmcli/fs": "^3.1.0",
"fs-minipass": "^2.1.0",
"glob": "^8.0.1",
"lru-cache": "^7.7.1",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-collect": "^1.0.2",
"minipass-flush": "^1.0.5",
"minipass-pipeline": "^1.2.4",
@@ -5283,6 +5283,18 @@
"node": ">= 8"
}
},
+ "node_modules/fs-minipass/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/fs.realpath": {
"version": "1.0.0",
"inBundle": true,
@@ -6918,6 +6930,18 @@
"node": ">=0.3.1"
}
},
+ "node_modules/libtap/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/licensee": {
"version": "9.0.0",
"resolved": "https://registry.npmjs.org/licensee/-/licensee-9.0.0.tgz",
@@ -7310,6 +7334,18 @@
"node": "^12.13.0 || ^14.15.0 || >=16.0.0"
}
},
+ "node_modules/licensee/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/licensee/node_modules/minipass-fetch": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-2.1.2.tgz",
@@ -7809,9 +7845,10 @@
"dev": true
},
"node_modules/make-fetch-happen": {
- "version": "11.0.1",
+ "version": "11.0.2",
+ "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-11.0.2.tgz",
+ "integrity": "sha512-5n/Pq41w/uZghpdlXAY5kIM85RgJThtTH/NYBRAZ9VUOBWV90USaQjwGrw76fZP3Lj5hl/VZjpVvOaRBMoL/2w==",
"inBundle": true,
- "license": "ISC",
"dependencies": {
"agentkeepalive": "^4.2.1",
"cacache": "^17.0.0",
@@ -7820,7 +7857,7 @@
"https-proxy-agent": "^5.0.0",
"is-lambda": "^1.0.1",
"lru-cache": "^7.7.1",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-collect": "^1.0.2",
"minipass-fetch": "^3.0.0",
"minipass-flush": "^1.0.5",
@@ -8894,9 +8931,10 @@
}
},
"node_modules/minipass": {
- "version": "3.3.4",
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-4.0.0.tgz",
+ "integrity": "sha512-g2Uuh2jEKoht+zvO6vJqXmYpflPqzRBT+Th2h01DKh5z7wbY/AZ2gCQ78cP70YoHPyFdY30YBV5WxgLOEwOykw==",
"inBundle": true,
- "license": "ISC",
"dependencies": {
"yallist": "^4.0.0"
},
@@ -8915,6 +8953,18 @@
"node": ">= 8"
}
},
+ "node_modules/minipass-collect/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minipass-fetch": {
"version": "3.0.0",
"inBundle": true,
@@ -8931,6 +8981,18 @@
"encoding": "^0.1.13"
}
},
+ "node_modules/minipass-fetch/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minipass-flush": {
"version": "1.0.5",
"inBundle": true,
@@ -8942,6 +9004,18 @@
"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==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minipass-json-stream": {
"version": "1.0.1",
"inBundle": true,
@@ -8951,6 +9025,18 @@
"minipass": "^3.0.0"
}
},
+ "node_modules/minipass-json-stream/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minipass-pipeline": {
"version": "1.2.4",
"inBundle": true,
@@ -8962,6 +9048,18 @@
"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==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minipass-sized": {
"version": "1.0.3",
"inBundle": true,
@@ -8973,6 +9071,18 @@
"node": ">=8"
}
},
+ "node_modules/minipass-sized/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/minizlib": {
"version": "2.1.2",
"inBundle": true,
@@ -8985,6 +9095,18 @@
"node": ">= 8"
}
},
+ "node_modules/minizlib/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/mkdirp": {
"version": "1.0.4",
"inBundle": true,
@@ -9315,6 +9437,18 @@
"node": "*"
}
},
+ "node_modules/node-gyp/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "inBundle": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/node-gyp/node_modules/minipass-fetch": {
"version": "2.1.2",
"inBundle": true,
@@ -9519,9 +9653,9 @@
}
},
"node_modules/npm-package-arg": {
- "version": "10.0.0",
- "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-10.0.0.tgz",
- "integrity": "sha512-7dkh8mRp7s0KwVHKIVJnFCJQ2B34gOGnzgBjDGyprycmARq/82SX/lhilQ95ZuacP/G/1gsS345iAkKmxWBQ2Q==",
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-10.1.0.tgz",
+ "integrity": "sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==",
"inBundle": true,
"dependencies": {
"hosted-git-info": "^6.0.0",
@@ -9572,12 +9706,13 @@
}
},
"node_modules/npm-registry-fetch": {
- "version": "14.0.2",
+ "version": "14.0.3",
+ "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-14.0.3.tgz",
+ "integrity": "sha512-YaeRbVNpnWvsGOjX2wk5s85XJ7l1qQBGAp724h8e2CZFFhMSuw9enom7K1mWVUtvXO1uUSFIAPofQK0pPN0ZcA==",
"inBundle": true,
- "license": "ISC",
"dependencies": {
"make-fetch-happen": "^11.0.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-fetch": "^3.0.0",
"minipass-json-stream": "^1.0.1",
"minizlib": "^2.1.2",
@@ -10105,9 +10240,9 @@
}
},
"node_modules/pacote": {
- "version": "15.0.6",
- "resolved": "https://registry.npmjs.org/pacote/-/pacote-15.0.6.tgz",
- "integrity": "sha512-dQwcz/sME7QIL+cdrw/jftQfMMXxSo17i2kJ/gnhBhUvvBAsxoBu1lw9B5IzCH/Ce8CvEkG/QYZ6txzKfn0bTw==",
+ "version": "15.0.7",
+ "resolved": "https://registry.npmjs.org/pacote/-/pacote-15.0.7.tgz",
+ "integrity": "sha512-OFf4dl3SM1PpsZvi1zk4vvMA0EplnyO0Ajbrtoyx6E3dXOWBoPnMapnLgQdInEfqPkNT8mrd2bY6c5t8JZ69sQ==",
"inBundle": true,
"dependencies": {
"@npmcli/git": "^4.0.0",
@@ -10116,7 +10251,7 @@
"@npmcli/run-script": "^6.0.0",
"cacache": "^17.0.0",
"fs-minipass": "^2.1.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"npm-package-arg": "^10.0.0",
"npm-packlist": "^7.0.0",
"npm-pick-manifest": "^8.0.0",
@@ -11585,11 +11720,12 @@
"dev": true
},
"node_modules/ssri": {
- "version": "10.0.0",
+ "version": "10.0.1",
+ "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.1.tgz",
+ "integrity": "sha512-WVy6di9DlPOeBWEjMScpNipeSX2jIZBGEn5Uuo8Q7aIuFEuDX0pw8RxcOjlD1TWP4obi24ki7m/13+nFpcbXrw==",
"inBundle": true,
- "license": "ISC",
"dependencies": {
- "minipass": "^3.1.1"
+ "minipass": "^4.0.0"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
@@ -11959,6 +12095,18 @@
"node": ">= 8"
}
},
+ "node_modules/tap-parser/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
"node_modules/tap-yaml": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/tap-yaml/-/tap-yaml-1.0.0.tgz",
@@ -13859,13 +14007,14 @@
}
},
"node_modules/tar": {
- "version": "6.1.12",
+ "version": "6.1.13",
+ "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.13.tgz",
+ "integrity": "sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==",
"inBundle": true,
- "license": "ISC",
"dependencies": {
"chownr": "^2.0.0",
"fs-minipass": "^2.0.0",
- "minipass": "^3.0.0",
+ "minipass": "^4.0.0",
"minizlib": "^2.1.1",
"mkdirp": "^1.0.3",
"yallist": "^4.0.0"
@@ -14998,7 +15147,7 @@
"@npmcli/query": "^3.0.0",
"@npmcli/run-script": "^6.0.0",
"bin-links": "^4.0.1",
- "cacache": "^17.0.2",
+ "cacache": "^17.0.3",
"common-ancestor-path": "^1.0.1",
"hosted-git-info": "^6.1.1",
"json-parse-even-better-errors": "^3.0.0",
@@ -15006,18 +15155,18 @@
"minimatch": "^5.1.0",
"nopt": "^7.0.0",
"npm-install-checks": "^6.0.0",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npm-pick-manifest": "^8.0.1",
- "npm-registry-fetch": "^14.0.2",
+ "npm-registry-fetch": "^14.0.3",
"npmlog": "^7.0.1",
- "pacote": "^15.0.2",
+ "pacote": "^15.0.7",
"parse-conflict-json": "^3.0.0",
"proc-log": "^3.0.0",
"promise-all-reject-late": "^1.0.0",
"promise-call-limit": "^1.0.1",
"read-package-json-fast": "^3.0.1",
"semver": "^7.3.7",
- "ssri": "^10.0.0",
+ "ssri": "^10.0.1",
"treeverse": "^3.0.0",
"walk-up-path": "^1.0.0"
},
@@ -15064,8 +15213,8 @@
"version": "7.0.0",
"license": "ISC",
"dependencies": {
- "npm-package-arg": "^10.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-package-arg": "^10.1.0",
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15088,9 +15237,9 @@
"binary-extensions": "^2.2.0",
"diff": "^5.1.0",
"minimatch": "^5.0.1",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.2",
- "tar": "^6.1.0"
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7",
+ "tar": "^6.1.13"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15109,9 +15258,9 @@
"@npmcli/run-script": "^6.0.0",
"chalk": "^4.1.0",
"ci-info": "^3.6.1",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npmlog": "^7.0.1",
- "pacote": "^15.0.2",
+ "pacote": "^15.0.7",
"proc-log": "^3.0.0",
"read": "^1.0.7",
"read-package-json-fast": "^3.0.1",
@@ -15153,7 +15302,7 @@
"license": "ISC",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15170,12 +15319,12 @@
"license": "ISC",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
"@npmcli/template-oss": "4.11.0",
- "minipass": "^3.1.1",
+ "minipass": "^4.0.0",
"nock": "^13.2.4",
"tap": "^16.0.1"
},
@@ -15189,8 +15338,8 @@
"dependencies": {
"@npmcli/arborist": "^6.1.4",
"@npmcli/run-script": "^6.0.0",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.2"
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15208,10 +15357,10 @@
"license": "ISC",
"dependencies": {
"normalize-package-data": "^5.0.0",
- "npm-package-arg": "^10.0.0",
- "npm-registry-fetch": "^14.0.2",
+ "npm-package-arg": "^10.1.0",
+ "npm-registry-fetch": "^14.0.3",
"semver": "^7.3.7",
- "ssri": "^10.0.0"
+ "ssri": "^10.0.1"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15229,7 +15378,7 @@
"version": "6.0.0",
"license": "ISC",
"dependencies": {
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
@@ -15246,7 +15395,7 @@
"license": "ISC",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
diff --git a/package.json b/package.json
index 073d4108ae14..da6b9e52e576 100644
--- a/package.json
+++ b/package.json
@@ -60,7 +60,7 @@
"@npmcli/run-script": "^6.0.0",
"abbrev": "^2.0.0",
"archy": "~1.0.0",
- "cacache": "^17.0.2",
+ "cacache": "^17.0.3",
"chalk": "^4.1.2",
"ci-info": "^3.6.1",
"cli-columns": "^4.0.0",
@@ -86,9 +86,9 @@
"libnpmsearch": "^6.0.0",
"libnpmteam": "^5.0.0",
"libnpmversion": "^4.0.1",
- "make-fetch-happen": "^11.0.1",
+ "make-fetch-happen": "^11.0.2",
"minimatch": "^5.1.0",
- "minipass": "^3.1.6",
+ "minipass": "^4.0.0",
"minipass-pipeline": "^1.2.4",
"mkdirp": "^1.0.4",
"ms": "^2.1.2",
@@ -96,14 +96,14 @@
"nopt": "^7.0.0",
"npm-audit-report": "^4.0.0",
"npm-install-checks": "^6.0.0",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npm-pick-manifest": "^8.0.1",
"npm-profile": "^7.0.1",
- "npm-registry-fetch": "^14.0.2",
+ "npm-registry-fetch": "^14.0.3",
"npm-user-validate": "^1.0.1",
"npmlog": "^7.0.1",
"p-map": "^4.0.0",
- "pacote": "^15.0.6",
+ "pacote": "^15.0.7",
"parse-conflict-json": "^3.0.0",
"proc-log": "^3.0.0",
"qrcode-terminal": "^0.12.0",
@@ -112,8 +112,8 @@
"read-package-json-fast": "^3.0.1",
"rimraf": "^3.0.2",
"semver": "^7.3.8",
- "ssri": "^10.0.0",
- "tar": "^6.1.12",
+ "ssri": "^10.0.1",
+ "tar": "^6.1.13",
"text-table": "~0.2.0",
"tiny-relative-date": "^1.3.0",
"treeverse": "^3.0.0",
diff --git a/workspaces/arborist/package.json b/workspaces/arborist/package.json
index 83a625aabea5..c3b957e6f74c 100644
--- a/workspaces/arborist/package.json
+++ b/workspaces/arborist/package.json
@@ -14,7 +14,7 @@
"@npmcli/query": "^3.0.0",
"@npmcli/run-script": "^6.0.0",
"bin-links": "^4.0.1",
- "cacache": "^17.0.2",
+ "cacache": "^17.0.3",
"common-ancestor-path": "^1.0.1",
"hosted-git-info": "^6.1.1",
"json-parse-even-better-errors": "^3.0.0",
@@ -22,18 +22,18 @@
"minimatch": "^5.1.0",
"nopt": "^7.0.0",
"npm-install-checks": "^6.0.0",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npm-pick-manifest": "^8.0.1",
- "npm-registry-fetch": "^14.0.2",
+ "npm-registry-fetch": "^14.0.3",
"npmlog": "^7.0.1",
- "pacote": "^15.0.2",
+ "pacote": "^15.0.7",
"parse-conflict-json": "^3.0.0",
"proc-log": "^3.0.0",
"promise-all-reject-late": "^1.0.0",
"promise-call-limit": "^1.0.1",
"read-package-json-fast": "^3.0.1",
"semver": "^7.3.7",
- "ssri": "^10.0.0",
+ "ssri": "^10.0.1",
"treeverse": "^3.0.0",
"walk-up-path": "^1.0.0"
},
diff --git a/workspaces/libnpmaccess/package.json b/workspaces/libnpmaccess/package.json
index 4938c0c150f7..e17b2ce49eaa 100644
--- a/workspaces/libnpmaccess/package.json
+++ b/workspaces/libnpmaccess/package.json
@@ -29,8 +29,8 @@
"bugs": "https://github.com/npm/libnpmaccess/issues",
"homepage": "https://npmjs.com/package/libnpmaccess",
"dependencies": {
- "npm-package-arg": "^10.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-package-arg": "^10.1.0",
+ "npm-registry-fetch": "^14.0.3"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
diff --git a/workspaces/libnpmdiff/package.json b/workspaces/libnpmdiff/package.json
index 79708170654d..c23a45e9c129 100644
--- a/workspaces/libnpmdiff/package.json
+++ b/workspaces/libnpmdiff/package.json
@@ -53,9 +53,9 @@
"binary-extensions": "^2.2.0",
"diff": "^5.1.0",
"minimatch": "^5.0.1",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.2",
- "tar": "^6.1.0"
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7",
+ "tar": "^6.1.13"
},
"templateOSS": {
"//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
diff --git a/workspaces/libnpmexec/package.json b/workspaces/libnpmexec/package.json
index 8fb82c090b42..950246f6e1be 100644
--- a/workspaces/libnpmexec/package.json
+++ b/workspaces/libnpmexec/package.json
@@ -65,9 +65,9 @@
"@npmcli/run-script": "^6.0.0",
"chalk": "^4.1.0",
"ci-info": "^3.6.1",
- "npm-package-arg": "^10.0.0",
+ "npm-package-arg": "^10.1.0",
"npmlog": "^7.0.1",
- "pacote": "^15.0.2",
+ "pacote": "^15.0.7",
"proc-log": "^3.0.0",
"read": "^1.0.7",
"read-package-json-fast": "^3.0.1",
diff --git a/workspaces/libnpmhook/package.json b/workspaces/libnpmhook/package.json
index 47216d109c3f..193e752edc78 100644
--- a/workspaces/libnpmhook/package.json
+++ b/workspaces/libnpmhook/package.json
@@ -33,7 +33,7 @@
"license": "ISC",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
diff --git a/workspaces/libnpmorg/package.json b/workspaces/libnpmorg/package.json
index a1049290f840..988549a82f55 100644
--- a/workspaces/libnpmorg/package.json
+++ b/workspaces/libnpmorg/package.json
@@ -29,7 +29,7 @@
"devDependencies": {
"@npmcli/eslint-config": "^4.0.0",
"@npmcli/template-oss": "4.11.0",
- "minipass": "^3.1.1",
+ "minipass": "^4.0.0",
"nock": "^13.2.4",
"tap": "^16.0.1"
},
@@ -42,7 +42,7 @@
"homepage": "https://npmjs.com/package/libnpmorg",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
diff --git a/workspaces/libnpmpack/package.json b/workspaces/libnpmpack/package.json
index 26a40cbd139f..2c0ba36caaa7 100644
--- a/workspaces/libnpmpack/package.json
+++ b/workspaces/libnpmpack/package.json
@@ -38,8 +38,8 @@
"dependencies": {
"@npmcli/arborist": "^6.1.4",
"@npmcli/run-script": "^6.0.0",
- "npm-package-arg": "^10.0.0",
- "pacote": "^15.0.2"
+ "npm-package-arg": "^10.1.0",
+ "pacote": "^15.0.7"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
diff --git a/workspaces/libnpmpublish/package.json b/workspaces/libnpmpublish/package.json
index 50879ad1eb9c..ec09f0380ad1 100644
--- a/workspaces/libnpmpublish/package.json
+++ b/workspaces/libnpmpublish/package.json
@@ -40,10 +40,10 @@
"homepage": "https://npmjs.com/package/libnpmpublish",
"dependencies": {
"normalize-package-data": "^5.0.0",
- "npm-package-arg": "^10.0.0",
- "npm-registry-fetch": "^14.0.2",
+ "npm-package-arg": "^10.1.0",
+ "npm-registry-fetch": "^14.0.3",
"semver": "^7.3.7",
- "ssri": "^10.0.0"
+ "ssri": "^10.0.1"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
diff --git a/workspaces/libnpmsearch/package.json b/workspaces/libnpmsearch/package.json
index d414d0c3ba76..e6dabd9f2c2f 100644
--- a/workspaces/libnpmsearch/package.json
+++ b/workspaces/libnpmsearch/package.json
@@ -38,7 +38,7 @@
"bugs": "https://github.com/npm/libnpmsearch/issues",
"homepage": "https://npmjs.com/package/libnpmsearch",
"dependencies": {
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"
diff --git a/workspaces/libnpmteam/package.json b/workspaces/libnpmteam/package.json
index 1c7953ea8b57..fe5e50352480 100644
--- a/workspaces/libnpmteam/package.json
+++ b/workspaces/libnpmteam/package.json
@@ -32,7 +32,7 @@
"homepage": "https://npmjs.com/package/libnpmteam",
"dependencies": {
"aproba": "^2.0.0",
- "npm-registry-fetch": "^14.0.2"
+ "npm-registry-fetch": "^14.0.3"
},
"engines": {
"node": "^14.17.0 || ^16.13.0 || >=18.0.0"