From 0a30b0d8a1c448b6d89d781ad81f46117d014953 Mon Sep 17 00:00:00 2001
From: claudiahdz <cghr1990@gmail.com>
Date: Thu, 6 Feb 2020 15:43:20 -0500
Subject: tar@6.0.1

---
 node_modules/fs-minipass/index.js                  | 103 +++--
 .../fs-minipass/node_modules/minipass/README.md    |  76 ++--
 .../fs-minipass/node_modules/minipass/index.js     |  45 +--
 .../fs-minipass/node_modules/minipass/package.json |  30 +-
 .../fs-minipass/node_modules/yallist/LICENSE       |  15 +
 .../fs-minipass/node_modules/yallist/README.md     | 204 ++++++++++
 .../fs-minipass/node_modules/yallist/iterator.js   |   8 +
 .../fs-minipass/node_modules/yallist/package.json  |  62 +++
 .../fs-minipass/node_modules/yallist/yallist.js    | 426 +++++++++++++++++++++
 node_modules/fs-minipass/package.json              |  32 +-
 10 files changed, 877 insertions(+), 124 deletions(-)
 create mode 100644 node_modules/fs-minipass/node_modules/yallist/LICENSE
 create mode 100644 node_modules/fs-minipass/node_modules/yallist/README.md
 create mode 100644 node_modules/fs-minipass/node_modules/yallist/iterator.js
 create mode 100644 node_modules/fs-minipass/node_modules/yallist/package.json
 create mode 100644 node_modules/fs-minipass/node_modules/yallist/yallist.js

(limited to 'node_modules/fs-minipass')

diff --git a/node_modules/fs-minipass/index.js b/node_modules/fs-minipass/index.js
index cd585a83c..9b0779c80 100644
--- a/node_modules/fs-minipass/index.js
+++ b/node_modules/fs-minipass/index.js
@@ -3,11 +3,21 @@ const MiniPass = require('minipass')
 const EE = require('events').EventEmitter
 const fs = require('fs')
 
-// for writev
-const binding = process.binding('fs')
-const writeBuffers = binding.writeBuffers
+let writev = fs.writev
 /* istanbul ignore next */
-const FSReqWrap = binding.FSReqWrap || binding.FSReqCallback
+if (!writev) {
+  // This entire block can be removed if support for earlier than Node.js
+  // 12.9.0 is not needed.
+  const binding = process.binding('fs')
+  const FSReqWrap = binding.FSReqWrap || binding.FSReqCallback
+
+  writev = (fd, iovec, pos, cb) => {
+    const done = (er, bw) => cb(er, bw, iovec)
+    const req = new FSReqWrap()
+    req.oncomplete = done
+    binding.writeBuffers(fd, iovec, pos, req)
+  }
+}
 
 const _autoClose = Symbol('_autoClose')
 const _close = Symbol('_close')
@@ -36,17 +46,20 @@ const _size = Symbol('_size')
 const _write = Symbol('_write')
 const _writing = Symbol('_writing')
 const _defaultFlag = Symbol('_defaultFlag')
+const _errored = Symbol('_errored')
 
 class ReadStream extends MiniPass {
   constructor (path, opt) {
     opt = opt || {}
     super(opt)
 
+    this.readable = true
     this.writable = false
 
     if (typeof path !== 'string')
       throw new TypeError('path must be a string')
 
+    this[_errored] = false
     this[_fd] = typeof opt.fd === 'number' ? opt.fd : null
     this[_path] = path
     this[_readSize] = opt.readSize || 16*1024*1024
@@ -96,7 +109,8 @@ class ReadStream extends MiniPass {
       this[_reading] = true
       const buf = this[_makeBuf]()
       /* istanbul ignore if */
-      if (buf.length === 0) return process.nextTick(() => this[_onread](null, 0, buf))
+      if (buf.length === 0)
+        return process.nextTick(() => this[_onread](null, 0, buf))
       fs.read(this[_fd], buf, 0, buf.length, null, (er, br, buf) =>
         this[_onread](er, br, buf))
     }
@@ -112,8 +126,9 @@ class ReadStream extends MiniPass {
 
   [_close] () {
     if (this[_autoClose] && typeof this[_fd] === 'number') {
-      fs.close(this[_fd], _ => this.emit('close'))
+      const fd = this[_fd]
       this[_fd] = null
+      fs.close(fd, er => er ? this.emit('error', er) : this.emit('close'))
     }
   }
 
@@ -150,6 +165,12 @@ class ReadStream extends MiniPass {
           this[_read]()
         break
 
+      case 'error':
+        if (this[_errored])
+          return
+        this[_errored] = true
+        return super.emit(ev, data)
+
       default:
         return super.emit(ev, data)
     }
@@ -176,7 +197,8 @@ class ReadStreamSync extends ReadStream {
         do {
           const buf = this[_makeBuf]()
           /* istanbul ignore next */
-          const br = buf.length === 0 ? 0 : fs.readSync(this[_fd], buf, 0, buf.length, null)
+          const br = buf.length === 0 ? 0
+            : fs.readSync(this[_fd], buf, 0, buf.length, null)
           if (!this[_handleChunk](br, buf))
             break
         } while (true)
@@ -191,10 +213,9 @@ class ReadStreamSync extends ReadStream {
 
   [_close] () {
     if (this[_autoClose] && typeof this[_fd] === 'number') {
-      try {
-        fs.closeSync(this[_fd])
-      } catch (er) {}
+      const fd = this[_fd]
       this[_fd] = null
+      fs.closeSync(fd)
       this.emit('close')
     }
   }
@@ -205,6 +226,8 @@ class WriteStream extends EE {
     opt = opt || {}
     super(opt)
     this.readable = false
+    this.writable = true
+    this[_errored] = false
     this[_writing] = false
     this[_ended] = false
     this[_needDrain] = false
@@ -225,6 +248,16 @@ class WriteStream extends EE {
       this[_open]()
   }
 
+  emit (ev, data) {
+    if (ev === 'error') {
+      if (this[_errored])
+        return
+      this[_errored] = true
+    }
+    return super.emit(ev, data)
+  }
+
+
   get fd () { return this[_fd] }
   get path () { return this[_path] }
 
@@ -264,11 +297,12 @@ class WriteStream extends EE {
     if (!this[_writing] && !this[_queue].length &&
         typeof this[_fd] === 'number')
       this[_onwrite](null, 0)
+    return this
   }
 
   write (buf, enc) {
     if (typeof buf === 'string')
-      buf = new Buffer(buf, enc)
+      buf = Buffer.from(buf, enc)
 
     if (this[_ended]) {
       this.emit('error', new Error('write() after end()'))
@@ -330,8 +364,9 @@ class WriteStream extends EE {
 
   [_close] () {
     if (this[_autoClose] && typeof this[_fd] === 'number') {
-      fs.close(this[_fd], _ => this.emit('close'))
+      const fd = this[_fd]
       this[_fd] = null
+      fs.close(fd, er => er ? this.emit('error', er) : this.emit('close'))
     }
   }
 }
@@ -339,47 +374,47 @@ class WriteStream extends EE {
 class WriteStreamSync extends WriteStream {
   [_open] () {
     let fd
-    try {
+    // only wrap in a try{} block if we know we'll retry, to avoid
+    // the rethrow obscuring the error's source frame in most cases.
+    if (this[_defaultFlag] && this[_flags] === 'r+') {
+      try {
+        fd = fs.openSync(this[_path], this[_flags], this[_mode])
+      } catch (er) {
+        if (er.code === 'ENOENT') {
+          this[_flags] = 'w'
+          return this[_open]()
+        } else
+          throw er
+      }
+    } else
       fd = fs.openSync(this[_path], this[_flags], this[_mode])
-    } catch (er) {
-      if (this[_defaultFlag] &&
-          this[_flags] === 'r+' &&
-          er && er.code === 'ENOENT') {
-        this[_flags] = 'w'
-        return this[_open]()
-      } else
-        throw er
-    }
+
     this[_onopen](null, fd)
   }
 
   [_close] () {
     if (this[_autoClose] && typeof this[_fd] === 'number') {
-      try {
-        fs.closeSync(this[_fd])
-      } catch (er) {}
+      const fd = this[_fd]
       this[_fd] = null
+      fs.closeSync(fd)
       this.emit('close')
     }
   }
 
   [_write] (buf) {
+    // throw the original, but try to close if it fails
+    let threw = true
     try {
       this[_onwrite](null,
         fs.writeSync(this[_fd], buf, 0, buf.length, this[_pos]))
-    } catch (er) {
-      this[_onwrite](er, 0)
+      threw = false
+    } finally {
+      if (threw)
+        try { this[_close]() } catch (_) {}
     }
   }
 }
 
-const writev = (fd, iovec, pos, cb) => {
-  const done = (er, bw) => cb(er, bw, iovec)
-  const req = new FSReqWrap()
-  req.oncomplete = done
-  binding.writeBuffers(fd, iovec, pos, req)
-}
-
 exports.ReadStream = ReadStream
 exports.ReadStreamSync = ReadStreamSync
 
diff --git a/node_modules/fs-minipass/node_modules/minipass/README.md b/node_modules/fs-minipass/node_modules/minipass/README.md
index c989beea0..32ace2fb9 100644
--- a/node_modules/fs-minipass/node_modules/minipass/README.md
+++ b/node_modules/fs-minipass/node_modules/minipass/README.md
@@ -7,32 +7,32 @@ stream](https://nodejs.org/api/stream.html#stream_class_stream_passthrough)
 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.
+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 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!
+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.
+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.
+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:
@@ -46,6 +46,7 @@ out:
 - [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
 
@@ -252,7 +253,8 @@ src.pipe(tee)
 
 ## USAGE
 
-It's a stream!  Use it like a stream and it'll most likely do what you want.
+It's a stream!  Use it like a stream and it'll most likely do what you
+want.
 
 ```js
 const Minipass = require('minipass')
@@ -280,31 +282,30 @@ streams.
 
 * `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.
+  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.
+* `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.
+* `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".)
+* `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.
+  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
@@ -421,8 +422,8 @@ mp.concat().then(onebigchunk => {
 
 ### iteration
 
-You can iterate over streams synchronously or asynchronously in
-platforms that support it.
+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
@@ -430,9 +431,8 @@ 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.
+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 })
diff --git a/node_modules/fs-minipass/node_modules/minipass/index.js b/node_modules/fs-minipass/node_modules/minipass/index.js
index c072352d4..55ea0f3dd 100644
--- a/node_modules/fs-minipass/node_modules/minipass/index.js
+++ b/node_modules/fs-minipass/node_modules/minipass/index.js
@@ -1,5 +1,6 @@
 'use strict'
 const EE = require('events')
+const Stream = require('stream')
 const Yallist = require('yallist')
 const SD = require('string_decoder').StringDecoder
 
@@ -29,12 +30,6 @@ const ASYNCITERATOR = doIter && Symbol.asyncIterator
 const ITERATOR = doIter && Symbol.iterator
   || Symbol('iterator not implemented')
 
-// Buffer in node 4.x < 4.5.0 doesn't have working Buffer.from
-// or Buffer.alloc, and Buffer in node 10 deprecated the ctor.
-// .M, this is fine .\^/M..
-const B = Buffer.alloc ? Buffer
-  : /* istanbul ignore next */ require('safe-buffer').Buffer
-
 // events that mean 'the stream is over'
 // these are treated specially, and re-emitted
 // if they are listened for after emitting.
@@ -49,9 +44,9 @@ const isArrayBuffer = b => b instanceof ArrayBuffer ||
   b.constructor.name === 'ArrayBuffer' &&
   b.byteLength >= 0
 
-const isArrayBufferView = b => !B.isBuffer(b) && ArrayBuffer.isView(b)
+const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b)
 
-module.exports = class Minipass extends EE {
+module.exports = class Minipass extends Stream {
   constructor (options) {
     super()
     this[FLOWING] = false
@@ -126,11 +121,11 @@ module.exports = class Minipass extends EE {
     // 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] && !B.isBuffer(chunk)) {
+    if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
       if (isArrayBufferView(chunk))
-        chunk = B.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+        chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
       else if (isArrayBuffer(chunk))
-        chunk = B.from(chunk)
+        chunk = Buffer.from(chunk)
       else if (typeof chunk !== 'string')
         // use the setter so we throw if we have encoding set
         this.objectMode = true
@@ -152,10 +147,10 @@ module.exports = class Minipass extends EE {
     if (typeof chunk === 'string' && !this[OBJECTMODE] &&
         // unless it is a string already ready for us to use
         !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
-      chunk = B.from(chunk, encoding)
+      chunk = Buffer.from(chunk, encoding)
     }
 
-    if (B.isBuffer(chunk) && this[ENCODING])
+    if (Buffer.isBuffer(chunk) && this[ENCODING])
       chunk = this[DECODER].write(chunk)
 
     try {
@@ -188,7 +183,7 @@ module.exports = class Minipass extends EE {
           ])
         else
           this.buffer = new Yallist([
-            B.concat(Array.from(this.buffer), this[BUFFERLENGTH])
+            Buffer.concat(Array.from(this.buffer), this[BUFFERLENGTH])
           ])
       }
 
@@ -423,12 +418,17 @@ module.exports = class Minipass extends EE {
   // const all = await stream.collect()
   collect () {
     const buf = []
-    buf.dataLength = 0
+    if (!this[OBJECTMODE])
+      buf.dataLength = 0
+    // set the promise first, in case an error is raised
+    // by triggering the flow here.
+    const p = this.promise()
     this.on('data', c => {
       buf.push(c)
-      buf.dataLength += c.length
+      if (!this[OBJECTMODE])
+        buf.dataLength += c.length
     })
-    return this.promise().then(() => buf)
+    return p.then(() => buf)
   }
 
   // const data = await stream.concat()
@@ -438,7 +438,7 @@ module.exports = class Minipass extends EE {
       : this.collect().then(buf =>
           this[OBJECTMODE]
             ? Promise.reject(new Error('cannot concat in objectMode'))
-            : this[ENCODING] ? buf.join('') : B.concat(buf, buf.dataLength))
+            : this[ENCODING] ? buf.join('') : Buffer.concat(buf, buf.dataLength))
   }
 
   // stream.promise().then(() => done, er => emitted error)
@@ -529,9 +529,10 @@ module.exports = class Minipass extends EE {
   }
 
   static isStream (s) {
-    return !!s && (s instanceof Minipass || s instanceof EE && (
-      typeof s.pipe === 'function' || // readable
-      (typeof s.write === 'function' && typeof s.end === 'function') // writable
-    ))
+    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
index 416e231c9..e125bc7dc 100644
--- a/node_modules/fs-minipass/node_modules/minipass/package.json
+++ b/node_modules/fs-minipass/node_modules/minipass/package.json
@@ -1,27 +1,27 @@
 {
-  "_from": "minipass@^2.6.0",
-  "_id": "minipass@2.9.0",
+  "_from": "minipass@^3.0.0",
+  "_id": "minipass@3.1.1",
   "_inBundle": false,
-  "_integrity": "sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==",
+  "_integrity": "sha512-UFqVihv6PQgwj8/yTGvl9kPz7xIAY+R5z6XYjRInD3Gk3qx6QGSD6zEcpeG4Dy/lQnv1J6zv8ejV90hyYIKf3w==",
   "_location": "/fs-minipass/minipass",
   "_phantomChildren": {},
   "_requested": {
     "type": "range",
     "registry": true,
-    "raw": "minipass@^2.6.0",
+    "raw": "minipass@^3.0.0",
     "name": "minipass",
     "escapedName": "minipass",
-    "rawSpec": "^2.6.0",
+    "rawSpec": "^3.0.0",
     "saveSpec": null,
-    "fetchSpec": "^2.6.0"
+    "fetchSpec": "^3.0.0"
   },
   "_requiredBy": [
     "/fs-minipass"
   ],
-  "_resolved": "https://registry.npmjs.org/minipass/-/minipass-2.9.0.tgz",
-  "_shasum": "e713762e7d3e32fed803115cf93e04bca9fcc9a6",
-  "_spec": "minipass@^2.6.0",
-  "_where": "/Users/mperrotte/npminc/cli/node_modules/fs-minipass",
+  "_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/fs-minipass",
   "author": {
     "name": "Isaac Z. Schlueter",
     "email": "i@izs.me",
@@ -32,8 +32,7 @@
   },
   "bundleDependencies": false,
   "dependencies": {
-    "safe-buffer": "^5.1.2",
-    "yallist": "^3.0.0"
+    "yallist": "^4.0.0"
   },
   "deprecated": false,
   "description": "minimal implementation of a PassThrough stream",
@@ -42,6 +41,9 @@
     "tap": "^14.6.5",
     "through2": "^2.0.3"
   },
+  "engines": {
+    "node": ">=8"
+  },
   "files": [
     "index.js"
   ],
@@ -59,12 +61,12 @@
   },
   "scripts": {
     "postpublish": "git push origin --follow-tags",
-    "postversion": "npm publish",
+    "postversion": "npm publish --tag=next",
     "preversion": "npm test",
     "test": "tap"
   },
   "tap": {
     "check-coverage": true
   },
-  "version": "2.9.0"
+  "version": "3.1.1"
 }
diff --git a/node_modules/fs-minipass/node_modules/yallist/LICENSE b/node_modules/fs-minipass/node_modules/yallist/LICENSE
new file mode 100644
index 000000000..19129e315
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/yallist/LICENSE
@@ -0,0 +1,15 @@
+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/fs-minipass/node_modules/yallist/README.md b/node_modules/fs-minipass/node_modules/yallist/README.md
new file mode 100644
index 000000000..f58610186
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/yallist/README.md
@@ -0,0 +1,204 @@
+# 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/fs-minipass/node_modules/yallist/iterator.js b/node_modules/fs-minipass/node_modules/yallist/iterator.js
new file mode 100644
index 000000000..d41c97a19
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/yallist/iterator.js
@@ -0,0 +1,8 @@
+'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/fs-minipass/node_modules/yallist/package.json b/node_modules/fs-minipass/node_modules/yallist/package.json
new file mode 100644
index 000000000..cdfd89afb
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/yallist/package.json
@@ -0,0 +1,62 @@
+{
+  "_from": "yallist@^4.0.0",
+  "_id": "yallist@4.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+  "_location": "/fs-minipass/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": [
+    "/fs-minipass/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/fs-minipass/node_modules/minipass",
+  "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/fs-minipass/node_modules/yallist/yallist.js b/node_modules/fs-minipass/node_modules/yallist/yallist.js
new file mode 100644
index 000000000..4e83ab1c5
--- /dev/null
+++ b/node_modules/fs-minipass/node_modules/yallist/yallist.js
@@ -0,0 +1,426 @@
+'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) {}
diff --git a/node_modules/fs-minipass/package.json b/node_modules/fs-minipass/package.json
index 870d08f6f..01635bd8d 100644
--- a/node_modules/fs-minipass/package.json
+++ b/node_modules/fs-minipass/package.json
@@ -1,30 +1,27 @@
 {
-  "_from": "fs-minipass@^1.2.5",
-  "_id": "fs-minipass@1.2.7",
+  "_from": "fs-minipass@^2.0.0",
+  "_id": "fs-minipass@2.1.0",
   "_inBundle": false,
-  "_integrity": "sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==",
+  "_integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
   "_location": "/fs-minipass",
-  "_phantomChildren": {
-    "safe-buffer": "5.1.2",
-    "yallist": "3.0.3"
-  },
+  "_phantomChildren": {},
   "_requested": {
     "type": "range",
     "registry": true,
-    "raw": "fs-minipass@^1.2.5",
+    "raw": "fs-minipass@^2.0.0",
     "name": "fs-minipass",
     "escapedName": "fs-minipass",
-    "rawSpec": "^1.2.5",
+    "rawSpec": "^2.0.0",
     "saveSpec": null,
-    "fetchSpec": "^1.2.5"
+    "fetchSpec": "^2.0.0"
   },
   "_requiredBy": [
     "/tar"
   ],
-  "_resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.7.tgz",
-  "_shasum": "ccff8570841e7fe4265693da88936c55aed7f7c7",
-  "_spec": "fs-minipass@^1.2.5",
-  "_where": "/Users/mperrotte/npminc/cli/node_modules/tar",
+  "_resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+  "_shasum": "7f5036fdbf12c63c169190cbe4199c852271f9fb",
+  "_spec": "fs-minipass@^2.0.0",
+  "_where": "/Users/claudiahdz/npm/cli/node_modules/tar",
   "author": {
     "name": "Isaac Z. Schlueter",
     "email": "i@izs.me",
@@ -35,7 +32,7 @@
   },
   "bundleDependencies": false,
   "dependencies": {
-    "minipass": "^2.6.0"
+    "minipass": "^3.0.0"
   },
   "deprecated": false,
   "description": "fs read and write streams based on minipass",
@@ -43,6 +40,9 @@
     "mutate-fs": "^2.0.1",
     "tap": "^14.6.4"
   },
+  "engines": {
+    "node": ">= 8"
+  },
   "files": [
     "index.js"
   ],
@@ -64,5 +64,5 @@
   "tap": {
     "check-coverage": true
   },
-  "version": "1.2.7"
+  "version": "2.1.0"
 }
-- 
cgit v1.2.3