tap@14.10.6, dedupe some dependencies in node_modules

9 files changed, 0 insertions, 1947 deletions

diff --git a/node_modules/minizlib/node_modules/minipass/LICENSE b/node_modules/minizlib/node_modules/minipass/LICENSE
deleted file mode 100644
index 20a476254..000000000
--- a/node_modules/minizlib/node_modules/minipass/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) npm, Inc. 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/README.md b/node_modules/minizlib/node_modules/minipass/README.md
deleted file mode 100644
index 32ace2fb9..000000000
--- a/node_modules/minizlib/node_modules/minipass/README.md
+++ /dev/null
@@ -1,606 +0,0 @@
-# minipass
-
-A _very_ minimal implementation of a [PassThrough
-stream](https://nodejs.org/api/stream.html#stream_class_stream_passthrough)
-
-[It's very
-fast](https://docs.google.com/spreadsheets/d/1oObKSrVwLX_7Ut4Z6g3fZW-AX1j1-k6w-cDsrkaSbHM/edit#gid=0)
-for objects, strings, and buffers.
-
-Supports pipe()ing (including multi-pipe() and backpressure transmission),
-buffering data until either a `data` event handler or `pipe()` is added (so
-you don't lose the first chunk), and most other cases where PassThrough is
-a good idea.
-
-There is a `read()` method, but it's much more efficient to consume data
-from this stream via `'data'` events or by calling `pipe()` into some other
-stream.  Calling `read()` requires the buffer to be flattened in some
-cases, which requires copying memory.
-
-There is also no `unpipe()` method.  Once you start piping, there is no
-stopping it!
-
-If you set `objectMode: true` in the options, then whatever is written will
-be emitted.  Otherwise, it'll do a minimal amount of Buffer copying to
-ensure proper Streams semantics when `read(n)` is called.
-
-`objectMode` can also be set by doing `stream.objectMode = true`, or by
-writing any non-string/non-buffer data.  `objectMode` cannot be set to
-false once it is set.
-
-This is not a `through` or `through2` stream.  It doesn't transform the
-data, it just passes it right through.  If you want to transform the data,
-extend the class, and override the `write()` method.  Once you're done
-transforming the data however you want, call `super.write()` with the
-transform output.
-
-For some examples of streams that extend Minipass in various ways, check
-out:
-
-- [minizlib](http://npm.im/minizlib)
-- [fs-minipass](http://npm.im/fs-minipass)
-- [tar](http://npm.im/tar)
-- [minipass-collect](http://npm.im/minipass-collect)
-- [minipass-flush](http://npm.im/minipass-flush)
-- [minipass-pipeline](http://npm.im/minipass-pipeline)
-- [tap](http://npm.im/tap)
-- [tap-parser](http://npm.im/tap)
-- [treport](http://npm.im/tap)
-- [minipass-fetch](http://npm.im/minipass-fetch)
-
-## Differences from Node.js Streams
-
-There are several things that make Minipass streams different from (and in
-some ways superior to) Node.js core streams.
-
-Please read these caveats if you are familiar with noode-core streams and
-intend to use Minipass streams in your programs.
-
-### Timing
-
-Minipass streams are designed to support synchronous use-cases.  Thus, data
-is emitted as soon as it is available, always.  It is buffered until read,
-but no longer.  Another way to look at it is that Minipass streams are
-exactly as synchronous as the logic that writes into them.
-
-This can be surprising if your code relies on `PassThrough.write()` always
-providing data on the next tick rather than the current one, or being able
-to call `resume()` and not have the entire buffer disappear immediately.
-
-However, without this synchronicity guarantee, there would be no way for
-Minipass to achieve the speeds it does, or support the synchronous use
-cases that it does.  Simply put, waiting takes time.
-
-This non-deferring approach makes Minipass streams much easier to reason
-about, especially in the context of Promises and other flow-control
-mechanisms.
-
-### No High/Low Water Marks
-
-Node.js core streams will optimistically fill up a buffer, returning `true`
-on all writes until the limit is hit, even if the data has nowhere to go.
-Then, they will not attempt to draw more data in until the buffer size dips
-below a minimum value.
-
-Minipass streams are much simpler.  The `write()` method will return `true`
-if the data has somewhere to go (which is to say, given the timing
-guarantees, that the data is already there by the time `write()` returns).
-
-If the data has nowhere to go, then `write()` returns false, and the data
-sits in a buffer, to be drained out immediately as soon as anyone consumes
-it.
-
-### Hazards of Buffering (or: Why Minipass Is So Fast)
-
-Since data written to a Minipass stream is immediately written all the way
-through the pipeline, and `write()` always returns true/false based on
-whether the data was fully flushed, backpressure is communicated
-immediately to the upstream caller.  This minimizes buffering.
-
-Consider this case:
-
-```js
-const {PassThrough} = require('stream')
-const p1 = new PassThrough({ highWaterMark: 1024 })
-const p2 = new PassThrough({ highWaterMark: 1024 })
-const p3 = new PassThrough({ highWaterMark: 1024 })
-const p4 = new PassThrough({ highWaterMark: 1024 })
-
-p1.pipe(p2).pipe(p3).pipe(p4)
-p4.on('data', () => console.log('made it through'))
-
-// this returns false and buffers, then writes to p2 on next tick (1)
-// p2 returns false and buffers, pausing p1, then writes to p3 on next tick (2)
-// p3 returns false and buffers, pausing p2, then writes to p4 on next tick (3)
-// p4 returns false and buffers, pausing p3, then emits 'data' and 'drain'
-// on next tick (4)
-// p3 sees p4's 'drain' event, and calls resume(), emitting 'resume' and
-// 'drain' on next tick (5)
-// p2 sees p3's 'drain', calls resume(), emits 'resume' and 'drain' on next tick (6)
-// p1 sees p2's 'drain', calls resume(), emits 'resume' and 'drain' on next
-// tick (7)
-
-p1.write(Buffer.alloc(2048)) // returns false
-```
-
-Along the way, the data was buffered and deferred at each stage, and
-multiple event deferrals happened, for an unblocked pipeline where it was
-perfectly safe to write all the way through!
-
-Furthermore, setting a `highWaterMark` of `1024` might lead someone reading
-the code to think an advisory maximum of 1KiB is being set for the
-pipeline.  However, the actual advisory buffering level is the _sum_ of
-`highWaterMark` values, since each one has its own bucket.
-
-Consider the Minipass case:
-
-```js
-const m1 = new Minipass()
-const m2 = new Minipass()
-const m3 = new Minipass()
-const m4 = new Minipass()
-
-m1.pipe(m2).pipe(m3).pipe(m4)
-m4.on('data', () => console.log('made it through'))
-
-// m1 is flowing, so it writes the data to m2 immediately
-// m2 is flowing, so it writes the data to m3 immediately
-// m3 is flowing, so it writes the data to m4 immediately
-// m4 is flowing, so it fires the 'data' event immediately, returns true
-// m4's write returned true, so m3 is still flowing, returns true
-// m3's write returned true, so m2 is still flowing, returns true
-// m2's write returned true, so m1 is still flowing, returns true
-// No event deferrals or buffering along the way!
-
-m1.write(Buffer.alloc(2048)) // returns true
-```
-
-It is extremely unlikely that you _don't_ want to buffer any data written,
-or _ever_ buffer data that can be flushed all the way through.  Neither
-node-core streams nor Minipass ever fail to buffer written data, but
-node-core streams do a lot of unnecessary buffering and pausing.
-
-As always, the faster implementation is the one that does less stuff and
-waits less time to do it.
-
-### Immediately emit `end` for empty streams (when not paused)
-
-If a stream is not paused, and `end()` is called before writing any data
-into it, then it will emit `end` immediately.
-
-If you have logic that occurs on the `end` event which you don't want to
-potentially happen immediately (for example, closing file descriptors,
-moving on to the next entry in an archive parse stream, etc.) then be sure
-to call `stream.pause()` on creation, and then `stream.resume()` once you
-are ready to respond to the `end` event.
-
-### Emit `end` When Asked
-
-One hazard of immediately emitting `'end'` is that you may not yet have had
-a chance to add a listener.  In order to avoid this hazard, Minipass
-streams safely re-emit the `'end'` event if a new listener is added after
-`'end'` has been emitted.
-
-Ie, if you do `stream.on('end', someFunction)`, and the stream has already
-emitted `end`, then it will call the handler right away.  (You can think of
-this somewhat like attaching a new `.then(fn)` to a previously-resolved
-Promise.)
-
-To prevent calling handlers multiple times who would not expect multiple
-ends to occur, all listeners are removed from the `'end'` event whenever it
-is emitted.
-
-### Impact of "immediate flow" on Tee-streams
-
-A "tee stream" is a stream piping to multiple destinations:
-
-```js
-const tee = new Minipass()
-t.pipe(dest1)
-t.pipe(dest2)
-t.write('foo') // goes to both destinations
-```
-
-Since Minipass streams _immediately_ process any pending data through the
-pipeline when a new pipe destination is added, this can have surprising
-effects, especially when a stream comes in from some other function and may
-or may not have data in its buffer.
-
-```js
-// WARNING! WILL LOSE DATA!
-const src = new Minipass()
-src.write('foo')
-src.pipe(dest1) // 'foo' chunk flows to dest1 immediately, and is gone
-src.pipe(dest2) // gets nothing!
-```
-
-The solution is to create a dedicated tee-stream junction that pipes to
-both locations, and then pipe to _that_ instead.
-
-```js
-// Safe example: tee to both places
-const src = new Minipass()
-src.write('foo')
-const tee = new Minipass()
-tee.pipe(dest1)
-tee.pipe(dest2)
-stream.pipe(tee) // tee gets 'foo', pipes to both locations
-```
-
-The same caveat applies to `on('data')` event listeners.  The first one
-added will _immediately_ receive all of the data, leaving nothing for the
-second:
-
-```js
-// WARNING! WILL LOSE DATA!
-const src = new Minipass()
-src.write('foo')
-src.on('data', handler1) // receives 'foo' right away
-src.on('data', handler2) // nothing to see here!
-```
-
-Using a dedicated tee-stream can be used in this case as well:
-
-```js
-// Safe example: tee to both data handlers
-const src = new Minipass()
-src.write('foo')
-const tee = new Minipass()
-tee.on('data', handler1)
-tee.on('data', handler2)
-src.pipe(tee)
-```
-
-## USAGE
-
-It's a stream!  Use it like a stream and it'll most likely do what you
-want.
-
-```js
-const Minipass = require('minipass')
-const mp = new Minipass(options) // optional: { encoding, objectMode }
-mp.write('foo')
-mp.pipe(someOtherStream)
-mp.end('bar')
-```
-
-### OPTIONS
-
-* `encoding` How would you like the data coming _out_ of the stream to be
-  encoded?  Accepts any values that can be passed to `Buffer.toString()`.
-* `objectMode` Emit data exactly as it comes in.  This will be flipped on
-  by default if you write() something other than a string or Buffer at any
-  point.  Setting `objectMode: true` will prevent setting any encoding
-  value.
-
-### API
-
-Implements the user-facing portions of Node.js's `Readable` and `Writable`
-streams.
-
-### Methods
-
-* `write(chunk, [encoding], [callback])` - Put data in.  (Note that, in the
-  base Minipass class, the same data will come out.)  Returns `false` if
-  the stream will buffer the next write, or true if it's still in "flowing"
-  mode.
-* `end([chunk, [encoding]], [callback])` - Signal that you have no more
-  data to write.  This will queue an `end` event to be fired when all the
-  data has been consumed.
-* `setEncoding(encoding)` - Set the encoding for data coming of the stream.
-  This can only be done once.
-* `pause()` - No more data for a while, please.  This also prevents `end`
-  from being emitted for empty streams until the stream is resumed.
-* `resume()` - Resume the stream.  If there's data in the buffer, it is all
-  discarded.  Any buffered events are immediately emitted.
-* `pipe(dest)` - Send all output to the stream provided.  There is no way
-  to unpipe.  When data is emitted, it is immediately written to any and
-  all pipe destinations.
-* `on(ev, fn)`, `emit(ev, fn)` - Minipass streams are EventEmitters.  Some
-  events are given special treatment, however.  (See below under "events".)
-* `promise()` - Returns a Promise that resolves when the stream emits
-  `end`, or rejects if the stream emits `error`.
-* `collect()` - Return a Promise that resolves on `end` with an array
-  containing each chunk of data that was emitted, or rejects if the stream
-  emits `error`.  Note that this consumes the stream data.
-* `concat()` - Same as `collect()`, but concatenates the data into a single
-  Buffer object.  Will reject the returned promise if the stream is in
-  objectMode, or if it goes into objectMode by the end of the data.
-* `read(n)` - Consume `n` bytes of data out of the buffer.  If `n` is not
-  provided, then consume all of it.  If `n` bytes are not available, then
-  it returns null.  **Note** consuming streams in this way is less
-  efficient, and can lead to unnecessary Buffer copying.
-* `destroy([er])` - Destroy the stream.  If an error is provided, then an
-  `'error'` event is emitted.  If the stream has a `close()` method, and
-  has not emitted a `'close'` event yet, then `stream.close()` will be
-  called.  Any Promises returned by `.promise()`, `.collect()` or
-  `.concat()` will be rejected.  After being destroyed, writing to the
-  stream will emit an error.  No more data will be emitted if the stream is
-  destroyed, even if it was previously buffered.
-
-### Properties
-
-* `bufferLength` Read-only.  Total number of bytes buffered, or in the case
-  of objectMode, the total number of objects.
-* `encoding` The encoding that has been set.  (Setting this is equivalent
-  to calling `setEncoding(enc)` and has the same prohibition against
-  setting multiple times.)
-* `flowing` Read-only.  Boolean indicating whether a chunk written to the
-  stream will be immediately emitted.
-* `emittedEnd` Read-only.  Boolean indicating whether the end-ish events
-  (ie, `end`, `prefinish`, `finish`) have been emitted.  Note that
-  listening on any end-ish event will immediateyl re-emit it if it has
-  already been emitted.
-* `writable` Whether the stream is writable.  Default `true`.  Set to
-  `false` when `end()`
-* `readable` Whether the stream is readable.  Default `true`.
-* `buffer` A [yallist](http://npm.im/yallist) linked list of chunks written
-  to the stream that have not yet been emitted.  (It's probably a bad idea
-  to mess with this.)
-* `pipes` A [yallist](http://npm.im/yallist) linked list of streams that
-  this stream is piping into.  (It's probably a bad idea to mess with
-  this.)
-* `destroyed` A getter that indicates whether the stream was destroyed.
-* `paused` True if the stream has been explicitly paused, otherwise false.
-* `objectMode` Indicates whether the stream is in `objectMode`.  Once set
-  to `true`, it cannot be set to `false`.
-
-### Events
-
-* `data` Emitted when there's data to read.  Argument is the data to read.
-  This is never emitted while not flowing.  If a listener is attached, that
-  will resume the stream.
-* `end` Emitted when there's no more data to read.  This will be emitted
-  immediately for empty streams when `end()` is called.  If a listener is
-  attached, and `end` was already emitted, then it will be emitted again.
-  All listeners are removed when `end` is emitted.
-* `prefinish` An end-ish event that follows the same logic as `end` and is
-  emitted in the same conditions where `end` is emitted.  Emitted after
-  `'end'`.
-* `finish` An end-ish event that follows the same logic as `end` and is
-  emitted in the same conditions where `end` is emitted.  Emitted after
-  `'prefinish'`.
-* `close` An indication that an underlying resource has been released.
-  Minipass does not emit this event, but will defer it until after `end`
-  has been emitted, since it throws off some stream libraries otherwise.
-* `drain` Emitted when the internal buffer empties, and it is again
-  suitable to `write()` into the stream.
-* `readable` Emitted when data is buffered and ready to be read by a
-  consumer.
-* `resume` Emitted when stream changes state from buffering to flowing
-  mode.  (Ie, when `resume` is called, `pipe` is called, or a `data` event
-  listener is added.)
-
-### Static Methods
-
-* `Minipass.isStream(stream)` Returns `true` if the argument is a stream,
-  and false otherwise.  To be considered a stream, the object must be
-  either an instance of Minipass, or an EventEmitter that has either a
-  `pipe()` method, or both `write()` and `end()` methods.  (Pretty much any
-  stream in node-land will return `true` for this.)
-
-## EXAMPLES
-
-Here are some examples of things you can do with Minipass streams.
-
-### simple "are you done yet" promise
-
-```js
-mp.promise().then(() => {
-  // stream is finished
-}, er => {
-  // stream emitted an error
-})
-```
-
-### collecting
-
-```js
-mp.collect().then(all => {
-  // all is an array of all the data emitted
-  // encoding is supported in this case, so
-  // so the result will be a collection of strings if
-  // an encoding is specified, or buffers/objects if not.
-  //
-  // In an async function, you may do
-  // const data = await stream.collect()
-})
-```
-
-### collecting into a single blob
-
-This is a bit slower because it concatenates the data into one chunk for
-you, but if you're going to do it yourself anyway, it's convenient this
-way:
-
-```js
-mp.concat().then(onebigchunk => {
-  // onebigchunk is a string if the stream
-  // had an encoding set, or a buffer otherwise.
-})
-```
-
-### iteration
-
-You can iterate over streams synchronously or asynchronously in platforms
-that support it.
-
-Synchronous iteration will end when the currently available data is
-consumed, even if the `end` event has not been reached.  In string and
-buffer mode, the data is concatenated, so unless multiple writes are
-occurring in the same tick as the `read()`, sync iteration loops will
-generally only have a single iteration.
-
-To consume chunks in this way exactly as they have been written, with no
-flattening, create the stream with the `{ objectMode: true }` option.
-
-```js
-const mp = new Minipass({ objectMode: true })
-mp.write('a')
-mp.write('b')
-for (let letter of mp) {
-  console.log(letter) // a, b
-}
-mp.write('c')
-mp.write('d')
-for (let letter of mp) {
-  console.log(letter) // c, d
-}
-mp.write('e')
-mp.end()
-for (let letter of mp) {
-  console.log(letter) // e
-}
-for (let letter of mp) {
-  console.log(letter) // nothing
-}
-```
-
-Asynchronous iteration will continue until the end event is reached,
-consuming all of the data.
-
-```js
-const mp = new Minipass({ encoding: 'utf8' })
-
-// some source of some data
-let i = 5
-const inter = setInterval(() => {
-  if (i --> 0)
-    mp.write(Buffer.from('foo\n', 'utf8'))
-  else {
-    mp.end()
-    clearInterval(inter)
-  }
-}, 100)
-
-// consume the data with asynchronous iteration
-async function consume () {
-  for await (let chunk of mp) {
-    console.log(chunk)
-  }
-  return 'ok'
-}
-
-consume().then(res => console.log(res))
-// logs `foo\n` 5 times, and then `ok`
-```
-
-### subclass that `console.log()`s everything written into it
-
-```js
-class Logger extends Minipass {
-  write (chunk, encoding, callback) {
-    console.log('WRITE', chunk, encoding)
-    return super.write(chunk, encoding, callback)
-  }
-  end (chunk, encoding, callback) {
-    console.log('END', chunk, encoding)
-    return super.end(chunk, encoding, callback)
-  }
-}
-
-someSource.pipe(new Logger()).pipe(someDest)
-```
-
-### same thing, but using an inline anonymous class
-
-```js
-// js classes are fun
-someSource
-  .pipe(new (class extends Minipass {
-    emit (ev, ...data) {
-      // let's also log events, because debugging some weird thing
-      console.log('EMIT', ev)
-      return super.emit(ev, ...data)
-    }
-    write (chunk, encoding, callback) {
-      console.log('WRITE', chunk, encoding)
-      return super.write(chunk, encoding, callback)
-    }
-    end (chunk, encoding, callback) {
-      console.log('END', chunk, encoding)
-      return super.end(chunk, encoding, callback)
-    }
-  }))
-  .pipe(someDest)
-```
-
-### subclass that defers 'end' for some reason
-
-```js
-class SlowEnd extends Minipass {
-  emit (ev, ...args) {
-    if (ev === 'end') {
-      console.log('going to end, hold on a sec')
-      setTimeout(() => {
-        console.log('ok, ready to end now')
-        super.emit('end', ...args)
-      }, 100)
-    } else {
-      return super.emit(ev, ...args)
-    }
-  }
-}
-```
-
-### transform that creates newline-delimited JSON
-
-```js
-class NDJSONEncode extends Minipass {
-  write (obj, cb) {
-    try {
-      // JSON.stringify can throw, emit an error on that
-      return super.write(JSON.stringify(obj) + '\n', 'utf8', cb)
-    } catch (er) {
-      this.emit('error', er)
-    }
-  }
-  end (obj, cb) {
-    if (typeof obj === 'function') {
-      cb = obj
-      obj = undefined
-    }
-    if (obj !== undefined) {
-      this.write(obj)
-    }
-    return super.end(cb)
-  }
-}
-```
-
-### transform that parses newline-delimited JSON
-
-```js
-class NDJSONDecode extends Minipass {
-  constructor (options) {
-    // always be in object mode, as far as Minipass is concerned
-    super({ objectMode: true })
-    this._jsonBuffer = ''
-  }
-  write (chunk, encoding, cb) {
-    if (typeof chunk === 'string' &&
-        typeof encoding === 'string' &&
-        encoding !== 'utf8') {
-      chunk = Buffer.from(chunk, encoding).toString()
-    } else if (Buffer.isBuffer(chunk))
-      chunk = chunk.toString()
-    }
-    if (typeof encoding === 'function') {
-      cb = encoding
-    }
-    const jsonData = (this._jsonBuffer + chunk).split('\n')
-    this._jsonBuffer = jsonData.pop()
-    for (let i = 0; i < jsonData.length; i++) {
-      let parsed
-      try {
-        super.write(parsed)
-      } catch (er) {
-        this.emit('error', er)
-        continue
-      }
-    }
-    if (cb)
-      cb()
-  }
-}
-```
diff --git a/node_modules/minizlib/node_modules/minipass/index.js b/node_modules/minizlib/node_modules/minipass/index.js
deleted file mode 100644
index 55ea0f3dd..000000000
--- a/node_modules/minizlib/node_modules/minipass/index.js
+++ /dev/null
@@ -1,538 +0,0 @@
-'use strict'
-const EE = require('events')
-const Stream = require('stream')
-const Yallist = require('yallist')
-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 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')
-
-// 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)
-
-module.exports = class Minipass extends Stream {
-  constructor (options) {
-    super()
-    this[FLOWING] = false
-    // whether we're explicitly paused
-    this[PAUSED] = false
-    this.pipes = new Yallist()
-    this.buffer = new Yallist()
-    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[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null
-    this[EOF] = false
-    this[EMITTED_END] = false
-    this[EMITTING_END] = false
-    this[CLOSED] = false
-    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 (ॐ ) { this[OBJECTMODE] = this[OBJECTMODE] || !!ॐ  }
-
-  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'
-
-    // 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
-    }
-
-    // this ensures at this point that the chunk is a buffer or string
-    // don't buffer it up or send it to the decoder
-    if (!this.objectMode && !chunk.length) {
-      const ret = this.flowing
-      if (this[BUFFERLENGTH] !== 0)
-        this.emit('readable')
-      if (cb)
-        cb()
-      return ret
-    }
-
-    // fast-path writing strings of same encoding to a stream with
-    // an empty buffer, skipping the buffer/decoder dance
-    if (typeof chunk === 'string' && !this[OBJECTMODE] &&
-        // 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)
-
-    try {
-      return this.flowing
-        ? (this.emit('data', chunk), this.flowing)
-        : (this[BUFFERPUSH](chunk), false)
-    } finally {
-      if (this[BUFFERLENGTH] !== 0)
-        this.emit('readable')
-      if (cb)
-        cb()
-    }
-  }
-
-  read (n) {
-    if (this[DESTROYED])
-      return null
-
-    try {
-      if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH])
-        return null
-
-      if (this[OBJECTMODE])
-        n = null
-
-      if (this.buffer.length > 1 && !this[OBJECTMODE]) {
-        if (this.encoding)
-          this.buffer = new Yallist([
-            Array.from(this.buffer).join('')
-          ])
-        else
-          this.buffer = new Yallist([
-            Buffer.concat(Array.from(this.buffer), this[BUFFERLENGTH])
-          ])
-      }
-
-      return this[READ](n || null, this.buffer.head.value)
-    } finally {
-      this[MAYBE_EMIT_END]()
-    }
-  }
-
-  [READ] (n, chunk) {
-    if (n === chunk.length || n === null)
-      this[BUFFERSHIFT]()
-    else {
-      this.buffer.head.value = 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
-    return this.buffer.push(chunk)
-  }
-
-  [BUFFERSHIFT] () {
-    if (this.buffer.length) {
-      if (this[OBJECTMODE])
-        this[BUFFERLENGTH] -= 1
-      else
-        this[BUFFERLENGTH] -= this.buffer.head.value.length
-    }
-    return this.buffer.shift()
-  }
-
-  [FLUSH] () {
-    do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()))
-
-    if (!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 === process.stdout || dest === process.stderr)
-      opts.end = false
-    else
-      opts.end = opts.end !== false
-
-    const p = { dest: dest, opts: opts, ondrain: _ => this[RESUME]() }
-    this.pipes.push(p)
-
-    dest.on('drain', p.ondrain)
-    this[RESUME]()
-    // piping an ended stream ends immediately
-    if (ended && p.opts.end)
-      p.dest.end()
-    return dest
-  }
-
-  addListener (ev, fn) {
-    return this.on(ev, fn)
-  }
-
-  on (ev, fn) {
-    try {
-      return super.on(ev, fn)
-    } finally {
-      if (ev === 'data' && !this.pipes.length && !this.flowing)
-        this[RESUME]()
-      else if (isEndish(ev) && this[EMITTED_END]) {
-        super.emit(ev)
-        this.removeAllListeners(ev)
-      }
-    }
-  }
-
-  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) {
-    // error and close are only events allowed after calling destroy()
-    if (ev !== 'error' && ev !== 'close' && ev !== DESTROYED && this[DESTROYED])
-      return
-    else if (ev === 'data') {
-      if (!data)
-        return
-
-      if (this.pipes.length)
-        this.pipes.forEach(p =>
-          p.dest.write(data) === false && this.pause())
-    } else if (ev === 'end') {
-      // only actual end gets this treatment
-      if (this[EMITTED_END] === true)
-        return
-
-      this[EMITTED_END] = true
-      this.readable = false
-
-      if (this[DECODER]) {
-        data = this[DECODER].end()
-        if (data) {
-          this.pipes.forEach(p => p.dest.write(data))
-          super.emit('data', data)
-        }
-      }
-
-      this.pipes.forEach(p => {
-        p.dest.removeListener('drain', p.ondrain)
-        if (p.opts.end)
-          p.dest.end()
-      })
-    } else if (ev === 'close') {
-      this[CLOSED] = true
-      // don't emit close before 'end' and 'finish'
-      if (!this[EMITTED_END] && !this[DESTROYED])
-        return
-    }
-
-    // TODO: replace with a spread operator when Node v4 support drops
-    const args = new Array(arguments.length)
-    args[0] = ev
-    args[1] = data
-    if (arguments.length > 2) {
-      for (let i = 2; i < arguments.length; i++) {
-        args[i] = arguments[i]
-      }
-    }
-
-    try {
-      return super.emit.apply(this, args)
-    } finally {
-      if (!isEndish(ev))
-        this[MAYBE_EMIT_END]()
-      else
-        this.removeAllListeners(ev)
-    }
-  }
-
-  // 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('end', () => resolve())
-      this.on('error', er => reject(er))
-    })
-  }
-
-  // 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 = new Yallist()
-    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
deleted file mode 100644
index 88791e4dd..000000000
--- a/node_modules/minizlib/node_modules/minipass/package.json
+++ /dev/null
@@ -1,72 +0,0 @@
-{
-  "_from": "minipass@^3.0.0",
-  "_id": "minipass@3.1.1",
-  "_inBundle": false,
-  "_integrity": "sha512-UFqVihv6PQgwj8/yTGvl9kPz7xIAY+R5z6XYjRInD3Gk3qx6QGSD6zEcpeG4Dy/lQnv1J6zv8ejV90hyYIKf3w==",
-  "_location": "/minizlib/minipass",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "minipass@^3.0.0",
-    "name": "minipass",
-    "escapedName": "minipass",
-    "rawSpec": "^3.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^3.0.0"
-  },
-  "_requiredBy": [
-    "/minizlib"
-  ],
-  "_resolved": "https://registry.npmjs.org/minipass/-/minipass-3.1.1.tgz",
-  "_shasum": "7607ce778472a185ad6d89082aa2070f79cedcd5",
-  "_spec": "minipass@^3.0.0",
-  "_where": "/Users/claudiahdz/npm/cli/node_modules/minizlib",
-  "author": {
-    "name": "Isaac Z. Schlueter",
-    "email": "i@izs.me",
-    "url": "http://blog.izs.me/"
-  },
-  "bugs": {
-    "url": "https://github.com/isaacs/minipass/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {
-    "yallist": "^4.0.0"
-  },
-  "deprecated": false,
-  "description": "minimal implementation of a PassThrough stream",
-  "devDependencies": {
-    "end-of-stream": "^1.4.0",
-    "tap": "^14.6.5",
-    "through2": "^2.0.3"
-  },
-  "engines": {
-    "node": ">=8"
-  },
-  "files": [
-    "index.js"
-  ],
-  "homepage": "https://github.com/isaacs/minipass#readme",
-  "keywords": [
-    "passthrough",
-    "stream"
-  ],
-  "license": "ISC",
-  "main": "index.js",
-  "name": "minipass",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/isaacs/minipass.git"
-  },
-  "scripts": {
-    "postpublish": "git push origin --follow-tags",
-    "postversion": "npm publish --tag=next",
-    "preversion": "npm test",
-    "test": "tap"
-  },
-  "tap": {
-    "check-coverage": true
-  },
-  "version": "3.1.1"
-}
diff --git a/node_modules/minizlib/node_modules/yallist/LICENSE b/node_modules/minizlib/node_modules/yallist/LICENSE
deleted file mode 100644
index 19129e315..000000000
--- a/node_modules/minizlib/node_modules/yallist/LICENSE
+++ /dev/null
@@ -1,15 +0,0 @@
-The ISC License
-
-Copyright (c) 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/yallist/README.md b/node_modules/minizlib/node_modules/yallist/README.md
deleted file mode 100644
index f58610186..000000000
--- a/node_modules/minizlib/node_modules/yallist/README.md
+++ /dev/null
@@ -1,204 +0,0 @@
-# yallist
-
-Yet Another Linked List
-
-There are many doubly-linked list implementations like it, but this
-one is mine.
-
-For when an array would be too big, and a Map can't be iterated in
-reverse order.
-
-
-[![Build Status](https://travis-ci.org/isaacs/yallist.svg?branch=master)](https://travis-ci.org/isaacs/yallist) [![Coverage Status](https://coveralls.io/repos/isaacs/yallist/badge.svg?service=github)](https://coveralls.io/github/isaacs/yallist)
-
-## basic usage
-
-```javascript
-var yallist = require('yallist')
-var myList = yallist.create([1, 2, 3])
-myList.push('foo')
-myList.unshift('bar')
-// of course pop() and shift() are there, too
-console.log(myList.toArray()) // ['bar', 1, 2, 3, 'foo']
-myList.forEach(function (k) {
-  // walk the list head to tail
-})
-myList.forEachReverse(function (k, index, list) {
-  // walk the list tail to head
-})
-var myDoubledList = myList.map(function (k) {
-  return k + k
-})
-// now myDoubledList contains ['barbar', 2, 4, 6, 'foofoo']
-// mapReverse is also a thing
-var myDoubledListReverse = myList.mapReverse(function (k) {
-  return k + k
-}) // ['foofoo', 6, 4, 2, 'barbar']
-
-var reduced = myList.reduce(function (set, entry) {
-  set += entry
-  return set
-}, 'start')
-console.log(reduced) // 'startfoo123bar'
-```
-
-## api
-
-The whole API is considered "public".
-
-Functions with the same name as an Array method work more or less the
-same way.
-
-There's reverse versions of most things because that's the point.
-
-### Yallist
-
-Default export, the class that holds and manages a list.
-
-Call it with either a forEach-able (like an array) or a set of
-arguments, to initialize the list.
-
-The Array-ish methods all act like you'd expect.  No magic length,
-though, so if you change that it won't automatically prune or add
-empty spots.
-
-### Yallist.create(..)
-
-Alias for Yallist function.  Some people like factories.
-
-#### yallist.head
-
-The first node in the list
-
-#### yallist.tail
-
-The last node in the list
-
-#### yallist.length
-
-The number of nodes in the list.  (Change this at your peril.  It is
-not magic like Array length.)
-
-#### yallist.toArray()
-
-Convert the list to an array.
-
-#### yallist.forEach(fn, [thisp])
-
-Call a function on each item in the list.
-
-#### yallist.forEachReverse(fn, [thisp])
-
-Call a function on each item in the list, in reverse order.
-
-#### yallist.get(n)
-
-Get the data at position `n` in the list.  If you use this a lot,
-probably better off just using an Array.
-
-#### yallist.getReverse(n)
-
-Get the data at position `n`, counting from the tail.
-
-#### yallist.map(fn, thisp)
-
-Create a new Yallist with the result of calling the function on each
-item.
-
-#### yallist.mapReverse(fn, thisp)
-
-Same as `map`, but in reverse.
-
-#### yallist.pop()
-
-Get the data from the list tail, and remove the tail from the list.
-
-#### yallist.push(item, ...)
-
-Insert one or more items to the tail of the list.
-
-#### yallist.reduce(fn, initialValue)
-
-Like Array.reduce.
-
-#### yallist.reduceReverse
-
-Like Array.reduce, but in reverse.
-
-#### yallist.reverse
-
-Reverse the list in place.
-
-#### yallist.shift()
-
-Get the data from the list head, and remove the head from the list.
-
-#### yallist.slice([from], [to])
-
-Just like Array.slice, but returns a new Yallist.
-
-#### yallist.sliceReverse([from], [to])
-
-Just like yallist.slice, but the result is returned in reverse.
-
-#### yallist.toArray()
-
-Create an array representation of the list.
-
-#### yallist.toArrayReverse()
-
-Create a reversed array representation of the list.
-
-#### yallist.unshift(item, ...)
-
-Insert one or more items to the head of the list.
-
-#### yallist.unshiftNode(node)
-
-Move a Node object to the front of the list.  (That is, pull it out of
-wherever it lives, and make it the new head.)
-
-If the node belongs to a different list, then that list will remove it
-first.
-
-#### yallist.pushNode(node)
-
-Move a Node object to the end of the list.  (That is, pull it out of
-wherever it lives, and make it the new tail.)
-
-If the node belongs to a list already, then that list will remove it
-first.
-
-#### yallist.removeNode(node)
-
-Remove a node from the list, preserving referential integrity of head
-and tail and other nodes.
-
-Will throw an error if you try to have a list remove a node that
-doesn't belong to it.
-
-### Yallist.Node
-
-The class that holds the data and is actually the list.
-
-Call with `var n = new Node(value, previousNode, nextNode)`
-
-Note that if you do direct operations on Nodes themselves, it's very
-easy to get into weird states where the list is broken.  Be careful :)
-
-#### node.next
-
-The next node in the list.
-
-#### node.prev
-
-The previous node in the list.
-
-#### node.value
-
-The data the node contains.
-
-#### node.list
-
-The list to which this node belongs.  (Null if it does not belong to
-any list.)
diff --git a/node_modules/minizlib/node_modules/yallist/iterator.js b/node_modules/minizlib/node_modules/yallist/iterator.js
deleted file mode 100644
index d41c97a19..000000000
--- a/node_modules/minizlib/node_modules/yallist/iterator.js
+++ /dev/null
@@ -1,8 +0,0 @@
-'use strict'
-module.exports = function (Yallist) {
-  Yallist.prototype[Symbol.iterator] = function* () {
-    for (let walker = this.head; walker; walker = walker.next) {
-      yield walker.value
-    }
-  }
-}
diff --git a/node_modules/minizlib/node_modules/yallist/package.json b/node_modules/minizlib/node_modules/yallist/package.json
deleted file mode 100644
index b89de41e4..000000000
--- a/node_modules/minizlib/node_modules/yallist/package.json
+++ /dev/null
@@ -1,63 +0,0 @@
-{
-  "_from": "yallist@^4.0.0",
-  "_id": "yallist@4.0.0",
-  "_inBundle": false,
-  "_integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-  "_location": "/minizlib/yallist",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "yallist@^4.0.0",
-    "name": "yallist",
-    "escapedName": "yallist",
-    "rawSpec": "^4.0.0",
-    "saveSpec": null,
-    "fetchSpec": "^4.0.0"
-  },
-  "_requiredBy": [
-    "/minizlib",
-    "/minizlib/minipass"
-  ],
-  "_resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-  "_shasum": "9bb92790d9c0effec63be73519e11a35019a3a72",
-  "_spec": "yallist@^4.0.0",
-  "_where": "/Users/claudiahdz/npm/cli/node_modules/minizlib",
-  "author": {
-    "name": "Isaac Z. Schlueter",
-    "email": "i@izs.me",
-    "url": "http://blog.izs.me/"
-  },
-  "bugs": {
-    "url": "https://github.com/isaacs/yallist/issues"
-  },
-  "bundleDependencies": false,
-  "dependencies": {},
-  "deprecated": false,
-  "description": "Yet Another Linked List",
-  "devDependencies": {
-    "tap": "^12.1.0"
-  },
-  "directories": {
-    "test": "test"
-  },
-  "files": [
-    "yallist.js",
-    "iterator.js"
-  ],
-  "homepage": "https://github.com/isaacs/yallist#readme",
-  "license": "ISC",
-  "main": "yallist.js",
-  "name": "yallist",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/isaacs/yallist.git"
-  },
-  "scripts": {
-    "postpublish": "git push origin --all; git push origin --tags",
-    "postversion": "npm publish",
-    "preversion": "npm test",
-    "test": "tap test/*.js --100"
-  },
-  "version": "4.0.0"
-}
diff --git a/node_modules/minizlib/node_modules/yallist/yallist.js b/node_modules/minizlib/node_modules/yallist/yallist.js
deleted file mode 100644
index 4e83ab1c5..000000000
--- a/node_modules/minizlib/node_modules/yallist/yallist.js
+++ /dev/null
@@ -1,426 +0,0 @@
-'use strict'
-module.exports = Yallist
-
-Yallist.Node = Node
-Yallist.create = Yallist
-
-function Yallist (list) {
-  var self = this
-  if (!(self instanceof Yallist)) {
-    self = new Yallist()
-  }
-
-  self.tail = null
-  self.head = null
-  self.length = 0
-
-  if (list && typeof list.forEach === 'function') {
-    list.forEach(function (item) {
-      self.push(item)
-    })
-  } else if (arguments.length > 0) {
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      self.push(arguments[i])
-    }
-  }
-
-  return self
-}
-
-Yallist.prototype.removeNode = function (node) {
-  if (node.list !== this) {
-    throw new Error('removing node which does not belong to this list')
-  }
-
-  var next = node.next
-  var prev = node.prev
-
-  if (next) {
-    next.prev = prev
-  }
-
-  if (prev) {
-    prev.next = next
-  }
-
-  if (node === this.head) {
-    this.head = next
-  }
-  if (node === this.tail) {
-    this.tail = prev
-  }
-
-  node.list.length--
-  node.next = null
-  node.prev = null
-  node.list = null
-
-  return next
-}
-
-Yallist.prototype.unshiftNode = function (node) {
-  if (node === this.head) {
-    return
-  }
-
-  if (node.list) {
-    node.list.removeNode(node)
-  }
-
-  var head = this.head
-  node.list = this
-  node.next = head
-  if (head) {
-    head.prev = node
-  }
-
-  this.head = node
-  if (!this.tail) {
-    this.tail = node
-  }
-  this.length++
-}
-
-Yallist.prototype.pushNode = function (node) {
-  if (node === this.tail) {
-    return
-  }
-
-  if (node.list) {
-    node.list.removeNode(node)
-  }
-
-  var tail = this.tail
-  node.list = this
-  node.prev = tail
-  if (tail) {
-    tail.next = node
-  }
-
-  this.tail = node
-  if (!this.head) {
-    this.head = node
-  }
-  this.length++
-}
-
-Yallist.prototype.push = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    push(this, arguments[i])
-  }
-  return this.length
-}
-
-Yallist.prototype.unshift = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    unshift(this, arguments[i])
-  }
-  return this.length
-}
-
-Yallist.prototype.pop = function () {
-  if (!this.tail) {
-    return undefined
-  }
-
-  var res = this.tail.value
-  this.tail = this.tail.prev
-  if (this.tail) {
-    this.tail.next = null
-  } else {
-    this.head = null
-  }
-  this.length--
-  return res
-}
-
-Yallist.prototype.shift = function () {
-  if (!this.head) {
-    return undefined
-  }
-
-  var res = this.head.value
-  this.head = this.head.next
-  if (this.head) {
-    this.head.prev = null
-  } else {
-    this.tail = null
-  }
-  this.length--
-  return res
-}
-
-Yallist.prototype.forEach = function (fn, thisp) {
-  thisp = thisp || this
-  for (var walker = this.head, i = 0; walker !== null; i++) {
-    fn.call(thisp, walker.value, i, this)
-    walker = walker.next
-  }
-}
-
-Yallist.prototype.forEachReverse = function (fn, thisp) {
-  thisp = thisp || this
-  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
-    fn.call(thisp, walker.value, i, this)
-    walker = walker.prev
-  }
-}
-
-Yallist.prototype.get = function (n) {
-  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.next
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-}
-
-Yallist.prototype.getReverse = function (n) {
-  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.prev
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-}
-
-Yallist.prototype.map = function (fn, thisp) {
-  thisp = thisp || this
-  var res = new Yallist()
-  for (var walker = this.head; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this))
-    walker = walker.next
-  }
-  return res
-}
-
-Yallist.prototype.mapReverse = function (fn, thisp) {
-  thisp = thisp || this
-  var res = new Yallist()
-  for (var walker = this.tail; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this))
-    walker = walker.prev
-  }
-  return res
-}
-
-Yallist.prototype.reduce = function (fn, initial) {
-  var acc
-  var walker = this.head
-  if (arguments.length > 1) {
-    acc = initial
-  } else if (this.head) {
-    walker = this.head.next
-    acc = this.head.value
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
-
-  for (var i = 0; walker !== null; i++) {
-    acc = fn(acc, walker.value, i)
-    walker = walker.next
-  }
-
-  return acc
-}
-
-Yallist.prototype.reduceReverse = function (fn, initial) {
-  var acc
-  var walker = this.tail
-  if (arguments.length > 1) {
-    acc = initial
-  } else if (this.tail) {
-    walker = this.tail.prev
-    acc = this.tail.value
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
-
-  for (var i = this.length - 1; walker !== null; i--) {
-    acc = fn(acc, walker.value, i)
-    walker = walker.prev
-  }
-
-  return acc
-}
-
-Yallist.prototype.toArray = function () {
-  var arr = new Array(this.length)
-  for (var i = 0, walker = this.head; walker !== null; i++) {
-    arr[i] = walker.value
-    walker = walker.next
-  }
-  return arr
-}
-
-Yallist.prototype.toArrayReverse = function () {
-  var arr = new Array(this.length)
-  for (var i = 0, walker = this.tail; walker !== null; i++) {
-    arr[i] = walker.value
-    walker = walker.prev
-  }
-  return arr
-}
-
-Yallist.prototype.slice = function (from, to) {
-  to = to || this.length
-  if (to < 0) {
-    to += this.length
-  }
-  from = from || 0
-  if (from < 0) {
-    from += this.length
-  }
-  var ret = new Yallist()
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0
-  }
-  if (to > this.length) {
-    to = this.length
-  }
-  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
-    walker = walker.next
-  }
-  for (; walker !== null && i < to; i++, walker = walker.next) {
-    ret.push(walker.value)
-  }
-  return ret
-}
-
-Yallist.prototype.sliceReverse = function (from, to) {
-  to = to || this.length
-  if (to < 0) {
-    to += this.length
-  }
-  from = from || 0
-  if (from < 0) {
-    from += this.length
-  }
-  var ret = new Yallist()
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0
-  }
-  if (to > this.length) {
-    to = this.length
-  }
-  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-    walker = walker.prev
-  }
-  for (; walker !== null && i > from; i--, walker = walker.prev) {
-    ret.push(walker.value)
-  }
-  return ret
-}
-
-Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
-  if (start > this.length) {
-    start = this.length - 1
-  }
-  if (start < 0) {
-    start = this.length + start;
-  }
-
-  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-    walker = walker.next
-  }
-
-  var ret = []
-  for (var i = 0; walker && i < deleteCount; i++) {
-    ret.push(walker.value)
-    walker = this.removeNode(walker)
-  }
-  if (walker === null) {
-    walker = this.tail
-  }
-
-  if (walker !== this.head && walker !== this.tail) {
-    walker = walker.prev
-  }
-
-  for (var i = 0; i < nodes.length; i++) {
-    walker = insert(this, walker, nodes[i])
-  }
-  return ret;
-}
-
-Yallist.prototype.reverse = function () {
-  var head = this.head
-  var tail = this.tail
-  for (var walker = head; walker !== null; walker = walker.prev) {
-    var p = walker.prev
-    walker.prev = walker.next
-    walker.next = p
-  }
-  this.head = tail
-  this.tail = head
-  return this
-}
-
-function insert (self, node, value) {
-  var inserted = node === self.head ?
-    new Node(value, null, node, self) :
-    new Node(value, node, node.next, self)
-
-  if (inserted.next === null) {
-    self.tail = inserted
-  }
-  if (inserted.prev === null) {
-    self.head = inserted
-  }
-
-  self.length++
-
-  return inserted
-}
-
-function push (self, item) {
-  self.tail = new Node(item, self.tail, null, self)
-  if (!self.head) {
-    self.head = self.tail
-  }
-  self.length++
-}
-
-function unshift (self, item) {
-  self.head = new Node(item, null, self.head, self)
-  if (!self.tail) {
-    self.tail = self.head
-  }
-  self.length++
-}
-
-function Node (value, prev, next, list) {
-  if (!(this instanceof Node)) {
-    return new Node(value, prev, next, list)
-  }
-
-  this.list = list
-  this.value = value
-
-  if (prev) {
-    prev.next = this
-    this.prev = prev
-  } else {
-    this.prev = null
-  }
-
-  if (next) {
-    next.prev = this
-    this.next = next
-  } else {
-    this.next = null
-  }
-}
-
-try {
-  // add if support for Symbol.iterator is present
-  require('./iterator.js')(Yallist)
-} catch (er) {}