text: require('./sourcemap-register.js');module.exports =
  /******/ (function(modules, runtime) { // webpackBootstrap
  /******/ 	"use strict";
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/
  /******/ 	// the startup function
  /******/ 	function startup() {
  /******/ 		// Load entry module and return exports
  /******/ 		return __webpack_require__(174);
  /******/ 	};
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 10:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  var RetryOperation = __webpack_require__(35);
  
  exports.operation = function(options) {
    var timeouts = exports.timeouts(options);
    return new RetryOperation(timeouts, {
        forever: options && options.forever,
        unref: options && options.unref,
        maxRetryTime: options && options.maxRetryTime
    });
  };
  
  exports.timeouts = function(options) {
    if (options instanceof Array) {
      return [].concat(options);
    }
  
    var opts = {
      retries: 10,
      factor: 2,
      minTimeout: 1 * 1000,
      maxTimeout: Infinity,
      randomize: false
    };
    for (var key in options) {
      opts[key] = options[key];
    }
  
    if (opts.minTimeout > opts.maxTimeout) {
      throw new Error('minTimeout is greater than maxTimeout');
    }
  
    var timeouts = [];
    for (var i = 0; i < opts.retries; i++) {
      timeouts.push(this.createTimeout(i, opts));
    }
  
    if (options && options.forever && !timeouts.length) {
      timeouts.push(this.createTimeout(i, opts));
    }
  
    // sort the array numerically ascending
    timeouts.sort(function(a,b) {
      return a - b;
    });
  
    return timeouts;
  };
  
  exports.createTimeout = function(attempt, opts) {
    var random = (opts.randomize)
      ? (Math.random() + 1)
      : 1;
  
    var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
    timeout = Math.min(timeout, opts.maxTimeout);
  
    return timeout;
  };
  
  exports.wrap = function(obj, options, methods) {
    if (options instanceof Array) {
      methods = options;
      options = null;
    }
  
    if (!methods) {
      methods = [];
      for (var key in obj) {
        if (typeof obj[key] === 'function') {
          methods.push(key);
        }
      }
    }
  
    for (var i = 0; i < methods.length; i++) {
      var method   = methods[i];
      var original = obj[method];
  
      obj[method] = function retryWrapper(original) {
        var op       = exports.operation(options);
        var args     = Array.prototype.slice.call(arguments, 1);
        var callback = args.pop();
  
        args.push(function(err) {
          if (op.retry(err)) {
            return;
          }
          if (err) {
            arguments[0] = op.mainError();
          }
          callback.apply(this, arguments);
        });
  
        op.attempt(function() {
          original.apply(obj, args);
        });
      }.bind(obj, original);
      obj[method].options = options;
    }
  };
  
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module) {
  
  // Returns a wrapper function that returns a wrapped callback
  // The wrapper function should do some stuff, and return a
  // presumably different callback function.
  // This makes sure that own properties are retained, so that
  // decorations and such are not lost along the way.
  module.exports = wrappy
  function wrappy (fn, cb) {
    if (fn && cb) return wrappy(fn)(cb)
  
    if (typeof fn !== 'function')
      throw new TypeError('need wrapper function')
  
    Object.keys(fn).forEach(function (k) {
      wrapper[k] = fn[k]
    })
  
    return wrapper
  
    function wrapper() {
      var args = new Array(arguments.length)
      for (var i = 0; i < args.length; i++) {
        args[i] = arguments[i]
      }
      var ret = fn.apply(this, args)
      var cb = args[args.length-1]
      if (typeof ret === 'function' && ret !== cb) {
        Object.keys(cb).forEach(function (k) {
          ret[k] = cb[k]
        })
      }
      return ret
    }
  }
  
  
  /***/ }),
  
  /***/ 19:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  // TODO: enable this once graceful-fs supports bigint option.
  // const fs = require('graceful-fs')
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  const copySync = __webpack_require__(914).copySync
  const removeSync = __webpack_require__(812).removeSync
  const mkdirpSync = __webpack_require__(562).mkdirpSync
  const stat = __webpack_require__(150)
  
  function moveSync (src, dest, opts) {
    opts = opts || {}
    const overwrite = opts.overwrite || opts.clobber || false
  
    const { srcStat } = stat.checkPathsSync(src, dest, 'move')
    stat.checkParentPathsSync(src, srcStat, dest, 'move')
    mkdirpSync(path.dirname(dest))
    return doRename(src, dest, overwrite)
  }
  
  function doRename (src, dest, overwrite) {
    if (overwrite) {
      removeSync(dest)
      return rename(src, dest, overwrite)
    }
    if (fs.existsSync(dest)) throw new Error('dest already exists.')
    return rename(src, dest, overwrite)
  }
  
  function rename (src, dest, overwrite) {
    try {
      fs.renameSync(src, dest)
    } catch (err) {
      if (err.code !== 'EXDEV') throw err
      return moveAcrossDevice(src, dest, overwrite)
    }
  }
  
  function moveAcrossDevice (src, dest, overwrite) {
    const opts = {
      overwrite,
      errorOnExist: true
    }
    copySync(src, dest, opts)
    return removeSync(src)
  }
  
  module.exports = moveSync
  
  
  /***/ }),
  
  /***/ 20:
  /***/ (function(module) {
  
  module.exports = function (xs, fn) {
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = fn(xs[i], i);
          if (isArray(x)) res.push.apply(res, x);
          else res.push(x);
      }
      return res;
  };
  
  var isArray = Array.isArray || function (xs) {
      return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  
  /***/ }),
  
  /***/ 28:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  const mkdir = __webpack_require__(562)
  const remove = __webpack_require__(812)
  
  const emptyDir = u(function emptyDir (dir, callback) {
    callback = callback || function () {}
    fs.readdir(dir, (err, items) => {
      if (err) return mkdir.mkdirs(dir, callback)
  
      items = items.map(item => path.join(dir, item))
  
      deleteItem()
  
      function deleteItem () {
        const item = items.pop()
        if (!item) return callback()
        remove.remove(item, err => {
          if (err) return callback(err)
          deleteItem()
        })
      }
    })
  })
  
  function emptyDirSync (dir) {
    let items
    try {
      items = fs.readdirSync(dir)
    } catch (err) {
      return mkdir.mkdirsSync(dir)
    }
  
    items.forEach(item => {
      item = path.join(dir, item)
      remove.removeSync(item)
    })
  }
  
  module.exports = {
    emptyDirSync,
    emptydirSync: emptyDirSync,
    emptyDir,
    emptydir: emptyDir
  }
  
  
  /***/ }),
  
  /***/ 35:
  /***/ (function(module) {
  
  function RetryOperation(timeouts, options) {
    // Compatibility for the old (timeouts, retryForever) signature
    if (typeof options === 'boolean') {
      options = { forever: options };
    }
  
    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
    this._timeouts = timeouts;
    this._options = options || {};
    this._maxRetryTime = options && options.maxRetryTime || Infinity;
    this._fn = null;
    this._errors = [];
    this._attempts = 1;
    this._operationTimeout = null;
    this._operationTimeoutCb = null;
    this._timeout = null;
    this._operationStart = null;
  
    if (this._options.forever) {
      this._cachedTimeouts = this._timeouts.slice(0);
    }
  }
  module.exports = RetryOperation;
  
  RetryOperation.prototype.reset = function() {
    this._attempts = 1;
    this._timeouts = this._originalTimeouts;
  }
  
  RetryOperation.prototype.stop = function() {
    if (this._timeout) {
      clearTimeout(this._timeout);
    }
  
    this._timeouts       = [];
    this._cachedTimeouts = null;
  };
  
  RetryOperation.prototype.retry = function(err) {
    if (this._timeout) {
      clearTimeout(this._timeout);
    }
  
    if (!err) {
      return false;
    }
    var currentTime = new Date().getTime();
    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
      this._errors.unshift(new Error('RetryOperation timeout occurred'));
      return false;
    }
  
    this._errors.push(err);
  
    var timeout = this._timeouts.shift();
    if (timeout === undefined) {
      if (this._cachedTimeouts) {
        // retry forever, only keep last error
        this._errors.splice(this._errors.length - 1, this._errors.length);
        this._timeouts = this._cachedTimeouts.slice(0);
        timeout = this._timeouts.shift();
      } else {
        return false;
      }
    }
  
    var self = this;
    var timer = setTimeout(function() {
      self._attempts++;
  
      if (self._operationTimeoutCb) {
        self._timeout = setTimeout(function() {
          self._operationTimeoutCb(self._attempts);
        }, self._operationTimeout);
  
        if (self._options.unref) {
            self._timeout.unref();
        }
      }
  
      self._fn(self._attempts);
    }, timeout);
  
    if (this._options.unref) {
        timer.unref();
    }
  
    return true;
  };
  
  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
    this._fn = fn;
  
    if (timeoutOps) {
      if (timeoutOps.timeout) {
        this._operationTimeout = timeoutOps.timeout;
      }
      if (timeoutOps.cb) {
        this._operationTimeoutCb = timeoutOps.cb;
      }
    }
  
    var self = this;
    if (this._operationTimeoutCb) {
      this._timeout = setTimeout(function() {
        self._operationTimeoutCb();
      }, self._operationTimeout);
    }
  
    this._operationStart = new Date().getTime();
  
    this._fn(this._attempts);
  };
  
  RetryOperation.prototype.try = function(fn) {
    console.log('Using RetryOperation.try() is deprecated');
    this.attempt(fn);
  };
  
  RetryOperation.prototype.start = function(fn) {
    console.log('Using RetryOperation.start() is deprecated');
    this.attempt(fn);
  };
  
  RetryOperation.prototype.start = RetryOperation.prototype.try;
  
  RetryOperation.prototype.errors = function() {
    return this._errors;
  };
  
  RetryOperation.prototype.attempts = function() {
    return this._attempts;
  };
  
  RetryOperation.prototype.mainError = function() {
    if (this._errors.length === 0) {
      return null;
    }
  
    var counts = {};
    var mainError = null;
    var mainErrorCount = 0;
  
    for (var i = 0; i < this._errors.length; i++) {
      var error = this._errors[i];
      var message = error.message;
      var count = (counts[message] || 0) + 1;
  
      counts[message] = count;
  
      if (count >= mainErrorCount) {
        mainError = error;
        mainErrorCount = count;
      }
    }
  
    return mainError;
  };
  
  
  /***/ }),
  
  /***/ 37:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  const path = __webpack_require__(589)
  const mkdir = __webpack_require__(562)
  const jsonFile = __webpack_require__(552)
  
  function outputJsonSync (file, data, options) {
    const dir = path.dirname(file)
  
    if (!fs.existsSync(dir)) {
      mkdir.mkdirsSync(dir)
    }
  
    jsonFile.writeJsonSync(file, data, options)
  }
  
  module.exports = outputJsonSync
  
  
  /***/ }),
  
  /***/ 42:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  module.exports = Readable;
  /*<replacement>*/
  
  var Duplex;
  /*</replacement>*/
  
  Readable.ReadableState = ReadableState;
  /*<replacement>*/
  
  var EE = __webpack_require__(485).EventEmitter;
  
  var EElistenerCount = function EElistenerCount(emitter, type) {
    return emitter.listeners(type).length;
  };
  /*</replacement>*/
  
  /*<replacement>*/
  
  
  var Stream = __webpack_require__(233);
  /*</replacement>*/
  
  
  var Buffer = __webpack_require__(942).Buffer;
  
  var OurUint8Array = global.Uint8Array || function () {};
  
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  /*<replacement>*/
  
  
  var debugUtil = __webpack_require__(64);
  
  var debug;
  
  if (debugUtil && debugUtil.debuglog) {
    debug = debugUtil.debuglog('stream');
  } else {
    debug = function debug() {};
  }
  /*</replacement>*/
  
  
  var BufferList = __webpack_require__(250);
  
  var destroyImpl = __webpack_require__(955);
  
  var _require = __webpack_require__(165),
      getHighWaterMark = _require.getHighWaterMark;
  
  var _require$codes = __webpack_require__(854).codes,
      ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
      ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
      ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
      ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
  
  var _require2 = __webpack_require__(890),
      emitExperimentalWarning = _require2.emitExperimentalWarning; // Lazy loaded to improve the startup performance.
  
  
  var StringDecoder;
  var createReadableStreamAsyncIterator;
  
  __webpack_require__(207)(Readable, Stream);
  
  var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
  
  function prependListener(emitter, event, fn) {
    // Sadly this is not cacheable as some libraries bundle their own
    // event emitter implementation with them.
    if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
    // userland ones.  NEVER DO THIS. This is here only because this code needs
    // to continue to work with older versions of Node.js that do not include
    // the prependListener() method. The goal is to eventually remove this hack.
  
    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
  }
  
  function ReadableState(options, stream, isDuplex) {
    Duplex = Duplex || __webpack_require__(404);
    options = options || {}; // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream.
    // These options can be provided separately as readableXXX and writableXXX.
  
    if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
    // make all the buffer merging and length checks go away
  
    this.objectMode = !!options.objectMode;
    if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
    // Note: 0 is a valid value, means "don't call _read preemptively ever"
  
    this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
    // linked list can remove elements from the beginning faster than
    // array.shift()
  
    this.buffer = new BufferList();
    this.length = 0;
    this.pipes = null;
    this.pipesCount = 0;
    this.flowing = null;
    this.ended = false;
    this.endEmitted = false;
    this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
    // immediately, or on a later tick.  We set this to true at first, because
    // any actions that shouldn't happen until "later" should generally also
    // not happen before the first read call.
  
    this.sync = true; // whenever we return null, then we set a flag to say
    // that we're awaiting a 'readable' event emission.
  
    this.needReadable = false;
    this.emittedReadable = false;
    this.readableListening = false;
    this.resumeScheduled = false;
    this.paused = true; // Should close be emitted on destroy. Defaults to true.
  
    this.emitClose = options.emitClose !== false; // has it been destroyed
  
    this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
  
    this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
  
    this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
  
    this.readingMore = false;
    this.decoder = null;
    this.encoding = null;
  
    if (options.encoding) {
      if (!StringDecoder) StringDecoder = __webpack_require__(988).StringDecoder;
      this.decoder = new StringDecoder(options.encoding);
      this.encoding = options.encoding;
    }
  }
  
  function Readable(options) {
    Duplex = Duplex || __webpack_require__(404);
    if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
    // the ReadableState constructor, at least with V8 6.5
  
    var isDuplex = this instanceof Duplex;
    this._readableState = new ReadableState(options, this, isDuplex); // legacy
  
    this.readable = true;
  
    if (options) {
      if (typeof options.read === 'function') this._read = options.read;
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
    }
  
    Stream.call(this);
  }
  
  Object.defineProperty(Readable.prototype, 'destroyed', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      if (this._readableState === undefined) {
        return false;
      }
  
      return this._readableState.destroyed;
    },
    set: function set(value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._readableState) {
        return;
      } // backward compatibility, the user is explicitly
      // managing destroyed
  
  
      this._readableState.destroyed = value;
    }
  });
  Readable.prototype.destroy = destroyImpl.destroy;
  Readable.prototype._undestroy = destroyImpl.undestroy;
  
  Readable.prototype._destroy = function (err, cb) {
    cb(err);
  }; // Manually shove something into the read() buffer.
  // This returns true if the highWaterMark has not been hit yet,
  // similar to how Writable.write() returns true if you should
  // write() some more.
  
  
  Readable.prototype.push = function (chunk, encoding) {
    var state = this._readableState;
    var skipChunkCheck;
  
    if (!state.objectMode) {
      if (typeof chunk === 'string') {
        encoding = encoding || state.defaultEncoding;
  
        if (encoding !== state.encoding) {
          chunk = Buffer.from(chunk, encoding);
          encoding = '';
        }
  
        skipChunkCheck = true;
      }
    } else {
      skipChunkCheck = true;
    }
  
    return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
  }; // Unshift should *always* be something directly out of read()
  
  
  Readable.prototype.unshift = function (chunk) {
    return readableAddChunk(this, chunk, null, true, false);
  };
  
  function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
    debug('readableAddChunk', chunk);
    var state = stream._readableState;
  
    if (chunk === null) {
      state.reading = false;
      onEofChunk(stream, state);
    } else {
      var er;
      if (!skipChunkCheck) er = chunkInvalid(state, chunk);
  
      if (er) {
        stream.emit('error', er);
      } else if (state.objectMode || chunk && chunk.length > 0) {
        if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
  
        if (addToFront) {
          if (state.endEmitted) stream.emit('error', new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
        } else if (state.ended) {
          stream.emit('error', new ERR_STREAM_PUSH_AFTER_EOF());
        } else if (state.destroyed) {
          return false;
        } else {
          state.reading = false;
  
          if (state.decoder && !encoding) {
            chunk = state.decoder.write(chunk);
            if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
          } else {
            addChunk(stream, state, chunk, false);
          }
        }
      } else if (!addToFront) {
        state.reading = false;
        maybeReadMore(stream, state);
      }
    } // We can push more data if we are below the highWaterMark.
    // Also, if we have no data yet, we can stand some more bytes.
    // This is to work around cases where hwm=0, such as the repl.
  
  
    return !state.ended && (state.length < state.highWaterMark || state.length === 0);
  }
  
  function addChunk(stream, state, chunk, addToFront) {
    if (state.flowing && state.length === 0 && !state.sync) {
      state.awaitDrain = 0;
      stream.emit('data', chunk);
    } else {
      // update the buffer info.
      state.length += state.objectMode ? 1 : chunk.length;
      if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
      if (state.needReadable) emitReadable(stream);
    }
  
    maybeReadMore(stream, state);
  }
  
  function chunkInvalid(state, chunk) {
    var er;
  
    if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
      er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
    }
  
    return er;
  }
  
  Readable.prototype.isPaused = function () {
    return this._readableState.flowing === false;
  }; // backwards compatibility.
  
  
  Readable.prototype.setEncoding = function (enc) {
    if (!StringDecoder) StringDecoder = __webpack_require__(988).StringDecoder;
    this._readableState.decoder = new StringDecoder(enc); // if setEncoding(null), decoder.encoding equals utf8
  
    this._readableState.encoding = this._readableState.decoder.encoding;
    return this;
  }; // Don't raise the hwm > 8MB
  
  
  var MAX_HWM = 0x800000;
  
  function computeNewHighWaterMark(n) {
    if (n >= MAX_HWM) {
      n = MAX_HWM;
    } else {
      // Get the next highest power of 2 to prevent increasing hwm excessively in
      // tiny amounts
      n--;
      n |= n >>> 1;
      n |= n >>> 2;
      n |= n >>> 4;
      n |= n >>> 8;
      n |= n >>> 16;
      n++;
    }
  
    return n;
  } // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  
  
  function howMuchToRead(n, state) {
    if (n <= 0 || state.length === 0 && state.ended) return 0;
    if (state.objectMode) return 1;
  
    if (n !== n) {
      // Only flow one buffer at a time
      if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
    } // If we're asking for more than the current hwm, then raise the hwm.
  
  
    if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
    if (n <= state.length) return n; // Don't have enough
  
    if (!state.ended) {
      state.needReadable = true;
      return 0;
    }
  
    return state.length;
  } // you can override either this method, or the async _read(n) below.
  
  
  Readable.prototype.read = function (n) {
    debug('read', n);
    n = parseInt(n, 10);
    var state = this._readableState;
    var nOrig = n;
    if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
    // already have a bunch of data in the buffer, then just trigger
    // the 'readable' event and move on.
  
    if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
      debug('read: emitReadable', state.length, state.ended);
      if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
      return null;
    }
  
    n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
  
    if (n === 0 && state.ended) {
      if (state.length === 0) endReadable(this);
      return null;
    } // All the actual chunk generation logic needs to be
    // *below* the call to _read.  The reason is that in certain
    // synthetic stream cases, such as passthrough streams, _read
    // may be a completely synchronous operation which may change
    // the state of the read buffer, providing enough data when
    // before there was *not* enough.
    //
    // So, the steps are:
    // 1. Figure out what the state of things will be after we do
    // a read from the buffer.
    //
    // 2. If that resulting state will trigger a _read, then call _read.
    // Note that this may be asynchronous, or synchronous.  Yes, it is
    // deeply ugly to write APIs this way, but that still doesn't mean
    // that the Readable class should behave improperly, as streams are
    // designed to be sync/async agnostic.
    // Take note if the _read call is sync or async (ie, if the read call
    // has returned yet), so that we know whether or not it's safe to emit
    // 'readable' etc.
    //
    // 3. Actually pull the requested chunks out of the buffer and return.
    // if we need a readable event, then we need to do some reading.
  
  
    var doRead = state.needReadable;
    debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
  
    if (state.length === 0 || state.length - n < state.highWaterMark) {
      doRead = true;
      debug('length less than watermark', doRead);
    } // however, if we've ended, then there's no point, and if we're already
    // reading, then it's unnecessary.
  
  
    if (state.ended || state.reading) {
      doRead = false;
      debug('reading or ended', doRead);
    } else if (doRead) {
      debug('do read');
      state.reading = true;
      state.sync = true; // if the length is currently zero, then we *need* a readable event.
  
      if (state.length === 0) state.needReadable = true; // call internal read method
  
      this._read(state.highWaterMark);
  
      state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
      // and we need to re-evaluate how much data we can return to the user.
  
      if (!state.reading) n = howMuchToRead(nOrig, state);
    }
  
    var ret;
    if (n > 0) ret = fromList(n, state);else ret = null;
  
    if (ret === null) {
      state.needReadable = true;
      n = 0;
    } else {
      state.length -= n;
      state.awaitDrain = 0;
    }
  
    if (state.length === 0) {
      // If we have nothing in the buffer, then we want to know
      // as soon as we *do* get something into the buffer.
      if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
  
      if (nOrig !== n && state.ended) endReadable(this);
    }
  
    if (ret !== null) this.emit('data', ret);
    return ret;
  };
  
  function onEofChunk(stream, state) {
    if (state.ended) return;
  
    if (state.decoder) {
      var chunk = state.decoder.end();
  
      if (chunk && chunk.length) {
        state.buffer.push(chunk);
        state.length += state.objectMode ? 1 : chunk.length;
      }
    }
  
    state.ended = true;
  
    if (state.sync) {
      // if we are sync, wait until next tick to emit the data.
      // Otherwise we risk emitting data in the flow()
      // the readable code triggers during a read() call
      emitReadable(stream);
    } else {
      // emit 'readable' now to make sure it gets picked up.
      state.needReadable = false;
  
      if (!state.emittedReadable) {
        state.emittedReadable = true;
        emitReadable_(stream);
      }
    }
  } // Don't emit readable right away in sync mode, because this can trigger
  // another read() call => stack overflow.  This way, it might trigger
  // a nextTick recursion warning, but that's not so bad.
  
  
  function emitReadable(stream) {
    var state = stream._readableState;
    state.needReadable = false;
  
    if (!state.emittedReadable) {
      debug('emitReadable', state.flowing);
      state.emittedReadable = true;
      process.nextTick(emitReadable_, stream);
    }
  }
  
  function emitReadable_(stream) {
    var state = stream._readableState;
    debug('emitReadable_', state.destroyed, state.length, state.ended);
  
    if (!state.destroyed && (state.length || state.ended)) {
      stream.emit('readable');
    } // The stream needs another readable event if
    // 1. It is not flowing, as the flow mechanism will take
    //    care of it.
    // 2. It is not ended.
    // 3. It is below the highWaterMark, so we can schedule
    //    another readable later.
  
  
    state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
    flow(stream);
  } // at this point, the user has presumably seen the 'readable' event,
  // and called read() to consume some data.  that may have triggered
  // in turn another _read(n) call, in which case reading = true if
  // it's in progress.
  // However, if we're not ended, or reading, and the length < hwm,
  // then go ahead and try to read some more preemptively.
  
  
  function maybeReadMore(stream, state) {
    if (!state.readingMore) {
      state.readingMore = true;
      process.nextTick(maybeReadMore_, stream, state);
    }
  }
  
  function maybeReadMore_(stream, state) {
    // Attempt to read more data if we should.
    //
    // The conditions for reading more data are (one of):
    // - Not enough data buffered (state.length < state.highWaterMark). The loop
    //   is responsible for filling the buffer with enough data if such data
    //   is available. If highWaterMark is 0 and we are not in the flowing mode
    //   we should _not_ attempt to buffer any extra data. We'll get more data
    //   when the stream consumer calls read() instead.
    // - No data in the buffer, and the stream is in flowing mode. In this mode
    //   the loop below is responsible for ensuring read() is called. Failing to
    //   call read here would abort the flow and there's no other mechanism for
    //   continuing the flow if the stream consumer has just subscribed to the
    //   'data' event.
    //
    // In addition to the above conditions to keep reading data, the following
    // conditions prevent the data from being read:
    // - The stream has ended (state.ended).
    // - There is already a pending 'read' operation (state.reading). This is a
    //   case where the the stream has called the implementation defined _read()
    //   method, but they are processing the call asynchronously and have _not_
    //   called push() with new data. In this case we skip performing more
    //   read()s. The execution ends in this method again after the _read() ends
    //   up calling push() with more data.
    while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
      var len = state.length;
      debug('maybeReadMore read 0');
      stream.read(0);
      if (len === state.length) // didn't get any data, stop spinning.
        break;
    }
  
    state.readingMore = false;
  } // abstract method.  to be overridden in specific implementation classes.
  // call cb(er, data) where data is <= n in length.
  // for virtual (non-string, non-buffer) streams, "length" is somewhat
  // arbitrary, and perhaps not very meaningful.
  
  
  Readable.prototype._read = function (n) {
    this.emit('error', new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
  };
  
  Readable.prototype.pipe = function (dest, pipeOpts) {
    var src = this;
    var state = this._readableState;
  
    switch (state.pipesCount) {
      case 0:
        state.pipes = dest;
        break;
  
      case 1:
        state.pipes = [state.pipes, dest];
        break;
  
      default:
        state.pipes.push(dest);
        break;
    }
  
    state.pipesCount += 1;
    debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
    var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
    var endFn = doEnd ? onend : unpipe;
    if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
    dest.on('unpipe', onunpipe);
  
    function onunpipe(readable, unpipeInfo) {
      debug('onunpipe');
  
      if (readable === src) {
        if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
          unpipeInfo.hasUnpiped = true;
          cleanup();
        }
      }
    }
  
    function onend() {
      debug('onend');
      dest.end();
    } // when the dest drains, it reduces the awaitDrain counter
    // on the source.  This would be more elegant with a .once()
    // handler in flow(), but adding and removing repeatedly is
    // too slow.
  
  
    var ondrain = pipeOnDrain(src);
    dest.on('drain', ondrain);
    var cleanedUp = false;
  
    function cleanup() {
      debug('cleanup'); // cleanup event handlers once the pipe is broken
  
      dest.removeListener('close', onclose);
      dest.removeListener('finish', onfinish);
      dest.removeListener('drain', ondrain);
      dest.removeListener('error', onerror);
      dest.removeListener('unpipe', onunpipe);
      src.removeListener('end', onend);
      src.removeListener('end', unpipe);
      src.removeListener('data', ondata);
      cleanedUp = true; // if the reader is waiting for a drain event from this
      // specific writer, then it would cause it to never start
      // flowing again.
      // So, if this is awaiting a drain, then we just call it now.
      // If we don't know, then assume that we are waiting for one.
  
      if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
    }
  
    src.on('data', ondata);
  
    function ondata(chunk) {
      debug('ondata');
      var ret = dest.write(chunk);
      debug('dest.write', ret);
  
      if (ret === false) {
        // If the user unpiped during `dest.write()`, it is possible
        // to get stuck in a permanently paused state if that write
        // also returned false.
        // => Check whether `dest` is still a piping destination.
        if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
          debug('false write response, pause', state.awaitDrain);
          state.awaitDrain++;
        }
  
        src.pause();
      }
    } // if the dest has an error, then stop piping into it.
    // however, don't suppress the throwing behavior for this.
  
  
    function onerror(er) {
      debug('onerror', er);
      unpipe();
      dest.removeListener('error', onerror);
      if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
    } // Make sure our error handler is attached before userland ones.
  
  
    prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
  
    function onclose() {
      dest.removeListener('finish', onfinish);
      unpipe();
    }
  
    dest.once('close', onclose);
  
    function onfinish() {
      debug('onfinish');
      dest.removeListener('close', onclose);
      unpipe();
    }
  
    dest.once('finish', onfinish);
  
    function unpipe() {
      debug('unpipe');
      src.unpipe(dest);
    } // tell the dest that it's being piped to
  
  
    dest.emit('pipe', src); // start the flow if it hasn't been started already.
  
    if (!state.flowing) {
      debug('pipe resume');
      src.resume();
    }
  
    return dest;
  };
  
  function pipeOnDrain(src) {
    return function pipeOnDrainFunctionResult() {
      var state = src._readableState;
      debug('pipeOnDrain', state.awaitDrain);
      if (state.awaitDrain) state.awaitDrain--;
  
      if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
        state.flowing = true;
        flow(src);
      }
    };
  }
  
  Readable.prototype.unpipe = function (dest) {
    var state = this._readableState;
    var unpipeInfo = {
      hasUnpiped: false
    }; // if we're not piping anywhere, then do nothing.
  
    if (state.pipesCount === 0) return this; // just one destination.  most common case.
  
    if (state.pipesCount === 1) {
      // passed in one, but it's not the right one.
      if (dest && dest !== state.pipes) return this;
      if (!dest) dest = state.pipes; // got a match.
  
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
      if (dest) dest.emit('unpipe', this, unpipeInfo);
      return this;
    } // slow case. multiple pipe destinations.
  
  
    if (!dest) {
      // remove all.
      var dests = state.pipes;
      var len = state.pipesCount;
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
  
      for (var i = 0; i < len; i++) {
        dests[i].emit('unpipe', this, {
          hasUnpiped: false
        });
      }
  
      return this;
    } // try to find the right one.
  
  
    var index = indexOf(state.pipes, dest);
    if (index === -1) return this;
    state.pipes.splice(index, 1);
    state.pipesCount -= 1;
    if (state.pipesCount === 1) state.pipes = state.pipes[0];
    dest.emit('unpipe', this, unpipeInfo);
    return this;
  }; // set up data events if they are asked for
  // Ensure readable listeners eventually get something
  
  
  Readable.prototype.on = function (ev, fn) {
    var res = Stream.prototype.on.call(this, ev, fn);
    var state = this._readableState;
  
    if (ev === 'data') {
      // update readableListening so that resume() may be a no-op
      // a few lines down. This is needed to support once('readable').
      state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
  
      if (state.flowing !== false) this.resume();
    } else if (ev === 'readable') {
      if (!state.endEmitted && !state.readableListening) {
        state.readableListening = state.needReadable = true;
        state.flowing = false;
        state.emittedReadable = false;
        debug('on readable', state.length, state.reading);
  
        if (state.length) {
          emitReadable(this);
        } else if (!state.reading) {
          process.nextTick(nReadingNextTick, this);
        }
      }
    }
  
    return res;
  };
  
  Readable.prototype.addListener = Readable.prototype.on;
  
  Readable.prototype.removeListener = function (ev, fn) {
    var res = Stream.prototype.removeListener.call(this, ev, fn);
  
    if (ev === 'readable') {
      // We need to check if there is someone still listening to
      // readable and reset the state. However this needs to happen
      // after readable has been emitted but before I/O (nextTick) to
      // support once('readable', fn) cycles. This means that calling
      // resume within the same tick will have no
      // effect.
      process.nextTick(updateReadableListening, this);
    }
  
    return res;
  };
  
  Readable.prototype.removeAllListeners = function (ev) {
    var res = Stream.prototype.removeAllListeners.apply(this, arguments);
  
    if (ev === 'readable' || ev === undefined) {
      // We need to check if there is someone still listening to
      // readable and reset the state. However this needs to happen
      // after readable has been emitted but before I/O (nextTick) to
      // support once('readable', fn) cycles. This means that calling
      // resume within the same tick will have no
      // effect.
      process.nextTick(updateReadableListening, this);
    }
  
    return res;
  };
  
  function updateReadableListening(self) {
    var state = self._readableState;
    state.readableListening = self.listenerCount('readable') > 0;
  
    if (state.resumeScheduled && !state.paused) {
      // flowing needs to be set to true now, otherwise
      // the upcoming resume will not flow.
      state.flowing = true; // crude way to check if we should resume
    } else if (self.listenerCount('data') > 0) {
      self.resume();
    }
  }
  
  function nReadingNextTick(self) {
    debug('readable nexttick read 0');
    self.read(0);
  } // pause() and resume() are remnants of the legacy readable stream API
  // If the user uses them, then switch into old mode.
  
  
  Readable.prototype.resume = function () {
    var state = this._readableState;
  
    if (!state.flowing) {
      debug('resume'); // we flow only if there is no one listening
      // for readable, but we still have to call
      // resume()
  
      state.flowing = !state.readableListening;
      resume(this, state);
    }
  
    state.paused = false;
    return this;
  };
  
  function resume(stream, state) {
    if (!state.resumeScheduled) {
      state.resumeScheduled = true;
      process.nextTick(resume_, stream, state);
    }
  }
  
  function resume_(stream, state) {
    debug('resume', state.reading);
  
    if (!state.reading) {
      stream.read(0);
    }
  
    state.resumeScheduled = false;
    stream.emit('resume');
    flow(stream);
    if (state.flowing && !state.reading) stream.read(0);
  }
  
  Readable.prototype.pause = function () {
    debug('call pause flowing=%j', this._readableState.flowing);
  
    if (this._readableState.flowing !== false) {
      debug('pause');
      this._readableState.flowing = false;
      this.emit('pause');
    }
  
    this._readableState.paused = true;
    return this;
  };
  
  function flow(stream) {
    var state = stream._readableState;
    debug('flow', state.flowing);
  
    while (state.flowing && stream.read() !== null) {
      ;
    }
  } // wrap an old-style stream as the async data source.
  // This is *not* part of the readable stream interface.
  // It is an ugly unfortunate mess of history.
  
  
  Readable.prototype.wrap = function (stream) {
    var _this = this;
  
    var state = this._readableState;
    var paused = false;
    stream.on('end', function () {
      debug('wrapped end');
  
      if (state.decoder && !state.ended) {
        var chunk = state.decoder.end();
        if (chunk && chunk.length) _this.push(chunk);
      }
  
      _this.push(null);
    });
    stream.on('data', function (chunk) {
      debug('wrapped data');
      if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
  
      if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
  
      var ret = _this.push(chunk);
  
      if (!ret) {
        paused = true;
        stream.pause();
      }
    }); // proxy all the other methods.
    // important when wrapping filters and duplexes.
  
    for (var i in stream) {
      if (this[i] === undefined && typeof stream[i] === 'function') {
        this[i] = function methodWrap(method) {
          return function methodWrapReturnFunction() {
            return stream[method].apply(stream, arguments);
          };
        }(i);
      }
    } // proxy certain important events.
  
  
    for (var n = 0; n < kProxyEvents.length; n++) {
      stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
    } // when we try to consume some more bytes, simply unpause the
    // underlying stream.
  
  
    this._read = function (n) {
      debug('wrapped _read', n);
  
      if (paused) {
        paused = false;
        stream.resume();
      }
    };
  
    return this;
  };
  
  if (typeof Symbol === 'function') {
    Readable.prototype[Symbol.asyncIterator] = function () {
      emitExperimentalWarning('Readable[Symbol.asyncIterator]');
  
      if (createReadableStreamAsyncIterator === undefined) {
        createReadableStreamAsyncIterator = __webpack_require__(756);
      }
  
      return createReadableStreamAsyncIterator(this);
    };
  }
  
  Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._readableState.highWaterMark;
    }
  });
  Object.defineProperty(Readable.prototype, 'readableBuffer', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._readableState && this._readableState.buffer;
    }
  });
  Object.defineProperty(Readable.prototype, 'readableFlowing', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._readableState.flowing;
    },
    set: function set(state) {
      if (this._readableState) {
        this._readableState.flowing = state;
      }
    }
  }); // exposed for testing purposes only.
  
  Readable._fromList = fromList;
  Object.defineProperty(Readable.prototype, 'readableLength', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._readableState.length;
    }
  }); // Pluck off n bytes from an array of buffers.
  // Length is the combined lengths of all the buffers in the list.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  
  function fromList(n, state) {
    // nothing buffered
    if (state.length === 0) return null;
    var ret;
    if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
      // read it all, truncate the list
      if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
      state.buffer.clear();
    } else {
      // read part of list
      ret = state.buffer.consume(n, state.decoder);
    }
    return ret;
  }
  
  function endReadable(stream) {
    var state = stream._readableState;
    debug('endReadable', state.endEmitted);
  
    if (!state.endEmitted) {
      state.ended = true;
      process.nextTick(endReadableNT, state, stream);
    }
  }
  
  function endReadableNT(state, stream) {
    debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
  
    if (!state.endEmitted && state.length === 0) {
      state.endEmitted = true;
      stream.readable = false;
      stream.emit('end');
    }
  }
  
  function indexOf(xs, x) {
    for (var i = 0, l = xs.length; i < l; i++) {
      if (xs[i] === x) return i;
    }
  
    return -1;
  }
  
  /***/ }),
  
  /***/ 55:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  const path = __webpack_require__(589)
  const invalidWin32Path = __webpack_require__(376).invalidWin32Path
  
  const o777 = parseInt('0777', 8)
  
  function mkdirs (p, opts, callback, made) {
    if (typeof opts === 'function') {
      callback = opts
      opts = {}
    } else if (!opts || typeof opts !== 'object') {
      opts = { mode: opts }
    }
  
    if (process.platform === 'win32' && invalidWin32Path(p)) {
      const errInval = new Error(p + ' contains invalid WIN32 path characters.')
      errInval.code = 'EINVAL'
      return callback(errInval)
    }
  
    let mode = opts.mode
    const xfs = opts.fs || fs
  
    if (mode === undefined) {
      mode = o777 & (~process.umask())
    }
    if (!made) made = null
  
    callback = callback || function () {}
    p = path.resolve(p)
  
    xfs.mkdir(p, mode, er => {
      if (!er) {
        made = made || p
        return callback(null, made)
      }
      switch (er.code) {
        case 'ENOENT':
          if (path.dirname(p) === p) return callback(er)
          mkdirs(path.dirname(p), opts, (er, made) => {
            if (er) callback(er, made)
            else mkdirs(p, opts, callback, made)
          })
          break
  
        // In the case of any other error, just see if there's a dir
        // there already.  If so, then hooray!  If not, then something
        // is borked.
        default:
          xfs.stat(p, (er2, stat) => {
            // if the stat fails, then that's super weird.
            // let the original error be the failure reason.
            if (er2 || !stat.isDirectory()) callback(er, made)
            else callback(null, made)
          })
          break
      }
    })
  }
  
  module.exports = mkdirs
  
  
  /***/ }),
  
  /***/ 64:
  /***/ (function(module) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ 66:
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 72:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const jsonFile = __webpack_require__(552)
  
  jsonFile.outputJson = u(__webpack_require__(136))
  jsonFile.outputJsonSync = __webpack_require__(37)
  // aliases
  jsonFile.outputJSON = jsonFile.outputJson
  jsonFile.outputJSONSync = jsonFile.outputJsonSync
  jsonFile.writeJSON = jsonFile.writeJson
  jsonFile.writeJSONSync = jsonFile.writeJsonSync
  jsonFile.readJSON = jsonFile.readJson
  jsonFile.readJSONSync = jsonFile.readJsonSync
  
  module.exports = jsonFile
  
  
  /***/ }),
  
  /***/ 77:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = Object.assign(
    {},
    // Export promiseified graceful-fs:
    __webpack_require__(827),
    // Export extra methods:
    __webpack_require__(914),
    __webpack_require__(381),
    __webpack_require__(28),
    __webpack_require__(802),
    __webpack_require__(72),
    __webpack_require__(562),
    __webpack_require__(551),
    __webpack_require__(225),
    __webpack_require__(415),
    __webpack_require__(734),
    __webpack_require__(812)
  )
  
  // Export fs.promises as a getter property so that we don't trigger
  // ExperimentalWarning before fs.promises is actually accessed.
  const fs = __webpack_require__(66)
  if (Object.getOwnPropertyDescriptor(fs, 'promises')) {
    Object.defineProperty(module.exports, 'promises', {
      get () { return fs.promises }
    })
  }
  
  
  /***/ }),
  
  /***/ 83:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var wrappy = __webpack_require__(16)
  module.exports = wrappy(once)
  module.exports.strict = wrappy(onceStrict)
  
  once.proto = once(function () {
    Object.defineProperty(Function.prototype, 'once', {
      value: function () {
        return once(this)
      },
      configurable: true
    })
  
    Object.defineProperty(Function.prototype, 'onceStrict', {
      value: function () {
        return onceStrict(this)
      },
      configurable: true
    })
  })
  
  function once (fn) {
    var f = function () {
      if (f.called) return f.value
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    f.called = false
    return f
  }
  
  function onceStrict (fn) {
    var f = function () {
      if (f.called)
        throw new Error(f.onceError)
      f.called = true
      return f.value = fn.apply(this, arguments)
    }
    var name = fn.name || 'Function wrapped with `once`'
    f.onceError = name + " shouldn't be called more than once"
    f.called = false
    return f
  }
  
  
  /***/ }),
  
  /***/ 86:
  /***/ (function(module) {
  
  /**
   * Helpers.
   */
  
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  module.exports = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse(val);
    } else if (type === 'number' && isFinite(val)) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  
  /***/ }),
  
  /***/ 88:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
  var __rest = (this && this.__rest) || function (s, e) {
      var t = {};
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
          t[p] = s[p];
      if (s != null && typeof Object.getOwnPropertySymbols === "function")
          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                  t[p[i]] = s[p[i]];
          }
      return t;
  };
  var __asyncValues = (this && this.__asyncValues) || function (o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  };
  var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const fs_extra_1 = __webpack_require__(77);
  const recursive_readdir_1 = __importDefault(__webpack_require__(253));
  const hashes_1 = __importStar(__webpack_require__(935));
  const upload_1 = __importDefault(__webpack_require__(845));
  const utils_1 = __webpack_require__(512);
  const errors_1 = __webpack_require__(610);
  var utils_2 = __webpack_require__(512);
  exports.EVENTS = utils_2.EVENTS;
  function buildCreateDeployment(version) {
      return function createDeployment(path, options = {}) {
          return __asyncGenerator(this, arguments, function* createDeployment_1() {
              var e_1, _a;
              if (typeof path !== 'string' && !Array.isArray(path)) {
                  throw new errors_1.DeploymentError({
                      code: 'missing_path',
                      message: 'Path not provided'
                  });
              }
              if (typeof options.token !== 'string') {
                  throw new errors_1.DeploymentError({
                      code: 'token_not_provided',
                      message: 'Options object must include a `token`'
                  });
              }
              const isDirectory = !Array.isArray(path) && fs_extra_1.lstatSync(path).isDirectory();
              // Get .nowignore
              let rootFiles;
              if (isDirectory && !Array.isArray(path)) {
                  rootFiles = yield __await(fs_extra_1.readdir(path));
              }
              else if (Array.isArray(path)) {
                  rootFiles = path;
              }
              else {
                  rootFiles = [path];
              }
              let ignores = yield __await(utils_1.getNowIgnore(rootFiles, path));
              let fileList;
              if (isDirectory && !Array.isArray(path)) {
                  // Directory path
                  fileList = yield __await(recursive_readdir_1.default(path, ignores));
              }
              else if (Array.isArray(path)) {
                  // Array of file paths
                  fileList = path;
              }
              else {
                  // Single file
                  fileList = [path];
              }
              const files = yield __await(hashes_1.default(fileList));
              yield yield __await({ type: 'hashes-calculated', payload: hashes_1.mapToObject(files) });
              const { token, teamId, force, defaultName } = options, metadata = __rest(options, ["token", "teamId", "force", "defaultName"]);
              metadata.version = version;
              const deploymentOpts = {
                  totalFiles: files.size,
                  token,
                  isDirectory,
                  path,
                  teamId,
                  force,
                  defaultName,
                  metadata
              };
              try {
                  for (var _b = __asyncValues(upload_1.default(files, deploymentOpts)), _c; _c = yield __await(_b.next()), !_c.done;) {
                      const event = _c.value;
                      yield yield __await(event);
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (_c && !_c.done && (_a = _b.return)) yield __await(_a.call(_b));
                  }
                  finally { if (e_1) throw e_1.error; }
              }
          });
      };
  }
  exports.default = buildCreateDeployment;
  
  
  /***/ }),
  
  /***/ 98:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const path = __webpack_require__(589)
  const fs = __webpack_require__(813)
  const mkdir = __webpack_require__(562)
  const pathExists = __webpack_require__(734).pathExists
  
  function createLink (srcpath, dstpath, callback) {
    function makeLink (srcpath, dstpath) {
      fs.link(srcpath, dstpath, err => {
        if (err) return callback(err)
        callback(null)
      })
    }
  
    pathExists(dstpath, (err, destinationExists) => {
      if (err) return callback(err)
      if (destinationExists) return callback(null)
      fs.lstat(srcpath, (err) => {
        if (err) {
          err.message = err.message.replace('lstat', 'ensureLink')
          return callback(err)
        }
  
        const dir = path.dirname(dstpath)
        pathExists(dir, (err, dirExists) => {
          if (err) return callback(err)
          if (dirExists) return makeLink(srcpath, dstpath)
          mkdir.mkdirs(dir, err => {
            if (err) return callback(err)
            makeLink(srcpath, dstpath)
          })
        })
      })
    })
  }
  
  function createLinkSync (srcpath, dstpath) {
    const destinationExists = fs.existsSync(dstpath)
    if (destinationExists) return undefined
  
    try {
      fs.lstatSync(srcpath)
    } catch (err) {
      err.message = err.message.replace('lstat', 'ensureLink')
      throw err
    }
  
    const dir = path.dirname(dstpath)
    const dirExists = fs.existsSync(dir)
    if (dirExists) return fs.linkSync(srcpath, dstpath)
    mkdir.mkdirsSync(dir)
  
    return fs.linkSync(srcpath, dstpath)
  }
  
  module.exports = {
    createLink: u(createLink),
    createLinkSync
  }
  
  
  /***/ }),
  
  /***/ 103:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var once = __webpack_require__(83);
  
  var noop = function() {};
  
  var isRequest = function(stream) {
  	return stream.setHeader && typeof stream.abort === 'function';
  };
  
  var isChildProcess = function(stream) {
  	return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
  };
  
  var eos = function(stream, opts, callback) {
  	if (typeof opts === 'function') return eos(stream, null, opts);
  	if (!opts) opts = {};
  
  	callback = once(callback || noop);
  
  	var ws = stream._writableState;
  	var rs = stream._readableState;
  	var readable = opts.readable || (opts.readable !== false && stream.readable);
  	var writable = opts.writable || (opts.writable !== false && stream.writable);
  
  	var onlegacyfinish = function() {
  		if (!stream.writable) onfinish();
  	};
  
  	var onfinish = function() {
  		writable = false;
  		if (!readable) callback.call(stream);
  	};
  
  	var onend = function() {
  		readable = false;
  		if (!writable) callback.call(stream);
  	};
  
  	var onexit = function(exitCode) {
  		callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
  	};
  
  	var onerror = function(err) {
  		callback.call(stream, err);
  	};
  
  	var onclose = function() {
  		if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
  		if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
  	};
  
  	var onrequest = function() {
  		stream.req.on('finish', onfinish);
  	};
  
  	if (isRequest(stream)) {
  		stream.on('complete', onfinish);
  		stream.on('abort', onclose);
  		if (stream.req) onrequest();
  		else stream.on('request', onrequest);
  	} else if (writable && !ws) { // legacy streams
  		stream.on('end', onlegacyfinish);
  		stream.on('close', onlegacyfinish);
  	}
  
  	if (isChildProcess(stream)) stream.on('exit', onexit);
  
  	stream.on('end', onend);
  	stream.on('finish', onfinish);
  	if (opts.error !== false) stream.on('error', onerror);
  	stream.on('close', onclose);
  
  	return function() {
  		stream.removeListener('complete', onfinish);
  		stream.removeListener('abort', onclose);
  		stream.removeListener('request', onrequest);
  		if (stream.req) stream.req.removeListener('finish', onfinish);
  		stream.removeListener('end', onlegacyfinish);
  		stream.removeListener('close', onlegacyfinish);
  		stream.removeListener('finish', onfinish);
  		stream.removeListener('exit', onexit);
  		stream.removeListener('end', onend);
  		stream.removeListener('error', onerror);
  		stream.removeListener('close', onclose);
  	};
  };
  
  module.exports = eos;
  
  
  /***/ }),
  
  /***/ 105:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  var urlParse = __webpack_require__(986).parse;
  var util = __webpack_require__(64);
  var ipRegex = __webpack_require__(548)({ exact: true });
  var pubsuffix = __webpack_require__(501);
  var Store = __webpack_require__(471).Store;
  var MemoryCookieStore = __webpack_require__(809).MemoryCookieStore;
  var pathMatch = __webpack_require__(143).pathMatch;
  var VERSION = __webpack_require__(261);
  
  var punycode;
  try {
    punycode = __webpack_require__(805);
  } catch(e) {
    console.warn("tough-cookie: can't load punycode; won't use punycode for domain normalization");
  }
  
  // From RFC6265 S4.1.1
  // note that it excludes \x3B ";"
  var COOKIE_OCTETS = /^[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]+$/;
  
  var CONTROL_CHARS = /[\x00-\x1F]/;
  
  // From Chromium // '\r', '\n' and '\0' should be treated as a terminator in
  // the "relaxed" mode, see:
  // https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/parsed_cookie.cc#L60
  var TERMINATORS = ['\n', '\r', '\0'];
  
  // RFC6265 S4.1.1 defines path value as 'any CHAR except CTLs or ";"'
  // Note ';' is \x3B
  var PATH_VALUE = /[\x20-\x3A\x3C-\x7E]+/;
  
  // date-time parsing constants (RFC6265 S5.1.1)
  
  var DATE_DELIM = /[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]/;
  
  var MONTH_TO_NUM = {
    jan:0, feb:1, mar:2, apr:3, may:4, jun:5,
    jul:6, aug:7, sep:8, oct:9, nov:10, dec:11
  };
  var NUM_TO_MONTH = [
    'Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'
  ];
  var NUM_TO_DAY = [
    'Sun','Mon','Tue','Wed','Thu','Fri','Sat'
  ];
  
  var MAX_TIME = 2147483647000; // 31-bit max
  var MIN_TIME = 0; // 31-bit min
  
  /*
   * Parses a Natural number (i.e., non-negative integer) with either the
   *    <min>*<max>DIGIT ( non-digit *OCTET )
   * or
   *    <min>*<max>DIGIT
   * grammar (RFC6265 S5.1.1).
   *
   * The "trailingOK" boolean controls if the grammar accepts a
   * "( non-digit *OCTET )" trailer.
   */
  function parseDigits(token, minDigits, maxDigits, trailingOK) {
    var count = 0;
    while (count < token.length) {
      var c = token.charCodeAt(count);
      // "non-digit = %x00-2F / %x3A-FF"
      if (c <= 0x2F || c >= 0x3A) {
        break;
      }
      count++;
    }
  
    // constrain to a minimum and maximum number of digits.
    if (count < minDigits || count > maxDigits) {
      return null;
    }
  
    if (!trailingOK && count != token.length) {
      return null;
    }
  
    return parseInt(token.substr(0,count), 10);
  }
  
  function parseTime(token) {
    var parts = token.split(':');
    var result = [0,0,0];
  
    /* RF6256 S5.1.1:
     *      time            = hms-time ( non-digit *OCTET )
     *      hms-time        = time-field ":" time-field ":" time-field
     *      time-field      = 1*2DIGIT
     */
  
    if (parts.length !== 3) {
      return null;
    }
  
    for (var i = 0; i < 3; i++) {
      // "time-field" must be strictly "1*2DIGIT", HOWEVER, "hms-time" can be
      // followed by "( non-digit *OCTET )" so therefore the last time-field can
      // have a trailer
      var trailingOK = (i == 2);
      var num = parseDigits(parts[i], 1, 2, trailingOK);
      if (num === null) {
        return null;
      }
      result[i] = num;
    }
  
    return result;
  }
  
  function parseMonth(token) {
    token = String(token).substr(0,3).toLowerCase();
    var num = MONTH_TO_NUM[token];
    return num >= 0 ? num : null;
  }
  
  /*
   * RFC6265 S5.1.1 date parser (see RFC for full grammar)
   */
  function parseDate(str) {
    if (!str) {
      return;
    }
  
    /* RFC6265 S5.1.1:
     * 2. Process each date-token sequentially in the order the date-tokens
     * appear in the cookie-date
     */
    var tokens = str.split(DATE_DELIM);
    if (!tokens) {
      return;
    }
  
    var hour = null;
    var minute = null;
    var second = null;
    var dayOfMonth = null;
    var month = null;
    var year = null;
  
    for (var i=0; i<tokens.length; i++) {
      var token = tokens[i].trim();
      if (!token.length) {
        continue;
      }
  
      var result;
  
      /* 2.1. If the found-time flag is not set and the token matches the time
       * production, set the found-time flag and set the hour- value,
       * minute-value, and second-value to the numbers denoted by the digits in
       * the date-token, respectively.  Skip the remaining sub-steps and continue
       * to the next date-token.
       */
      if (second === null) {
        result = parseTime(token);
        if (result) {
          hour = result[0];
          minute = result[1];
          second = result[2];
          continue;
        }
      }
  
      /* 2.2. If the found-day-of-month flag is not set and the date-token matches
       * the day-of-month production, set the found-day-of- month flag and set
       * the day-of-month-value to the number denoted by the date-token.  Skip
       * the remaining sub-steps and continue to the next date-token.
       */
      if (dayOfMonth === null) {
        // "day-of-month = 1*2DIGIT ( non-digit *OCTET )"
        result = parseDigits(token, 1, 2, true);
        if (result !== null) {
          dayOfMonth = result;
          continue;
        }
      }
  
      /* 2.3. If the found-month flag is not set and the date-token matches the
       * month production, set the found-month flag and set the month-value to
       * the month denoted by the date-token.  Skip the remaining sub-steps and
       * continue to the next date-token.
       */
      if (month === null) {
        result = parseMonth(token);
        if (result !== null) {
          month = result;
          continue;
        }
      }
  
      /* 2.4. If the found-year flag is not set and the date-token matches the
       * year production, set the found-year flag and set the year-value to the
       * number denoted by the date-token.  Skip the remaining sub-steps and
       * continue to the next date-token.
       */
      if (year === null) {
        // "year = 2*4DIGIT ( non-digit *OCTET )"
        result = parseDigits(token, 2, 4, true);
        if (result !== null) {
          year = result;
          /* From S5.1.1:
           * 3.  If the year-value is greater than or equal to 70 and less
           * than or equal to 99, increment the year-value by 1900.
           * 4.  If the year-value is greater than or equal to 0 and less
           * than or equal to 69, increment the year-value by 2000.
           */
          if (year >= 70 && year <= 99) {
            year += 1900;
          } else if (year >= 0 && year <= 69) {
            year += 2000;
          }
        }
      }
    }
  
    /* RFC 6265 S5.1.1
     * "5. Abort these steps and fail to parse the cookie-date if:
     *     *  at least one of the found-day-of-month, found-month, found-
     *        year, or found-time flags is not set,
     *     *  the day-of-month-value is less than 1 or greater than 31,
     *     *  the year-value is less than 1601,
     *     *  the hour-value is greater than 23,
     *     *  the minute-value is greater than 59, or
     *     *  the second-value is greater than 59.
     *     (Note that leap seconds cannot be represented in this syntax.)"
     *
     * So, in order as above:
     */
    if (
      dayOfMonth === null || month === null || year === null || second === null ||
      dayOfMonth < 1 || dayOfMonth > 31 ||
      year < 1601 ||
      hour > 23 ||
      minute > 59 ||
      second > 59
    ) {
      return;
    }
  
    return new Date(Date.UTC(year, month, dayOfMonth, hour, minute, second));
  }
  
  function formatDate(date) {
    var d = date.getUTCDate(); d = d >= 10 ? d : '0'+d;
    var h = date.getUTCHours(); h = h >= 10 ? h : '0'+h;
    var m = date.getUTCMinutes(); m = m >= 10 ? m : '0'+m;
    var s = date.getUTCSeconds(); s = s >= 10 ? s : '0'+s;
    return NUM_TO_DAY[date.getUTCDay()] + ', ' +
      d+' '+ NUM_TO_MONTH[date.getUTCMonth()] +' '+ date.getUTCFullYear() +' '+
      h+':'+m+':'+s+' GMT';
  }
  
  // S5.1.2 Canonicalized Host Names
  function canonicalDomain(str) {
    if (str == null) {
      return null;
    }
    str = str.trim().replace(/^\./,''); // S4.1.2.3 & S5.2.3: ignore leading .
  
    // convert to IDN if any non-ASCII characters
    if (punycode && /[^\u0001-\u007f]/.test(str)) {
      str = punycode.toASCII(str);
    }
  
    return str.toLowerCase();
  }
  
  // S5.1.3 Domain Matching
  function domainMatch(str, domStr, canonicalize) {
    if (str == null || domStr == null) {
      return null;
    }
    if (canonicalize !== false) {
      str = canonicalDomain(str);
      domStr = canonicalDomain(domStr);
    }
  
    /*
     * "The domain string and the string are identical. (Note that both the
     * domain string and the string will have been canonicalized to lower case at
     * this point)"
     */
    if (str == domStr) {
      return true;
    }
  
    /* "All of the following [three] conditions hold:" (order adjusted from the RFC) */
  
    /* "* The string is a host name (i.e., not an IP address)." */
    if (ipRegex.test(str)) {
      return false;
    }
  
    /* "* The domain string is a suffix of the string" */
    var idx = str.indexOf(domStr);
    if (idx <= 0) {
      return false; // it's a non-match (-1) or prefix (0)
    }
  
    // e.g "a.b.c".indexOf("b.c") === 2
    // 5 === 3+2
    if (str.length !== domStr.length + idx) { // it's not a suffix
      return false;
    }
  
    /* "* The last character of the string that is not included in the domain
    * string is a %x2E (".") character." */
    if (str.substr(idx-1,1) !== '.') {
      return false;
    }
  
    return true;
  }
  
  
  // RFC6265 S5.1.4 Paths and Path-Match
  
  /*
   * "The user agent MUST use an algorithm equivalent to the following algorithm
   * to compute the default-path of a cookie:"
   *
   * Assumption: the path (and not query part or absolute uri) is passed in.
   */
  function defaultPath(path) {
    // "2. If the uri-path is empty or if the first character of the uri-path is not
    // a %x2F ("/") character, output %x2F ("/") and skip the remaining steps.
    if (!path || path.substr(0,1) !== "/") {
      return "/";
    }
  
    // "3. If the uri-path contains no more than one %x2F ("/") character, output
    // %x2F ("/") and skip the remaining step."
    if (path === "/") {
      return path;
    }
  
    var rightSlash = path.lastIndexOf("/");
    if (rightSlash === 0) {
      return "/";
    }
  
    // "4. Output the characters of the uri-path from the first character up to,
    // but not including, the right-most %x2F ("/")."
    return path.slice(0, rightSlash);
  }
  
  function trimTerminator(str) {
    for (var t = 0; t < TERMINATORS.length; t++) {
      var terminatorIdx = str.indexOf(TERMINATORS[t]);
      if (terminatorIdx !== -1) {
        str = str.substr(0,terminatorIdx);
      }
    }
  
    return str;
  }
  
  function parseCookiePair(cookiePair, looseMode) {
    cookiePair = trimTerminator(cookiePair);
  
    var firstEq = cookiePair.indexOf('=');
    if (looseMode) {
      if (firstEq === 0) { // '=' is immediately at start
        cookiePair = cookiePair.substr(1);
        firstEq = cookiePair.indexOf('='); // might still need to split on '='
      }
    } else { // non-loose mode
      if (firstEq <= 0) { // no '=' or is at start
        return; // needs to have non-empty "cookie-name"
      }
    }
  
    var cookieName, cookieValue;
    if (firstEq <= 0) {
      cookieName = "";
      cookieValue = cookiePair.trim();
    } else {
      cookieName = cookiePair.substr(0, firstEq).trim();
      cookieValue = cookiePair.substr(firstEq+1).trim();
    }
  
    if (CONTROL_CHARS.test(cookieName) || CONTROL_CHARS.test(cookieValue)) {
      return;
    }
  
    var c = new Cookie();
    c.key = cookieName;
    c.value = cookieValue;
    return c;
  }
  
  function parse(str, options) {
    if (!options || typeof options !== 'object') {
      options = {};
    }
    str = str.trim();
  
    // We use a regex to parse the "name-value-pair" part of S5.2
    var firstSemi = str.indexOf(';'); // S5.2 step 1
    var cookiePair = (firstSemi === -1) ? str : str.substr(0, firstSemi);
    var c = parseCookiePair(cookiePair, !!options.loose);
    if (!c) {
      return;
    }
  
    if (firstSemi === -1) {
      return c;
    }
  
    // S5.2.3 "unparsed-attributes consist of the remainder of the set-cookie-string
    // (including the %x3B (";") in question)." plus later on in the same section
    // "discard the first ";" and trim".
    var unparsed = str.slice(firstSemi + 1).trim();
  
    // "If the unparsed-attributes string is empty, skip the rest of these
    // steps."
    if (unparsed.length === 0) {
      return c;
    }
  
    /*
     * S5.2 says that when looping over the items "[p]rocess the attribute-name
     * and attribute-value according to the requirements in the following
     * subsections" for every item.  Plus, for many of the individual attributes
     * in S5.3 it says to use the "attribute-value of the last attribute in the
     * cookie-attribute-list".  Therefore, in this implementation, we overwrite
     * the previous value.
     */
    var cookie_avs = unparsed.split(';');
    while (cookie_avs.length) {
      var av = cookie_avs.shift().trim();
      if (av.length === 0) { // happens if ";;" appears
        continue;
      }
      var av_sep = av.indexOf('=');
      var av_key, av_value;
  
      if (av_sep === -1) {
        av_key = av;
        av_value = null;
      } else {
        av_key = av.substr(0,av_sep);
        av_value = av.substr(av_sep+1);
      }
  
      av_key = av_key.trim().toLowerCase();
  
      if (av_value) {
        av_value = av_value.trim();
      }
  
      switch(av_key) {
      case 'expires': // S5.2.1
        if (av_value) {
          var exp = parseDate(av_value);
          // "If the attribute-value failed to parse as a cookie date, ignore the
          // cookie-av."
          if (exp) {
            // over and underflow not realistically a concern: V8's getTime() seems to
            // store something larger than a 32-bit time_t (even with 32-bit node)
            c.expires = exp;
          }
        }
        break;
  
      case 'max-age': // S5.2.2
        if (av_value) {
          // "If the first character of the attribute-value is not a DIGIT or a "-"
          // character ...[or]... If the remainder of attribute-value contains a
          // non-DIGIT character, ignore the cookie-av."
          if (/^-?[0-9]+$/.test(av_value)) {
            var delta = parseInt(av_value, 10);
            // "If delta-seconds is less than or equal to zero (0), let expiry-time
            // be the earliest representable date and time."
            c.setMaxAge(delta);
          }
        }
        break;
  
      case 'domain': // S5.2.3
        // "If the attribute-value is empty, the behavior is undefined.  However,
        // the user agent SHOULD ignore the cookie-av entirely."
        if (av_value) {
          // S5.2.3 "Let cookie-domain be the attribute-value without the leading %x2E
          // (".") character."
          var domain = av_value.trim().replace(/^\./, '');
          if (domain) {
            // "Convert the cookie-domain to lower case."
            c.domain = domain.toLowerCase();
          }
        }
        break;
  
      case 'path': // S5.2.4
        /*
         * "If the attribute-value is empty or if the first character of the
         * attribute-value is not %x2F ("/"):
         *   Let cookie-path be the default-path.
         * Otherwise:
         *   Let cookie-path be the attribute-value."
         *
         * We'll represent the default-path as null since it depends on the
         * context of the parsing.
         */
        c.path = av_value && av_value[0] === "/" ? av_value : null;
        break;
  
      case 'secure': // S5.2.5
        /*
         * "If the attribute-name case-insensitively matches the string "Secure",
         * the user agent MUST append an attribute to the cookie-attribute-list
         * with an attribute-name of Secure and an empty attribute-value."
         */
        c.secure = true;
        break;
  
      case 'httponly': // S5.2.6 -- effectively the same as 'secure'
        c.httpOnly = true;
        break;
  
      default:
        c.extensions = c.extensions || [];
        c.extensions.push(av);
        break;
      }
    }
  
    return c;
  }
  
  // avoid the V8 deoptimization monster!
  function jsonParse(str) {
    var obj;
    try {
      obj = JSON.parse(str);
    } catch (e) {
      return e;
    }
    return obj;
  }
  
  function fromJSON(str) {
    if (!str) {
      return null;
    }
  
    var obj;
    if (typeof str === 'string') {
      obj = jsonParse(str);
      if (obj instanceof Error) {
        return null;
      }
    } else {
      // assume it's an Object
      obj = str;
    }
  
    var c = new Cookie();
    for (var i=0; i<Cookie.serializableProperties.length; i++) {
      var prop = Cookie.serializableProperties[i];
      if (obj[prop] === undefined ||
          obj[prop] === Cookie.prototype[prop])
      {
        continue; // leave as prototype default
      }
  
      if (prop === 'expires' ||
          prop === 'creation' ||
          prop === 'lastAccessed')
      {
        if (obj[prop] === null) {
          c[prop] = null;
        } else {
          c[prop] = obj[prop] == "Infinity" ?
            "Infinity" : new Date(obj[prop]);
        }
      } else {
        c[prop] = obj[prop];
      }
    }
  
    return c;
  }
  
  /* Section 5.4 part 2:
   * "*  Cookies with longer paths are listed before cookies with
   *     shorter paths.
   *
   *  *  Among cookies that have equal-length path fields, cookies with
   *     earlier creation-times are listed before cookies with later
   *     creation-times."
   */
  
  function cookieCompare(a,b) {
    var cmp = 0;
  
    // descending for length: b CMP a
    var aPathLen = a.path ? a.path.length : 0;
    var bPathLen = b.path ? b.path.length : 0;
    cmp = bPathLen - aPathLen;
    if (cmp !== 0) {
      return cmp;
    }
  
    // ascending for time: a CMP b
    var aTime = a.creation ? a.creation.getTime() : MAX_TIME;
    var bTime = b.creation ? b.creation.getTime() : MAX_TIME;
    cmp = aTime - bTime;
    if (cmp !== 0) {
      return cmp;
    }
  
    // break ties for the same millisecond (precision of JavaScript's clock)
    cmp = a.creationIndex - b.creationIndex;
  
    return cmp;
  }
  
  // Gives the permutation of all possible pathMatch()es of a given path. The
  // array is in longest-to-shortest order.  Handy for indexing.
  function permutePath(path) {
    if (path === '/') {
      return ['/'];
    }
    if (path.lastIndexOf('/') === path.length-1) {
      path = path.substr(0,path.length-1);
    }
    var permutations = [path];
    while (path.length > 1) {
      var lindex = path.lastIndexOf('/');
      if (lindex === 0) {
        break;
      }
      path = path.substr(0,lindex);
      permutations.push(path);
    }
    permutations.push('/');
    return permutations;
  }
  
  function getCookieContext(url) {
    if (url instanceof Object) {
      return url;
    }
    // NOTE: decodeURI will throw on malformed URIs (see GH-32).
    // Therefore, we will just skip decoding for such URIs.
    try {
      url = decodeURI(url);
    }
    catch(err) {
      // Silently swallow error
    }
  
    return urlParse(url);
  }
  
  function Cookie(options) {
    options = options || {};
  
    Object.keys(options).forEach(function(prop) {
      if (Cookie.prototype.hasOwnProperty(prop) &&
          Cookie.prototype[prop] !== options[prop] &&
          prop.substr(0,1) !== '_')
      {
        this[prop] = options[prop];
      }
    }, this);
  
    this.creation = this.creation || new Date();
  
    // used to break creation ties in cookieCompare():
    Object.defineProperty(this, 'creationIndex', {
      configurable: false,
      enumerable: false, // important for assert.deepEqual checks
      writable: true,
      value: ++Cookie.cookiesCreated
    });
  }
  
  Cookie.cookiesCreated = 0; // incremented each time a cookie is created
  
  Cookie.parse = parse;
  Cookie.fromJSON = fromJSON;
  
  Cookie.prototype.key = "";
  Cookie.prototype.value = "";
  
  // the order in which the RFC has them:
  Cookie.prototype.expires = "Infinity"; // coerces to literal Infinity
  Cookie.prototype.maxAge = null; // takes precedence over expires for TTL
  Cookie.prototype.domain = null;
  Cookie.prototype.path = null;
  Cookie.prototype.secure = false;
  Cookie.prototype.httpOnly = false;
  Cookie.prototype.extensions = null;
  
  // set by the CookieJar:
  Cookie.prototype.hostOnly = null; // boolean when set
  Cookie.prototype.pathIsDefault = null; // boolean when set
  Cookie.prototype.creation = null; // Date when set; defaulted by Cookie.parse
  Cookie.prototype.lastAccessed = null; // Date when set
  Object.defineProperty(Cookie.prototype, 'creationIndex', {
    configurable: true,
    enumerable: false,
    writable: true,
    value: 0
  });
  
  Cookie.serializableProperties = Object.keys(Cookie.prototype)
    .filter(function(prop) {
      return !(
        Cookie.prototype[prop] instanceof Function ||
        prop === 'creationIndex' ||
        prop.substr(0,1) === '_'
      );
    });
  
  Cookie.prototype.inspect = function inspect() {
    var now = Date.now();
    return 'Cookie="'+this.toString() +
      '; hostOnly='+(this.hostOnly != null ? this.hostOnly : '?') +
      '; aAge='+(this.lastAccessed ? (now-this.lastAccessed.getTime())+'ms' : '?') +
      '; cAge='+(this.creation ? (now-this.creation.getTime())+'ms' : '?') +
      '"';
  };
  
  // Use the new custom inspection symbol to add the custom inspect function if
  // available.
  if (util.inspect.custom) {
    Cookie.prototype[util.inspect.custom] = Cookie.prototype.inspect;
  }
  
  Cookie.prototype.toJSON = function() {
    var obj = {};
  
    var props = Cookie.serializableProperties;
    for (var i=0; i<props.length; i++) {
      var prop = props[i];
      if (this[prop] === Cookie.prototype[prop]) {
        continue; // leave as prototype default
      }
  
      if (prop === 'expires' ||
          prop === 'creation' ||
          prop === 'lastAccessed')
      {
        if (this[prop] === null) {
          obj[prop] = null;
        } else {
          obj[prop] = this[prop] == "Infinity" ? // intentionally not ===
            "Infinity" : this[prop].toISOString();
        }
      } else if (prop === 'maxAge') {
        if (this[prop] !== null) {
          // again, intentionally not ===
          obj[prop] = (this[prop] == Infinity || this[prop] == -Infinity) ?
            this[prop].toString() : this[prop];
        }
      } else {
        if (this[prop] !== Cookie.prototype[prop]) {
          obj[prop] = this[prop];
        }
      }
    }
  
    return obj;
  };
  
  Cookie.prototype.clone = function() {
    return fromJSON(this.toJSON());
  };
  
  Cookie.prototype.validate = function validate() {
    if (!COOKIE_OCTETS.test(this.value)) {
      return false;
    }
    if (this.expires != Infinity && !(this.expires instanceof Date) && !parseDate(this.expires)) {
      return false;
    }
    if (this.maxAge != null && this.maxAge <= 0) {
      return false; // "Max-Age=" non-zero-digit *DIGIT
    }
    if (this.path != null && !PATH_VALUE.test(this.path)) {
      return false;
    }
  
    var cdomain = this.cdomain();
    if (cdomain) {
      if (cdomain.match(/\.$/)) {
        return false; // S4.1.2.3 suggests that this is bad. domainMatch() tests confirm this
      }
      var suffix = pubsuffix.getPublicSuffix(cdomain);
      if (suffix == null) { // it's a public suffix
        return false;
      }
    }
    return true;
  };
  
  Cookie.prototype.setExpires = function setExpires(exp) {
    if (exp instanceof Date) {
      this.expires = exp;
    } else {
      this.expires = parseDate(exp) || "Infinity";
    }
  };
  
  Cookie.prototype.setMaxAge = function setMaxAge(age) {
    if (age === Infinity || age === -Infinity) {
      this.maxAge = age.toString(); // so JSON.stringify() works
    } else {
      this.maxAge = age;
    }
  };
  
  // gives Cookie header format
  Cookie.prototype.cookieString = function cookieString() {
    var val = this.value;
    if (val == null) {
      val = '';
    }
    if (this.key === '') {
      return val;
    }
    return this.key+'='+val;
  };
  
  // gives Set-Cookie header format
  Cookie.prototype.toString = function toString() {
    var str = this.cookieString();
  
    if (this.expires != Infinity) {
      if (this.expires instanceof Date) {
        str += '; Expires='+formatDate(this.expires);
      } else {
        str += '; Expires='+this.expires;
      }
    }
  
    if (this.maxAge != null && this.maxAge != Infinity) {
      str += '; Max-Age='+this.maxAge;
    }
  
    if (this.domain && !this.hostOnly) {
      str += '; Domain='+this.domain;
    }
    if (this.path) {
      str += '; Path='+this.path;
    }
  
    if (this.secure) {
      str += '; Secure';
    }
    if (this.httpOnly) {
      str += '; HttpOnly';
    }
    if (this.extensions) {
      this.extensions.forEach(function(ext) {
        str += '; '+ext;
      });
    }
  
    return str;
  };
  
  // TTL() partially replaces the "expiry-time" parts of S5.3 step 3 (setCookie()
  // elsewhere)
  // S5.3 says to give the "latest representable date" for which we use Infinity
  // For "expired" we use 0
  Cookie.prototype.TTL = function TTL(now) {
    /* RFC6265 S4.1.2.2 If a cookie has both the Max-Age and the Expires
     * attribute, the Max-Age attribute has precedence and controls the
     * expiration date of the cookie.
     * (Concurs with S5.3 step 3)
     */
    if (this.maxAge != null) {
      return this.maxAge<=0 ? 0 : this.maxAge*1000;
    }
  
    var expires = this.expires;
    if (expires != Infinity) {
      if (!(expires instanceof Date)) {
        expires = parseDate(expires) || Infinity;
      }
  
      if (expires == Infinity) {
        return Infinity;
      }
  
      return expires.getTime() - (now || Date.now());
    }
  
    return Infinity;
  };
  
  // expiryTime() replaces the "expiry-time" parts of S5.3 step 3 (setCookie()
  // elsewhere)
  Cookie.prototype.expiryTime = function expiryTime(now) {
    if (this.maxAge != null) {
      var relativeTo = now || this.creation || new Date();
      var age = (this.maxAge <= 0) ? -Infinity : this.maxAge*1000;
      return relativeTo.getTime() + age;
    }
  
    if (this.expires == Infinity) {
      return Infinity;
    }
    return this.expires.getTime();
  };
  
  // expiryDate() replaces the "expiry-time" parts of S5.3 step 3 (setCookie()
  // elsewhere), except it returns a Date
  Cookie.prototype.expiryDate = function expiryDate(now) {
    var millisec = this.expiryTime(now);
    if (millisec == Infinity) {
      return new Date(MAX_TIME);
    } else if (millisec == -Infinity) {
      return new Date(MIN_TIME);
    } else {
      return new Date(millisec);
    }
  };
  
  // This replaces the "persistent-flag" parts of S5.3 step 3
  Cookie.prototype.isPersistent = function isPersistent() {
    return (this.maxAge != null || this.expires != Infinity);
  };
  
  // Mostly S5.1.2 and S5.2.3:
  Cookie.prototype.cdomain =
  Cookie.prototype.canonicalizedDomain = function canonicalizedDomain() {
    if (this.domain == null) {
      return null;
    }
    return canonicalDomain(this.domain);
  };
  
  function CookieJar(store, options) {
    if (typeof options === "boolean") {
      options = {rejectPublicSuffixes: options};
    } else if (options == null) {
      options = {};
    }
    if (options.rejectPublicSuffixes != null) {
      this.rejectPublicSuffixes = options.rejectPublicSuffixes;
    }
    if (options.looseMode != null) {
      this.enableLooseMode = options.looseMode;
    }
  
    if (!store) {
      store = new MemoryCookieStore();
    }
    this.store = store;
  }
  CookieJar.prototype.store = null;
  CookieJar.prototype.rejectPublicSuffixes = true;
  CookieJar.prototype.enableLooseMode = false;
  var CAN_BE_SYNC = [];
  
  CAN_BE_SYNC.push('setCookie');
  CookieJar.prototype.setCookie = function(cookie, url, options, cb) {
    var err;
    var context = getCookieContext(url);
    if (options instanceof Function) {
      cb = options;
      options = {};
    }
  
    var host = canonicalDomain(context.hostname);
    var loose = this.enableLooseMode;
    if (options.loose != null) {
      loose = options.loose;
    }
  
    // S5.3 step 1
    if (typeof(cookie) === 'string' || cookie instanceof String) {
      cookie = Cookie.parse(cookie, { loose: loose });
      if (!cookie) {
        err = new Error("Cookie failed to parse");
        return cb(options.ignoreError ? null : err);
      }
    }
    else if (!(cookie instanceof Cookie)) {
      // If you're seeing this error, and are passing in a Cookie object, 
      // it *might* be a Cookie object from another loaded version of tough-cookie.
      err = new Error("First argument to setCookie must be a Cookie object or string");
      return cb(options.ignoreError ? null : err);
    }
  
    // S5.3 step 2
    var now = options.now || new Date(); // will assign later to save effort in the face of errors
  
    // S5.3 step 3: NOOP; persistent-flag and expiry-time is handled by getCookie()
  
    // S5.3 step 4: NOOP; domain is null by default
  
    // S5.3 step 5: public suffixes
    if (this.rejectPublicSuffixes && cookie.domain) {
      var suffix = pubsuffix.getPublicSuffix(cookie.cdomain());
      if (suffix == null) { // e.g. "com"
        err = new Error("Cookie has domain set to a public suffix");
        return cb(options.ignoreError ? null : err);
      }
    }
  
    // S5.3 step 6:
    if (cookie.domain) {
      if (!domainMatch(host, cookie.cdomain(), false)) {
        err = new Error("Cookie not in this host's domain. Cookie:"+cookie.cdomain()+" Request:"+host);
        return cb(options.ignoreError ? null : err);
      }
  
      if (cookie.hostOnly == null) { // don't reset if already set
        cookie.hostOnly = false;
      }
  
    } else {
      cookie.hostOnly = true;
      cookie.domain = host;
    }
  
    //S5.2.4 If the attribute-value is empty or if the first character of the
    //attribute-value is not %x2F ("/"):
    //Let cookie-path be the default-path.
    if (!cookie.path || cookie.path[0] !== '/') {
      cookie.path = defaultPath(context.pathname);
      cookie.pathIsDefault = true;
    }
  
    // S5.3 step 8: NOOP; secure attribute
    // S5.3 step 9: NOOP; httpOnly attribute
  
    // S5.3 step 10
    if (options.http === false && cookie.httpOnly) {
      err = new Error("Cookie is HttpOnly and this isn't an HTTP API");
      return cb(options.ignoreError ? null : err);
    }
  
    var store = this.store;
  
    if (!store.updateCookie) {
      store.updateCookie = function(oldCookie, newCookie, cb) {
        this.putCookie(newCookie, cb);
      };
    }
  
    function withCookie(err, oldCookie) {
      if (err) {
        return cb(err);
      }
  
      var next = function(err) {
        if (err) {
          return cb(err);
        } else {
          cb(null, cookie);
        }
      };
  
      if (oldCookie) {
        // S5.3 step 11 - "If the cookie store contains a cookie with the same name,
        // domain, and path as the newly created cookie:"
        if (options.http === false && oldCookie.httpOnly) { // step 11.2
          err = new Error("old Cookie is HttpOnly and this isn't an HTTP API");
          return cb(options.ignoreError ? null : err);
        }
        cookie.creation = oldCookie.creation; // step 11.3
        cookie.creationIndex = oldCookie.creationIndex; // preserve tie-breaker
        cookie.lastAccessed = now;
        // Step 11.4 (delete cookie) is implied by just setting the new one:
        store.updateCookie(oldCookie, cookie, next); // step 12
  
      } else {
        cookie.creation = cookie.lastAccessed = now;
        store.putCookie(cookie, next); // step 12
      }
    }
  
    store.findCookie(cookie.domain, cookie.path, cookie.key, withCookie);
  };
  
  // RFC6365 S5.4
  CAN_BE_SYNC.push('getCookies');
  CookieJar.prototype.getCookies = function(url, options, cb) {
    var context = getCookieContext(url);
    if (options instanceof Function) {
      cb = options;
      options = {};
    }
  
    var host = canonicalDomain(context.hostname);
    var path = context.pathname || '/';
  
    var secure = options.secure;
    if (secure == null && context.protocol &&
        (context.protocol == 'https:' || context.protocol == 'wss:'))
    {
      secure = true;
    }
  
    var http = options.http;
    if (http == null) {
      http = true;
    }
  
    var now = options.now || Date.now();
    var expireCheck = options.expire !== false;
    var allPaths = !!options.allPaths;
    var store = this.store;
  
    function matchingCookie(c) {
      // "Either:
      //   The cookie's host-only-flag is true and the canonicalized
      //   request-host is identical to the cookie's domain.
      // Or:
      //   The cookie's host-only-flag is false and the canonicalized
      //   request-host domain-matches the cookie's domain."
      if (c.hostOnly) {
        if (c.domain != host) {
          return false;
        }
      } else {
        if (!domainMatch(host, c.domain, false)) {
          return false;
        }
      }
  
      // "The request-uri's path path-matches the cookie's path."
      if (!allPaths && !pathMatch(path, c.path)) {
        return false;
      }
  
      // "If the cookie's secure-only-flag is true, then the request-uri's
      // scheme must denote a "secure" protocol"
      if (c.secure && !secure) {
        return false;
      }
  
      // "If the cookie's http-only-flag is true, then exclude the cookie if the
      // cookie-string is being generated for a "non-HTTP" API"
      if (c.httpOnly && !http) {
        return false;
      }
  
      // deferred from S5.3
      // non-RFC: allow retention of expired cookies by choice
      if (expireCheck && c.expiryTime() <= now) {
        store.removeCookie(c.domain, c.path, c.key, function(){}); // result ignored
        return false;
      }
  
      return true;
    }
  
    store.findCookies(host, allPaths ? null : path, function(err,cookies) {
      if (err) {
        return cb(err);
      }
  
      cookies = cookies.filter(matchingCookie);
  
      // sorting of S5.4 part 2
      if (options.sort !== false) {
        cookies = cookies.sort(cookieCompare);
      }
  
      // S5.4 part 3
      var now = new Date();
      cookies.forEach(function(c) {
        c.lastAccessed = now;
      });
      // TODO persist lastAccessed
  
      cb(null,cookies);
    });
  };
  
  CAN_BE_SYNC.push('getCookieString');
  CookieJar.prototype.getCookieString = function(/*..., cb*/) {
    var args = Array.prototype.slice.call(arguments,0);
    var cb = args.pop();
    var next = function(err,cookies) {
      if (err) {
        cb(err);
      } else {
        cb(null, cookies
          .sort(cookieCompare)
          .map(function(c){
            return c.cookieString();
          })
          .join('; '));
      }
    };
    args.push(next);
    this.getCookies.apply(this,args);
  };
  
  CAN_BE_SYNC.push('getSetCookieStrings');
  CookieJar.prototype.getSetCookieStrings = function(/*..., cb*/) {
    var args = Array.prototype.slice.call(arguments,0);
    var cb = args.pop();
    var next = function(err,cookies) {
      if (err) {
        cb(err);
      } else {
        cb(null, cookies.map(function(c){
          return c.toString();
        }));
      }
    };
    args.push(next);
    this.getCookies.apply(this,args);
  };
  
  CAN_BE_SYNC.push('serialize');
  CookieJar.prototype.serialize = function(cb) {
    var type = this.store.constructor.name;
    if (type === 'Object') {
      type = null;
    }
  
    // update README.md "Serialization Format" if you change this, please!
    var serialized = {
      // The version of tough-cookie that serialized this jar. Generally a good
      // practice since future versions can make data import decisions based on
      // known past behavior. When/if this matters, use `semver`.
      version: 'tough-cookie@'+VERSION,
  
      // add the store type, to make humans happy:
      storeType: type,
  
      // CookieJar configuration:
      rejectPublicSuffixes: !!this.rejectPublicSuffixes,
  
      // this gets filled from getAllCookies:
      cookies: []
    };
  
    if (!(this.store.getAllCookies &&
          typeof this.store.getAllCookies === 'function'))
    {
      return cb(new Error('store does not support getAllCookies and cannot be serialized'));
    }
  
    this.store.getAllCookies(function(err,cookies) {
      if (err) {
        return cb(err);
      }
  
      serialized.cookies = cookies.map(function(cookie) {
        // convert to serialized 'raw' cookies
        cookie = (cookie instanceof Cookie) ? cookie.toJSON() : cookie;
  
        // Remove the index so new ones get assigned during deserialization
        delete cookie.creationIndex;
  
        return cookie;
      });
  
      return cb(null, serialized);
    });
  };
  
  // well-known name that JSON.stringify calls
  CookieJar.prototype.toJSON = function() {
    return this.serializeSync();
  };
  
  // use the class method CookieJar.deserialize instead of calling this directly
  CAN_BE_SYNC.push('_importCookies');
  CookieJar.prototype._importCookies = function(serialized, cb) {
    var jar = this;
    var cookies = serialized.cookies;
    if (!cookies || !Array.isArray(cookies)) {
      return cb(new Error('serialized jar has no cookies array'));
    }
    cookies = cookies.slice(); // do not modify the original
  
    function putNext(err) {
      if (err) {
        return cb(err);
      }
  
      if (!cookies.length) {
        return cb(err, jar);
      }
  
      var cookie;
      try {
        cookie = fromJSON(cookies.shift());
      } catch (e) {
        return cb(e);
      }
  
      if (cookie === null) {
        return putNext(null); // skip this cookie
      }
  
      jar.store.putCookie(cookie, putNext);
    }
  
    putNext();
  };
  
  CookieJar.deserialize = function(strOrObj, store, cb) {
    if (arguments.length !== 3) {
      // store is optional
      cb = store;
      store = null;
    }
  
    var serialized;
    if (typeof strOrObj === 'string') {
      serialized = jsonParse(strOrObj);
      if (serialized instanceof Error) {
        return cb(serialized);
      }
    } else {
      serialized = strOrObj;
    }
  
    var jar = new CookieJar(store, serialized.rejectPublicSuffixes);
    jar._importCookies(serialized, function(err) {
      if (err) {
        return cb(err);
      }
      cb(null, jar);
    });
  };
  
  CookieJar.deserializeSync = function(strOrObj, store) {
    var serialized = typeof strOrObj === 'string' ?
      JSON.parse(strOrObj) : strOrObj;
    var jar = new CookieJar(store, serialized.rejectPublicSuffixes);
  
    // catch this mistake early:
    if (!jar.store.synchronous) {
      throw new Error('CookieJar store is not synchronous; use async API instead.');
    }
  
    jar._importCookiesSync(serialized);
    return jar;
  };
  CookieJar.fromJSON = CookieJar.deserializeSync;
  
  CookieJar.prototype.clone = function(newStore, cb) {
    if (arguments.length === 1) {
      cb = newStore;
      newStore = null;
    }
  
    this.serialize(function(err,serialized) {
      if (err) {
        return cb(err);
      }
      CookieJar.deserialize(serialized, newStore, cb);
    });
  };
  
  CAN_BE_SYNC.push('removeAllCookies');
  CookieJar.prototype.removeAllCookies = function(cb) {
    var store = this.store;
  
    // Check that the store implements its own removeAllCookies(). The default
    // implementation in Store will immediately call the callback with a "not
    // implemented" Error.
    if (store.removeAllCookies instanceof Function &&
        store.removeAllCookies !== Store.prototype.removeAllCookies)
    {
      return store.removeAllCookies(cb);
    }
  
    store.getAllCookies(function(err, cookies) {
      if (err) {
        return cb(err);
      }
  
      if (cookies.length === 0) {
        return cb(null);
      }
  
      var completedCount = 0;
      var removeErrors = [];
  
      function removeCookieCb(removeErr) {
        if (removeErr) {
          removeErrors.push(removeErr);
        }
  
        completedCount++;
  
        if (completedCount === cookies.length) {
          return cb(removeErrors.length ? removeErrors[0] : null);
        }
      }
  
      cookies.forEach(function(cookie) {
        store.removeCookie(cookie.domain, cookie.path, cookie.key, removeCookieCb);
      });
    });
  };
  
  CookieJar.prototype._cloneSync = syncWrap('clone');
  CookieJar.prototype.cloneSync = function(newStore) {
    if (!newStore.synchronous) {
      throw new Error('CookieJar clone destination store is not synchronous; use async API instead.');
    }
    return this._cloneSync(newStore);
  };
  
  // Use a closure to provide a true imperative API for synchronous stores.
  function syncWrap(method) {
    return function() {
      if (!this.store.synchronous) {
        throw new Error('CookieJar store is not synchronous; use async API instead.');
      }
  
      var args = Array.prototype.slice.call(arguments);
      var syncErr, syncResult;
      args.push(function syncCb(err, result) {
        syncErr = err;
        syncResult = result;
      });
      this[method].apply(this, args);
  
      if (syncErr) {
        throw syncErr;
      }
      return syncResult;
    };
  }
  
  // wrap all declared CAN_BE_SYNC methods in the sync wrapper
  CAN_BE_SYNC.forEach(function(method) {
    CookieJar.prototype[method+'Sync'] = syncWrap(method);
  });
  
  exports.version = VERSION;
  exports.CookieJar = CookieJar;
  exports.Cookie = Cookie;
  exports.Store = Store;
  exports.MemoryCookieStore = MemoryCookieStore;
  exports.parseDate = parseDate;
  exports.formatDate = formatDate;
  exports.parse = parse;
  exports.fromJSON = fromJSON;
  exports.domainMatch = domainMatch;
  exports.defaultPath = defaultPath;
  exports.pathMatch = pathMatch;
  exports.getPublicSuffix = pubsuffix.getPublicSuffix;
  exports.cookieCompare = cookieCompare;
  exports.permuteDomain = __webpack_require__(231).permuteDomain;
  exports.permutePath = permutePath;
  exports.canonicalDomain = canonicalDomain;
  
  
  /***/ }),
  
  /***/ 113:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  const path = __webpack_require__(589)
  const assert = __webpack_require__(393)
  
  const isWindows = (process.platform === 'win32')
  
  function defaults (options) {
    const methods = [
      'unlink',
      'chmod',
      'stat',
      'lstat',
      'rmdir',
      'readdir'
    ]
    methods.forEach(m => {
      options[m] = options[m] || fs[m]
      m = m + 'Sync'
      options[m] = options[m] || fs[m]
    })
  
    options.maxBusyTries = options.maxBusyTries || 3
  }
  
  function rimraf (p, options, cb) {
    let busyTries = 0
  
    if (typeof options === 'function') {
      cb = options
      options = {}
    }
  
    assert(p, 'rimraf: missing path')
    assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')
    assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required')
    assert(options, 'rimraf: invalid options argument provided')
    assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')
  
    defaults(options)
  
    rimraf_(p, options, function CB (er) {
      if (er) {
        if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
            busyTries < options.maxBusyTries) {
          busyTries++
          const time = busyTries * 100
          // try again, with the same exact callback as this one.
          return setTimeout(() => rimraf_(p, options, CB), time)
        }
  
        // already gone
        if (er.code === 'ENOENT') er = null
      }
  
      cb(er)
    })
  }
  
  // Two possible strategies.
  // 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
  // 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
  //
  // Both result in an extra syscall when you guess wrong.  However, there
  // are likely far more normal files in the world than directories.  This
  // is based on the assumption that a the average number of files per
  // directory is >= 1.
  //
  // If anyone ever complains about this, then I guess the strategy could
  // be made configurable somehow.  But until then, YAGNI.
  function rimraf_ (p, options, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    // sunos lets the root user unlink directories, which is... weird.
    // so we have to lstat here and make sure it's not a dir.
    options.lstat(p, (er, st) => {
      if (er && er.code === 'ENOENT') {
        return cb(null)
      }
  
      // Windows can EPERM on stat.  Life is suffering.
      if (er && er.code === 'EPERM' && isWindows) {
        return fixWinEPERM(p, options, er, cb)
      }
  
      if (st && st.isDirectory()) {
        return rmdir(p, options, er, cb)
      }
  
      options.unlink(p, er => {
        if (er) {
          if (er.code === 'ENOENT') {
            return cb(null)
          }
          if (er.code === 'EPERM') {
            return (isWindows)
              ? fixWinEPERM(p, options, er, cb)
              : rmdir(p, options, er, cb)
          }
          if (er.code === 'EISDIR') {
            return rmdir(p, options, er, cb)
          }
        }
        return cb(er)
      })
    })
  }
  
  function fixWinEPERM (p, options, er, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
    if (er) {
      assert(er instanceof Error)
    }
  
    options.chmod(p, 0o666, er2 => {
      if (er2) {
        cb(er2.code === 'ENOENT' ? null : er)
      } else {
        options.stat(p, (er3, stats) => {
          if (er3) {
            cb(er3.code === 'ENOENT' ? null : er)
          } else if (stats.isDirectory()) {
            rmdir(p, options, er, cb)
          } else {
            options.unlink(p, cb)
          }
        })
      }
    })
  }
  
  function fixWinEPERMSync (p, options, er) {
    let stats
  
    assert(p)
    assert(options)
    if (er) {
      assert(er instanceof Error)
    }
  
    try {
      options.chmodSync(p, 0o666)
    } catch (er2) {
      if (er2.code === 'ENOENT') {
        return
      } else {
        throw er
      }
    }
  
    try {
      stats = options.statSync(p)
    } catch (er3) {
      if (er3.code === 'ENOENT') {
        return
      } else {
        throw er
      }
    }
  
    if (stats.isDirectory()) {
      rmdirSync(p, options, er)
    } else {
      options.unlinkSync(p)
    }
  }
  
  function rmdir (p, options, originalEr, cb) {
    assert(p)
    assert(options)
    if (originalEr) {
      assert(originalEr instanceof Error)
    }
    assert(typeof cb === 'function')
  
    // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
    // if we guessed wrong, and it's not a directory, then
    // raise the original error.
    options.rmdir(p, er => {
      if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
        rmkids(p, options, cb)
      } else if (er && er.code === 'ENOTDIR') {
        cb(originalEr)
      } else {
        cb(er)
      }
    })
  }
  
  function rmkids (p, options, cb) {
    assert(p)
    assert(options)
    assert(typeof cb === 'function')
  
    options.readdir(p, (er, files) => {
      if (er) return cb(er)
  
      let n = files.length
      let errState
  
      if (n === 0) return options.rmdir(p, cb)
  
      files.forEach(f => {
        rimraf(path.join(p, f), options, er => {
          if (errState) {
            return
          }
          if (er) return cb(errState = er)
          if (--n === 0) {
            options.rmdir(p, cb)
          }
        })
      })
    })
  }
  
  // this looks simpler, and is strictly *faster*, but will
  // tie up the JavaScript thread and fail on excessively
  // deep directory trees.
  function rimrafSync (p, options) {
    let st
  
    options = options || {}
    defaults(options)
  
    assert(p, 'rimraf: missing path')
    assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string')
    assert(options, 'rimraf: missing options')
    assert.strictEqual(typeof options, 'object', 'rimraf: options should be object')
  
    try {
      st = options.lstatSync(p)
    } catch (er) {
      if (er.code === 'ENOENT') {
        return
      }
  
      // Windows can EPERM on stat.  Life is suffering.
      if (er.code === 'EPERM' && isWindows) {
        fixWinEPERMSync(p, options, er)
      }
    }
  
    try {
      // sunos lets the root user unlink directories, which is... weird.
      if (st && st.isDirectory()) {
        rmdirSync(p, options, null)
      } else {
        options.unlinkSync(p)
      }
    } catch (er) {
      if (er.code === 'ENOENT') {
        return
      } else if (er.code === 'EPERM') {
        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
      } else if (er.code !== 'EISDIR') {
        throw er
      }
      rmdirSync(p, options, er)
    }
  }
  
  function rmdirSync (p, options, originalEr) {
    assert(p)
    assert(options)
    if (originalEr) {
      assert(originalEr instanceof Error)
    }
  
    try {
      options.rmdirSync(p)
    } catch (er) {
      if (er.code === 'ENOTDIR') {
        throw originalEr
      } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
        rmkidsSync(p, options)
      } else if (er.code !== 'ENOENT') {
        throw er
      }
    }
  }
  
  function rmkidsSync (p, options) {
    assert(p)
    assert(options)
    options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
  
    if (isWindows) {
      // We only end up here once we got ENOTEMPTY at least once, and
      // at this point, we are guaranteed to have removed all the kids.
      // So, we know that it won't be ENOENT or ENOTDIR or anything else.
      // try really hard to delete stuff on windows, because it has a
      // PROFOUNDLY annoying habit of not closing handles promptly when
      // files are deleted, resulting in spurious ENOTEMPTY errors.
      const startTime = Date.now()
      do {
        try {
          const ret = options.rmdirSync(p, options)
          return ret
        } catch (er) { }
      } while (Date.now() - startTime < 500) // give up after 500ms
    } else {
      const ret = options.rmdirSync(p, options)
      return ret
    }
  }
  
  module.exports = rimraf
  rimraf.sync = rimrafSync
  
  
  /***/ }),
  
  /***/ 121:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http2_1 = __webpack_require__(675);
  const url_1 = __webpack_require__(986);
  const callguard_1 = __webpack_require__(382);
  const core_1 = __webpack_require__(570);
  const request_1 = __webpack_require__(673);
  const response_1 = __webpack_require__(973);
  const utils_1 = __webpack_require__(760);
  const utils_http2_1 = __webpack_require__(987);
  const { HTTP2_HEADER_PATH, } = http2_1.constants;
  class H2Context {
      constructor(getDecoders, getSessionOptions) {
          this._h2sessions = new Map();
          this._h2staleSessions = new Map();
          this._getDecoders = getDecoders;
          this._getSessionOptions = getSessionOptions;
          /* istanbul ignore next */
          if (process.env.DEBUG_FETCH_H2) {
              const debug = (line, ...args) => {
                  // tslint:disable-next-line
                  console.error(line, ...args);
              };
              const printSession = (origin, session) => {
                  debug("  Origin:", origin);
                  debug("   Ref-counter:", session.__fetch_h2_refcount);
                  debug("   Destroyed:", session.destroyed);
                  debug("   Destroyed mark:", session.__fetch_h2_destroyed);
              };
              process.on("SIGUSR2", () => {
                  debug("[Debug fetch-h2]: H2 sessions");
                  debug(" Active sessions");
                  [...this._h2sessions.entries()]
                      .forEach(([origin, { session }]) => {
                      printSession(origin, session);
                  });
                  debug(" Stale sessions");
                  [...this._h2staleSessions.entries()]
                      .forEach(([origin, set]) => {
                      [...set]
                          .forEach((session) => {
                          printSession(origin, session);
                      });
                  });
              });
          }
      }
      hasOrigin(origin) {
          return this._h2sessions.has(origin);
      }
      getOrCreateHttp2(origin, extraOptions) {
          const willCreate = !this._h2sessions.has(origin);
          if (willCreate) {
              const sessionItem = this.connectHttp2(origin, extraOptions);
              const { promise } = sessionItem;
              // Handle session closure (delete from store)
              promise
                  .then(session => {
                  session.once("close", () => this.disconnect(origin, session));
                  session.once("goaway", (_errorCode, _lastStreamID, _opaqueData) => {
                      utils_http2_1.setGotGoaway(session);
                      this.releaseSession(origin);
                  });
              })
                  .catch(() => {
                  if (sessionItem.session)
                      this.disconnect(origin, sessionItem.session);
              });
              this._h2sessions.set(origin, sessionItem);
          }
          const { promise: session, ref, unref } = this._h2sessions.get(origin);
          if (!willCreate)
              // This was re-used
              ref();
          // Avoid potential double-clean races
          let hasCleanedUp = false;
          const cleanup = () => {
              if (hasCleanedUp)
                  return;
              hasCleanedUp = true;
              unref();
          };
          return {
              cleanup,
              didCreate: willCreate,
              session,
          };
      }
      disconnectSession(session) {
          return new Promise(resolve => {
              if (session.destroyed)
                  return resolve();
              session.once("close", () => resolve());
              session.destroy();
          });
      }
      releaseSession(origin) {
          const sessionItem = this.deleteActiveSession(origin);
          if (!sessionItem)
              return;
          if (!this._h2staleSessions.has(origin))
              this._h2staleSessions.set(origin, new Set());
          this._h2staleSessions.get(origin)
              .add(sessionItem.session);
      }
      deleteActiveSession(origin) {
          const sessionItem = this._h2sessions.get(origin);
          if (!sessionItem)
              return;
          this._h2sessions.delete(origin);
          sessionItem.session.unref();
          // Never re-ref, this session is over
          utils_http2_1.setDestroyed(sessionItem.session);
          return sessionItem;
      }
      async disconnectStaleSessions(origin) {
          const promises = [];
          const sessionSet = this._h2staleSessions.get(origin);
          if (!sessionSet)
              return;
          this._h2staleSessions.delete(origin);
          for (const session of sessionSet)
              promises.push(this.disconnectSession(session));
          return Promise.all(promises).then(() => { });
      }
      disconnectAll() {
          const promises = [];
          for (const eventualH2session of this._h2sessions.values()) {
              promises.push(this.handleDisconnect(eventualH2session));
          }
          this._h2sessions.clear();
          for (const origin of this._h2staleSessions.keys()) {
              promises.push(this.disconnectStaleSessions(origin));
          }
          return Promise.all(promises).then(() => { });
      }
      disconnect(url, session) {
          const { origin } = new url_1.URL(url);
          const promises = [];
          const sessionItem = this.deleteActiveSession(origin);
          if (sessionItem && (!session || sessionItem.session === session))
              promises.push(this.handleDisconnect(sessionItem));
          if (!session) {
              promises.push(this.disconnectStaleSessions(origin));
          }
          else if (this._h2staleSessions.has(origin)) {
              const sessionSet = this._h2staleSessions.get(origin);
              if (sessionSet.has(session)) {
                  sessionSet.delete(session);
                  promises.push(this.disconnectSession(session));
              }
          }
          return Promise.all(promises).then(() => { });
      }
      handleDisconnect(sessionItem) {
          const { promise, session } = sessionItem;
          if (session)
              session.destroy();
          return promise
              .then(_h2session => { })
              .catch(err => {
              const debugMode = false;
              if (debugMode)
                  // tslint:disable-next-line
                  console.warn("Disconnect error", err);
          });
      }
      handlePush(origin, pushedStream, requestHeaders, ref, unref) {
          if (!this._pushHandler)
              return; // Drop push. TODO: Signal through error log: #8
          const path = requestHeaders[HTTP2_HEADER_PATH];
          // Remove pseudo-headers
          Object.keys(requestHeaders)
              .filter(name => name.charAt(0) === ":")
              .forEach(name => { delete requestHeaders[name]; });
          const pushedRequest = new request_1.Request(path, { headers: requestHeaders });
          ref();
          const futureResponse = new Promise((resolve, reject) => {
              const guard = callguard_1.syncGuard(reject, { catchAsync: true });
              pushedStream.once("close", unref);
              pushedStream.once("aborted", () => reject(new core_1.AbortError("Response aborted")));
              pushedStream.once("frameError", () => reject(new Error("Push request failed")));
              pushedStream.once("error", reject);
              pushedStream.once("push", guard((responseHeaders) => {
                  const response = new response_1.StreamResponse(this._getDecoders(origin), path, pushedStream, responseHeaders, false, {}, void 0, 2, false);
                  resolve(response);
              }));
          });
          futureResponse
              .catch(_err => { }); // TODO: #8
          const getResponse = () => futureResponse;
          return this._pushHandler(origin, pushedRequest, getResponse);
      }
      connectHttp2(origin, extraOptions = {}) {
          const makeConnectionTimeout = () => new core_1.TimeoutError(`Connection timeout to ${origin}`);
          const makeError = (event) => event
              ? new Error(`Unknown connection error (${event}): ${origin}`)
              : new Error(`Connection closed`);
          let session = void 0;
          // TODO: #8
          // tslint:disable-next-line
          const aGuard = callguard_1.asyncGuard(console.error.bind(console));
          const sessionRefs = {};
          const makeRefs = (session) => {
              const monkeySession = session;
              monkeySession.__fetch_h2_refcount = 1; // Begins ref'd
              sessionRefs.ref = () => {
                  if (utils_http2_1.isDestroyed(session))
                      return;
                  if (monkeySession.__fetch_h2_refcount === 0)
                      // Go from unref'd to ref'd
                      session.ref();
                  ++monkeySession.__fetch_h2_refcount;
              };
              sessionRefs.unref = () => {
                  if (session.destroyed)
                      return;
                  --monkeySession.__fetch_h2_refcount;
                  if (monkeySession.__fetch_h2_refcount === 0)
                      // Go from ref'd to unref'd
                      session.unref();
              };
          };
          const options = {
              ...this._getSessionOptions(origin),
              ...extraOptions,
          };
          const promise = new Promise((resolve, reject) => {
              session =
                  http2_1.connect(origin, options, () => resolve(session));
              makeRefs(session);
              session.on("stream", aGuard((stream, headers) => this.handlePush(origin, stream, headers, sessionRefs.ref, sessionRefs.unref)));
              session.once("close", () => reject(utils_1.makeOkError(makeError())));
              session.once("timeout", () => reject(makeConnectionTimeout()));
              session.once("error", reject);
          });
          return {
              promise,
              ref: sessionRefs.ref,
              session,
              unref: sessionRefs.unref,
          };
      }
  }
  exports.H2Context = H2Context;
  //# sourceMappingURL=context-http2.js.map
  
  /***/ }),
  
  /***/ 132:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const events_1 = __webpack_require__(485);
  exports.signalEvent = "internal-abort";
  class AbortSignalImpl extends events_1.EventEmitter {
      constructor() {
          super();
          this.aborted = false;
          this.onabort = () => { };
          this.once(exports.signalEvent, () => {
              this.aborted = true;
              this.emit("abort");
              this.onabort && this.onabort();
          });
      }
  }
  class AbortController {
      constructor() {
          this.signal = new AbortSignalImpl();
          this.abort = () => {
              this.signal.emit(exports.signalEvent);
          };
      }
  }
  exports.AbortController = AbortController;
  //# sourceMappingURL=abort.js.map
  
  /***/ }),
  
  /***/ 136:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(589)
  const mkdir = __webpack_require__(562)
  const pathExists = __webpack_require__(734).pathExists
  const jsonFile = __webpack_require__(552)
  
  function outputJson (file, data, options, callback) {
    if (typeof options === 'function') {
      callback = options
      options = {}
    }
  
    const dir = path.dirname(file)
  
    pathExists(dir, (err, itDoes) => {
      if (err) return callback(err)
      if (itDoes) return jsonFile.writeJson(file, data, options, callback)
  
      mkdir.mkdirs(dir, err => {
        if (err) return callback(err)
        jsonFile.writeJson(file, data, options, callback)
      })
    })
  }
  
  module.exports = outputJson
  
  
  /***/ }),
  
  /***/ 143:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  /*
   * "A request-path path-matches a given cookie-path if at least one of the
   * following conditions holds:"
   */
  function pathMatch (reqPath, cookiePath) {
    // "o  The cookie-path and the request-path are identical."
    if (cookiePath === reqPath) {
      return true;
    }
  
    var idx = reqPath.indexOf(cookiePath);
    if (idx === 0) {
      // "o  The cookie-path is a prefix of the request-path, and the last
      // character of the cookie-path is %x2F ("/")."
      if (cookiePath.substr(-1) === "/") {
        return true;
      }
  
      // " o  The cookie-path is a prefix of the request-path, and the first
      // character of the request-path that is not included in the cookie- path
      // is a %x2F ("/") character."
      if (reqPath.substr(cookiePath.length, 1) === "/") {
        return true;
      }
    }
  
    return false;
  }
  
  exports.pathMatch = pathMatch;
  
  
  /***/ }),
  
  /***/ 148:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  // a passthrough stream.
  // basically just the most minimal sort of Transform stream.
  // Every written chunk gets output as-is.
  
  
  module.exports = PassThrough;
  
  var Transform = __webpack_require__(598);
  
  __webpack_require__(207)(PassThrough, Transform);
  
  function PassThrough(options) {
    if (!(this instanceof PassThrough)) return new PassThrough(options);
    Transform.call(this, options);
  }
  
  PassThrough.prototype._transform = function (chunk, encoding, cb) {
    cb(null, chunk);
  };
  
  /***/ }),
  
  /***/ 150:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  // TODO: enable this once graceful-fs supports bigint option.
  // const fs = require('graceful-fs')
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  
  const NODE_VERSION_MAJOR_WITH_BIGINT = 10
  const NODE_VERSION_MINOR_WITH_BIGINT = 5
  const NODE_VERSION_PATCH_WITH_BIGINT = 0
  const nodeVersion = process.versions.node.split('.')
  const nodeVersionMajor = Number.parseInt(nodeVersion[0], 10)
  const nodeVersionMinor = Number.parseInt(nodeVersion[1], 10)
  const nodeVersionPatch = Number.parseInt(nodeVersion[2], 10)
  
  function nodeSupportsBigInt () {
    if (nodeVersionMajor > NODE_VERSION_MAJOR_WITH_BIGINT) {
      return true
    } else if (nodeVersionMajor === NODE_VERSION_MAJOR_WITH_BIGINT) {
      if (nodeVersionMinor > NODE_VERSION_MINOR_WITH_BIGINT) {
        return true
      } else if (nodeVersionMinor === NODE_VERSION_MINOR_WITH_BIGINT) {
        if (nodeVersionPatch >= NODE_VERSION_PATCH_WITH_BIGINT) {
          return true
        }
      }
    }
    return false
  }
  
  function getStats (src, dest, cb) {
    if (nodeSupportsBigInt()) {
      fs.stat(src, { bigint: true }, (err, srcStat) => {
        if (err) return cb(err)
        fs.stat(dest, { bigint: true }, (err, destStat) => {
          if (err) {
            if (err.code === 'ENOENT') return cb(null, { srcStat, destStat: null })
            return cb(err)
          }
          return cb(null, { srcStat, destStat })
        })
      })
    } else {
      fs.stat(src, (err, srcStat) => {
        if (err) return cb(err)
        fs.stat(dest, (err, destStat) => {
          if (err) {
            if (err.code === 'ENOENT') return cb(null, { srcStat, destStat: null })
            return cb(err)
          }
          return cb(null, { srcStat, destStat })
        })
      })
    }
  }
  
  function getStatsSync (src, dest) {
    let srcStat, destStat
    if (nodeSupportsBigInt()) {
      srcStat = fs.statSync(src, { bigint: true })
    } else {
      srcStat = fs.statSync(src)
    }
    try {
      if (nodeSupportsBigInt()) {
        destStat = fs.statSync(dest, { bigint: true })
      } else {
        destStat = fs.statSync(dest)
      }
    } catch (err) {
      if (err.code === 'ENOENT') return { srcStat, destStat: null }
      throw err
    }
    return { srcStat, destStat }
  }
  
  function checkPaths (src, dest, funcName, cb) {
    getStats(src, dest, (err, stats) => {
      if (err) return cb(err)
      const { srcStat, destStat } = stats
      if (destStat && destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
        return cb(new Error('Source and destination must not be the same.'))
      }
      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
        return cb(new Error(errMsg(src, dest, funcName)))
      }
      return cb(null, { srcStat, destStat })
    })
  }
  
  function checkPathsSync (src, dest, funcName) {
    const { srcStat, destStat } = getStatsSync(src, dest)
    if (destStat && destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
      throw new Error('Source and destination must not be the same.')
    }
    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
      throw new Error(errMsg(src, dest, funcName))
    }
    return { srcStat, destStat }
  }
  
  // recursively check if dest parent is a subdirectory of src.
  // It works for all file types including symlinks since it
  // checks the src and dest inodes. It starts from the deepest
  // parent and stops once it reaches the src parent or the root path.
  function checkParentPaths (src, srcStat, dest, funcName, cb) {
    const srcParent = path.resolve(path.dirname(src))
    const destParent = path.resolve(path.dirname(dest))
    if (destParent === srcParent || destParent === path.parse(destParent).root) return cb()
    if (nodeSupportsBigInt()) {
      fs.stat(destParent, { bigint: true }, (err, destStat) => {
        if (err) {
          if (err.code === 'ENOENT') return cb()
          return cb(err)
        }
        if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
          return cb(new Error(errMsg(src, dest, funcName)))
        }
        return checkParentPaths(src, srcStat, destParent, funcName, cb)
      })
    } else {
      fs.stat(destParent, (err, destStat) => {
        if (err) {
          if (err.code === 'ENOENT') return cb()
          return cb(err)
        }
        if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
          return cb(new Error(errMsg(src, dest, funcName)))
        }
        return checkParentPaths(src, srcStat, destParent, funcName, cb)
      })
    }
  }
  
  function checkParentPathsSync (src, srcStat, dest, funcName) {
    const srcParent = path.resolve(path.dirname(src))
    const destParent = path.resolve(path.dirname(dest))
    if (destParent === srcParent || destParent === path.parse(destParent).root) return
    let destStat
    try {
      if (nodeSupportsBigInt()) {
        destStat = fs.statSync(destParent, { bigint: true })
      } else {
        destStat = fs.statSync(destParent)
      }
    } catch (err) {
      if (err.code === 'ENOENT') return
      throw err
    }
    if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) {
      throw new Error(errMsg(src, dest, funcName))
    }
    return checkParentPathsSync(src, srcStat, destParent, funcName)
  }
  
  // return true if dest is a subdir of src, otherwise false.
  // It only checks the path strings.
  function isSrcSubdir (src, dest) {
    const srcArr = path.resolve(src).split(path.sep).filter(i => i)
    const destArr = path.resolve(dest).split(path.sep).filter(i => i)
    return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true)
  }
  
  function errMsg (src, dest, funcName) {
    return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
  }
  
  module.exports = {
    checkPaths,
    checkPathsSync,
    checkParentPaths,
    checkParentPathsSync,
    isSrcSubdir
  }
  
  
  /***/ }),
  
  /***/ 165:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  var ERR_INVALID_OPT_VALUE = __webpack_require__(854).codes.ERR_INVALID_OPT_VALUE;
  
  function highWaterMarkFrom(options, isDuplex, duplexKey) {
    return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
  }
  
  function getHighWaterMark(state, options, duplexKey, isDuplex) {
    var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
  
    if (hwm != null) {
      if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
        var name = isDuplex ? duplexKey : 'highWaterMark';
        throw new ERR_INVALID_OPT_VALUE(name, hwm);
      }
  
      return Math.floor(hwm);
    } // Default value
  
  
    return state.objectMode ? 16 : 16 * 1024;
  }
  
  module.exports = {
    getHighWaterMark: getHighWaterMark
  };
  
  /***/ }),
  
  /***/ 167:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  const os = __webpack_require__(431)
  const path = __webpack_require__(589)
  
  // HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
  function hasMillisResSync () {
    let tmpfile = path.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2))
    tmpfile = path.join(os.tmpdir(), tmpfile)
  
    // 550 millis past UNIX epoch
    const d = new Date(1435410243862)
    fs.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141')
    const fd = fs.openSync(tmpfile, 'r+')
    fs.futimesSync(fd, d, d)
    fs.closeSync(fd)
    return fs.statSync(tmpfile).mtime > 1435410243000
  }
  
  function hasMillisRes (callback) {
    let tmpfile = path.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2))
    tmpfile = path.join(os.tmpdir(), tmpfile)
  
    // 550 millis past UNIX epoch
    const d = new Date(1435410243862)
    fs.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
      if (err) return callback(err)
      fs.open(tmpfile, 'r+', (err, fd) => {
        if (err) return callback(err)
        fs.futimes(fd, d, d, err => {
          if (err) return callback(err)
          fs.close(fd, err => {
            if (err) return callback(err)
            fs.stat(tmpfile, (err, stats) => {
              if (err) return callback(err)
              callback(null, stats.mtime > 1435410243000)
            })
          })
        })
      })
    })
  }
  
  function timeRemoveMillis (timestamp) {
    if (typeof timestamp === 'number') {
      return Math.floor(timestamp / 1000) * 1000
    } else if (timestamp instanceof Date) {
      return new Date(Math.floor(timestamp.getTime() / 1000) * 1000)
    } else {
      throw new Error('fs-extra: timeRemoveMillis() unknown parameter type')
    }
  }
  
  function utimesMillis (path, atime, mtime, callback) {
    // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
    fs.open(path, 'r+', (err, fd) => {
      if (err) return callback(err)
      fs.futimes(fd, atime, mtime, futimesErr => {
        fs.close(fd, closeErr => {
          if (callback) callback(futimesErr || closeErr)
        })
      })
    })
  }
  
  function utimesMillisSync (path, atime, mtime) {
    const fd = fs.openSync(path, 'r+')
    fs.futimesSync(fd, atime, mtime)
    return fs.closeSync(fd)
  }
  
  module.exports = {
    hasMillisRes,
    hasMillisResSync,
    timeRemoveMillis,
    utimesMillis,
    utimesMillisSync
  }
  
  
  /***/ }),
  
  /***/ 174:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  function __export(m) {
      for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const create_deployment_1 = __importDefault(__webpack_require__(88));
  exports.createDeployment = create_deployment_1.default(1);
  exports.createLegacyDeployment = create_deployment_1.default(2);
  __export(__webpack_require__(610));
  
  
  /***/ }),
  
  /***/ 191:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const utils_1 = __webpack_require__(760);
  const forbiddenHeaders = [
      "accept-charset",
      "accept-encoding",
      "access-control-request-headers",
      "access-control-request-method",
      "connection",
      "content-length",
      "cookie",
      "cookie2",
      "date",
      "dnt",
      "expect",
      "host",
      "keep-alive",
      "origin",
      "referer",
      "te",
      "trailer",
      "transfer-encoding",
      "upgrade",
      "via",
  ];
  function isForbiddenHeader(name) {
      if (name.startsWith("proxy-") || name.startsWith("sec-"))
          // Safe headers
          return false;
      return forbiddenHeaders.includes(name);
  }
  function isForbiddenResponseHeader(name) {
      return ["set-cookie", "set-cookie2"].includes(name);
  }
  function isSimpleHeader(name, value) {
      const simpleHeaders = [
          "accept",
          "accept-language",
          "content-language",
          "dpr",
          "downlink",
          "save-data",
          "viewport-width",
          "width",
      ];
      if (simpleHeaders.includes(name))
          return true;
      if (name !== "content-type")
          return false;
      if (value == null)
          return false;
      const mimeType = value.replace(/;.*/, "").toLowerCase();
      return [
          "application/x-www-form-urlencoded",
          "multipart/form-data",
          "text/plain",
      ].includes(mimeType);
  }
  function filterName(name) {
      if (/[^A-Za-z0-9\-#$%&'*+.\^_`|~]/.test(name))
          throw new TypeError("Invalid character in header field name: " + name);
      return name.toLowerCase();
  }
  function _ensureGuard(guard, name, value) {
      if (guard === "immutable")
          throw new TypeError("Header guard error: Cannot change immutable header");
      if (!name)
          return;
      if (guard === "request" && isForbiddenHeader(name))
          throw new TypeError("Header guard error: " +
              "Cannot set forbidden header for requests" +
              ` (${name})`);
      if (guard === "request-no-cors" && !isSimpleHeader(name, value))
          throw new TypeError("Header guard error: " +
              "Cannot set non-simple header for no-cors requests" +
              ` (${name})`);
      if (guard === "response" && isForbiddenResponseHeader(name))
          throw new TypeError("Header guard error: " +
              "Cannot set forbidden response header for response" +
              ` (${name})`);
  }
  let _guard = null;
  class Headers {
      constructor(init) {
          this._guard = _guard || "none";
          _guard = null;
          this._data = new Map();
          const set = (name, values) => {
              if (values.length === 1)
                  this.set(name, values[0]);
              else
                  for (const value of values)
                      this.append(name, value);
          };
          if (!init)
              return;
          else if (init instanceof Headers) {
              for (const [name, values] of init._data.entries())
                  set(name, values);
          }
          else {
              for (const _name of Object.keys(init)) {
                  const name = filterName(_name);
                  const value = utils_1.arrayify(init[_name])
                      .map(val => `${val}`);
                  set(name, [...value]);
              }
          }
      }
      append(name, value) {
          const _name = filterName(name);
          _ensureGuard(this._guard, _name, value);
          if (!this._data.has(_name))
              this._data.set(_name, [value]);
          else
              this._data.get(_name).push(value);
      }
      delete(name) {
          const _name = filterName(name);
          _ensureGuard(this._guard);
          this._data.delete(_name);
      }
      *entries() {
          for (const [name, value] of this._data.entries())
              yield [name, value.join(",")];
      }
      get(name) {
          const _name = filterName(name);
          return this._data.has(_name)
              ? this._data.get(_name).join(",")
              : null;
      }
      has(name) {
          return this._data.has(filterName(name));
      }
      keys() {
          return this._data.keys();
      }
      set(name, value) {
          const _name = filterName(name);
          _ensureGuard(this._guard, _name, value);
          this._data.set(_name, [value]);
      }
      *values() {
          for (const value of this._data.values())
              yield value.join(",");
      }
  }
  exports.Headers = Headers;
  class GuardedHeaders extends Headers {
      constructor(guard, init) {
          super((_guard = guard, init));
          _guard = null;
      }
  }
  exports.GuardedHeaders = GuardedHeaders;
  function ensureHeaders(headers) {
      return headers instanceof Headers ? headers : new Headers(headers);
  }
  exports.ensureHeaders = ensureHeaders;
  //# sourceMappingURL=headers.js.map
  
  /***/ }),
  
  /***/ 193:
  /***/ (function(module) {
  
  module.exports = require("net");
  
  /***/ }),
  
  /***/ 200:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  // A bit simpler than readable streams.
  // Implement an async ._write(chunk, encoding, cb), and it'll handle all
  // the drain event emission and buffering.
  
  
  module.exports = Writable;
  /* <replacement> */
  
  function WriteReq(chunk, encoding, cb) {
    this.chunk = chunk;
    this.encoding = encoding;
    this.callback = cb;
    this.next = null;
  } // It seems a linked list but it is not
  // there will be only 2 of these for each stream
  
  
  function CorkedRequest(state) {
    var _this = this;
  
    this.next = null;
    this.entry = null;
  
    this.finish = function () {
      onCorkedFinish(_this, state);
    };
  }
  /* </replacement> */
  
  /*<replacement>*/
  
  
  var Duplex;
  /*</replacement>*/
  
  Writable.WritableState = WritableState;
  /*<replacement>*/
  
  var internalUtil = {
    deprecate: __webpack_require__(507)
  };
  /*</replacement>*/
  
  /*<replacement>*/
  
  var Stream = __webpack_require__(233);
  /*</replacement>*/
  
  
  var Buffer = __webpack_require__(942).Buffer;
  
  var OurUint8Array = global.Uint8Array || function () {};
  
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  
  var destroyImpl = __webpack_require__(955);
  
  var _require = __webpack_require__(165),
      getHighWaterMark = _require.getHighWaterMark;
  
  var _require$codes = __webpack_require__(854).codes,
      ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
      ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
      ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
      ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
      ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
      ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
      ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
      ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
  
  __webpack_require__(207)(Writable, Stream);
  
  function nop() {}
  
  function WritableState(options, stream, isDuplex) {
    Duplex = Duplex || __webpack_require__(404);
    options = options || {}; // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream,
    // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
  
    if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
    // contains buffers or objects.
  
    this.objectMode = !!options.objectMode;
    if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
    // Note: 0 is a valid value, means that we always return false if
    // the entire buffer is not flushed immediately on write()
  
    this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
  
    this.finalCalled = false; // drain event flag.
  
    this.needDrain = false; // at the start of calling end()
  
    this.ending = false; // when end() has been called, and returned
  
    this.ended = false; // when 'finish' is emitted
  
    this.finished = false; // has it been destroyed
  
    this.destroyed = false; // should we decode strings into buffers before passing to _write?
    // this is here so that some node-core streams can optimize string
    // handling at a lower level.
  
    var noDecode = options.decodeStrings === false;
    this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
  
    this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
    // of how much we're waiting to get pushed to some underlying
    // socket or file.
  
    this.length = 0; // a flag to see when we're in the middle of a write.
  
    this.writing = false; // when true all writes will be buffered until .uncork() call
  
    this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
    // or on a later tick.  We set this to true at first, because any
    // actions that shouldn't happen until "later" should generally also
    // not happen before the first write call.
  
    this.sync = true; // a flag to know if we're processing previously buffered items, which
    // may call the _write() callback in the same tick, so that we don't
    // end up in an overlapped onwrite situation.
  
    this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
  
    this.onwrite = function (er) {
      onwrite(stream, er);
    }; // the callback that the user supplies to write(chunk,encoding,cb)
  
  
    this.writecb = null; // the amount that is being written when _write is called.
  
    this.writelen = 0;
    this.bufferedRequest = null;
    this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
    // this must be 0 before 'finish' can be emitted
  
    this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
    // This is relevant for synchronous Transform streams
  
    this.prefinished = false; // True if the error was already emitted and should not be thrown again
  
    this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
  
    this.emitClose = options.emitClose !== false; // count buffered requests
  
    this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
    // one allocated and free to use, and we maintain at most two
  
    this.corkedRequestsFree = new CorkedRequest(this);
  }
  
  WritableState.prototype.getBuffer = function getBuffer() {
    var current = this.bufferedRequest;
    var out = [];
  
    while (current) {
      out.push(current);
      current = current.next;
    }
  
    return out;
  };
  
  (function () {
    try {
      Object.defineProperty(WritableState.prototype, 'buffer', {
        get: internalUtil.deprecate(function writableStateBufferGetter() {
          return this.getBuffer();
        }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
      });
    } catch (_) {}
  })(); // Test _writableState for inheritance to account for Duplex streams,
  // whose prototype chain only points to Readable.
  
  
  var realHasInstance;
  
  if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
    realHasInstance = Function.prototype[Symbol.hasInstance];
    Object.defineProperty(Writable, Symbol.hasInstance, {
      value: function value(object) {
        if (realHasInstance.call(this, object)) return true;
        if (this !== Writable) return false;
        return object && object._writableState instanceof WritableState;
      }
    });
  } else {
    realHasInstance = function realHasInstance(object) {
      return object instanceof this;
    };
  }
  
  function Writable(options) {
    Duplex = Duplex || __webpack_require__(404); // Writable ctor is applied to Duplexes, too.
    // `realHasInstance` is necessary because using plain `instanceof`
    // would return false, as no `_writableState` property is attached.
    // Trying to use the custom `instanceof` for Writable here will also break the
    // Node.js LazyTransform implementation, which has a non-trivial getter for
    // `_writableState` that would lead to infinite recursion.
    // Checking for a Stream.Duplex instance is faster here instead of inside
    // the WritableState constructor, at least with V8 6.5
  
    var isDuplex = this instanceof Duplex;
    if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
    this._writableState = new WritableState(options, this, isDuplex); // legacy.
  
    this.writable = true;
  
    if (options) {
      if (typeof options.write === 'function') this._write = options.write;
      if (typeof options.writev === 'function') this._writev = options.writev;
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
      if (typeof options.final === 'function') this._final = options.final;
    }
  
    Stream.call(this);
  } // Otherwise people can pipe Writable streams, which is just wrong.
  
  
  Writable.prototype.pipe = function () {
    this.emit('error', new ERR_STREAM_CANNOT_PIPE());
  };
  
  function writeAfterEnd(stream, cb) {
    var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
  
    stream.emit('error', er);
    process.nextTick(cb, er);
  } // Checks that a user-supplied chunk is valid, especially for the particular
  // mode the stream is in. Currently this means that `null` is never accepted
  // and undefined/non-string values are only allowed in object mode.
  
  
  function validChunk(stream, state, chunk, cb) {
    var er;
  
    if (chunk === null) {
      er = new ERR_STREAM_NULL_VALUES();
    } else if (typeof chunk !== 'string' && !state.objectMode) {
      er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
    }
  
    if (er) {
      stream.emit('error', er);
      process.nextTick(cb, er);
      return false;
    }
  
    return true;
  }
  
  Writable.prototype.write = function (chunk, encoding, cb) {
    var state = this._writableState;
    var ret = false;
  
    var isBuf = !state.objectMode && _isUint8Array(chunk);
  
    if (isBuf && !Buffer.isBuffer(chunk)) {
      chunk = _uint8ArrayToBuffer(chunk);
    }
  
    if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
    if (typeof cb !== 'function') cb = nop;
    if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
      state.pendingcb++;
      ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
    }
    return ret;
  };
  
  Writable.prototype.cork = function () {
    this._writableState.corked++;
  };
  
  Writable.prototype.uncork = function () {
    var state = this._writableState;
  
    if (state.corked) {
      state.corked--;
      if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
    }
  };
  
  Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
    // node::ParseEncoding() requires lower case.
    if (typeof encoding === 'string') encoding = encoding.toLowerCase();
    if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
    this._writableState.defaultEncoding = encoding;
    return this;
  };
  
  Object.defineProperty(Writable.prototype, 'writableBuffer', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState && this._writableState.getBuffer();
    }
  });
  
  function decodeChunk(state, chunk, encoding) {
    if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
      chunk = Buffer.from(chunk, encoding);
    }
  
    return chunk;
  }
  
  Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState.highWaterMark;
    }
  }); // if we're already writing something, then just put this
  // in the queue, and wait our turn.  Otherwise, call _write
  // If we return false, then we need a drain event, so set that flag.
  
  function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
    if (!isBuf) {
      var newChunk = decodeChunk(state, chunk, encoding);
  
      if (chunk !== newChunk) {
        isBuf = true;
        encoding = 'buffer';
        chunk = newChunk;
      }
    }
  
    var len = state.objectMode ? 1 : chunk.length;
    state.length += len;
    var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
  
    if (!ret) state.needDrain = true;
  
    if (state.writing || state.corked) {
      var last = state.lastBufferedRequest;
      state.lastBufferedRequest = {
        chunk: chunk,
        encoding: encoding,
        isBuf: isBuf,
        callback: cb,
        next: null
      };
  
      if (last) {
        last.next = state.lastBufferedRequest;
      } else {
        state.bufferedRequest = state.lastBufferedRequest;
      }
  
      state.bufferedRequestCount += 1;
    } else {
      doWrite(stream, state, false, len, chunk, encoding, cb);
    }
  
    return ret;
  }
  
  function doWrite(stream, state, writev, len, chunk, encoding, cb) {
    state.writelen = len;
    state.writecb = cb;
    state.writing = true;
    state.sync = true;
    if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
    state.sync = false;
  }
  
  function onwriteError(stream, state, sync, er, cb) {
    --state.pendingcb;
  
    if (sync) {
      // defer the callback if we are being called synchronously
      // to avoid piling up things on the stack
      process.nextTick(cb, er); // this can emit finish, and it will always happen
      // after error
  
      process.nextTick(finishMaybe, stream, state);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er);
    } else {
      // the caller expect this to happen before if
      // it is async
      cb(er);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er); // this can emit finish, but finish must
      // always follow error
  
      finishMaybe(stream, state);
    }
  }
  
  function onwriteStateUpdate(state) {
    state.writing = false;
    state.writecb = null;
    state.length -= state.writelen;
    state.writelen = 0;
  }
  
  function onwrite(stream, er) {
    var state = stream._writableState;
    var sync = state.sync;
    var cb = state.writecb;
    if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
    onwriteStateUpdate(state);
    if (er) onwriteError(stream, state, sync, er, cb);else {
      // Check if we're actually ready to finish, but don't emit yet
      var finished = needFinish(state) || stream.destroyed;
  
      if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
        clearBuffer(stream, state);
      }
  
      if (sync) {
        process.nextTick(afterWrite, stream, state, finished, cb);
      } else {
        afterWrite(stream, state, finished, cb);
      }
    }
  }
  
  function afterWrite(stream, state, finished, cb) {
    if (!finished) onwriteDrain(stream, state);
    state.pendingcb--;
    cb();
    finishMaybe(stream, state);
  } // Must force callback to be called on nextTick, so that we don't
  // emit 'drain' before the write() consumer gets the 'false' return
  // value, and has a chance to attach a 'drain' listener.
  
  
  function onwriteDrain(stream, state) {
    if (state.length === 0 && state.needDrain) {
      state.needDrain = false;
      stream.emit('drain');
    }
  } // if there's something in the buffer waiting, then process it
  
  
  function clearBuffer(stream, state) {
    state.bufferProcessing = true;
    var entry = state.bufferedRequest;
  
    if (stream._writev && entry && entry.next) {
      // Fast case, write everything using _writev()
      var l = state.bufferedRequestCount;
      var buffer = new Array(l);
      var holder = state.corkedRequestsFree;
      holder.entry = entry;
      var count = 0;
      var allBuffers = true;
  
      while (entry) {
        buffer[count] = entry;
        if (!entry.isBuf) allBuffers = false;
        entry = entry.next;
        count += 1;
      }
  
      buffer.allBuffers = allBuffers;
      doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
      // as the hot path ends with doWrite
  
      state.pendingcb++;
      state.lastBufferedRequest = null;
  
      if (holder.next) {
        state.corkedRequestsFree = holder.next;
        holder.next = null;
      } else {
        state.corkedRequestsFree = new CorkedRequest(state);
      }
  
      state.bufferedRequestCount = 0;
    } else {
      // Slow case, write chunks one-by-one
      while (entry) {
        var chunk = entry.chunk;
        var encoding = entry.encoding;
        var cb = entry.callback;
        var len = state.objectMode ? 1 : chunk.length;
        doWrite(stream, state, false, len, chunk, encoding, cb);
        entry = entry.next;
        state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
        // it means that we need to wait until it does.
        // also, that means that the chunk and cb are currently
        // being processed, so move the buffer counter past them.
  
        if (state.writing) {
          break;
        }
      }
  
      if (entry === null) state.lastBufferedRequest = null;
    }
  
    state.bufferedRequest = entry;
    state.bufferProcessing = false;
  }
  
  Writable.prototype._write = function (chunk, encoding, cb) {
    cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
  };
  
  Writable.prototype._writev = null;
  
  Writable.prototype.end = function (chunk, encoding, cb) {
    var state = this._writableState;
  
    if (typeof chunk === 'function') {
      cb = chunk;
      chunk = null;
      encoding = null;
    } else if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
  
    if (state.corked) {
      state.corked = 1;
      this.uncork();
    } // ignore unnecessary end() calls.
  
  
    if (!state.ending) endWritable(this, state, cb);
    return this;
  };
  
  Object.defineProperty(Writable.prototype, 'writableLength', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState.length;
    }
  });
  
  function needFinish(state) {
    return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
  }
  
  function callFinal(stream, state) {
    stream._final(function (err) {
      state.pendingcb--;
  
      if (err) {
        stream.emit('error', err);
      }
  
      state.prefinished = true;
      stream.emit('prefinish');
      finishMaybe(stream, state);
    });
  }
  
  function prefinish(stream, state) {
    if (!state.prefinished && !state.finalCalled) {
      if (typeof stream._final === 'function' && !state.destroyed) {
        state.pendingcb++;
        state.finalCalled = true;
        process.nextTick(callFinal, stream, state);
      } else {
        state.prefinished = true;
        stream.emit('prefinish');
      }
    }
  }
  
  function finishMaybe(stream, state) {
    var need = needFinish(state);
  
    if (need) {
      prefinish(stream, state);
  
      if (state.pendingcb === 0) {
        state.finished = true;
        stream.emit('finish');
      }
    }
  
    return need;
  }
  
  function endWritable(stream, state, cb) {
    state.ending = true;
    finishMaybe(stream, state);
  
    if (cb) {
      if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
    }
  
    state.ended = true;
    stream.writable = false;
  }
  
  function onCorkedFinish(corkReq, state, err) {
    var entry = corkReq.entry;
    corkReq.entry = null;
  
    while (entry) {
      var cb = entry.callback;
      state.pendingcb--;
      cb(err);
      entry = entry.next;
    } // reuse the free corkReq.
  
  
    state.corkedRequestsFree.next = corkReq;
  }
  
  Object.defineProperty(Writable.prototype, 'destroyed', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      if (this._writableState === undefined) {
        return false;
      }
  
      return this._writableState.destroyed;
    },
    set: function set(value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._writableState) {
        return;
      } // backward compatibility, the user is explicitly
      // managing destroyed
  
  
      this._writableState.destroyed = value;
    }
  });
  Writable.prototype.destroy = destroyImpl.destroy;
  Writable.prototype._undestroy = destroyImpl.undestroy;
  
  Writable.prototype._destroy = function (err, cb) {
    cb(err);
  };
  
  /***/ }),
  
  /***/ 207:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  try {
    var util = __webpack_require__(64);
    if (typeof util.inherits !== 'function') throw '';
    module.exports = util.inherits;
  } catch (e) {
    module.exports = __webpack_require__(714);
  }
  
  
  /***/ }),
  
  /***/ 225:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  module.exports = {
    move: u(__webpack_require__(849))
  }
  
  
  /***/ }),
  
  /***/ 230:
  /***/ (function(module) {
  
  module.exports = require("https");
  
  /***/ }),
  
  /***/ 231:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  var pubsuffix = __webpack_require__(501);
  
  // Gives the permutation of all possible domainMatch()es of a given domain. The
  // array is in shortest-to-longest order.  Handy for indexing.
  function permuteDomain (domain) {
    var pubSuf = pubsuffix.getPublicSuffix(domain);
    if (!pubSuf) {
      return null;
    }
    if (pubSuf == domain) {
      return [domain];
    }
  
    var prefix = domain.slice(0, -(pubSuf.length + 1)); // ".example.com"
    var parts = prefix.split('.').reverse();
    var cur = pubSuf;
    var permutations = [cur];
    while (parts.length) {
      cur = parts.shift() + '.' + cur;
      permutations.push(cur);
    }
    return permutations;
  }
  
  exports.permuteDomain = permuteDomain;
  
  
  /***/ }),
  
  /***/ 233:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = __webpack_require__(688);
  
  
  /***/ }),
  
  /***/ 250:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  var _require = __webpack_require__(942),
      Buffer = _require.Buffer;
  
  var _require2 = __webpack_require__(64),
      inspect = _require2.inspect;
  
  var custom = inspect && inspect.custom || 'inspect';
  
  function copyBuffer(src, target, offset) {
    Buffer.prototype.copy.call(src, target, offset);
  }
  
  module.exports =
  /*#__PURE__*/
  function () {
    function BufferList() {
      this.head = null;
      this.tail = null;
      this.length = 0;
    }
  
    var _proto = BufferList.prototype;
  
    _proto.push = function push(v) {
      var entry = {
        data: v,
        next: null
      };
      if (this.length > 0) this.tail.next = entry;else this.head = entry;
      this.tail = entry;
      ++this.length;
    };
  
    _proto.unshift = function unshift(v) {
      var entry = {
        data: v,
        next: this.head
      };
      if (this.length === 0) this.tail = entry;
      this.head = entry;
      ++this.length;
    };
  
    _proto.shift = function shift() {
      if (this.length === 0) return;
      var ret = this.head.data;
      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
      --this.length;
      return ret;
    };
  
    _proto.clear = function clear() {
      this.head = this.tail = null;
      this.length = 0;
    };
  
    _proto.join = function join(s) {
      if (this.length === 0) return '';
      var p = this.head;
      var ret = '' + p.data;
  
      while (p = p.next) {
        ret += s + p.data;
      }
  
      return ret;
    };
  
    _proto.concat = function concat(n) {
      if (this.length === 0) return Buffer.alloc(0);
      var ret = Buffer.allocUnsafe(n >>> 0);
      var p = this.head;
      var i = 0;
  
      while (p) {
        copyBuffer(p.data, ret, i);
        i += p.data.length;
        p = p.next;
      }
  
      return ret;
    } // Consumes a specified amount of bytes or characters from the buffered data.
    ;
  
    _proto.consume = function consume(n, hasStrings) {
      var ret;
  
      if (n < this.head.data.length) {
        // `slice` is the same for buffers and strings.
        ret = this.head.data.slice(0, n);
        this.head.data = this.head.data.slice(n);
      } else if (n === this.head.data.length) {
        // First chunk is a perfect match.
        ret = this.shift();
      } else {
        // Result spans more than one buffer.
        ret = hasStrings ? this._getString(n) : this._getBuffer(n);
      }
  
      return ret;
    };
  
    _proto.first = function first() {
      return this.head.data;
    } // Consumes a specified amount of characters from the buffered data.
    ;
  
    _proto._getString = function _getString(n) {
      var p = this.head;
      var c = 1;
      var ret = p.data;
      n -= ret.length;
  
      while (p = p.next) {
        var str = p.data;
        var nb = n > str.length ? str.length : n;
        if (nb === str.length) ret += str;else ret += str.slice(0, n);
        n -= nb;
  
        if (n === 0) {
          if (nb === str.length) {
            ++c;
            if (p.next) this.head = p.next;else this.head = this.tail = null;
          } else {
            this.head = p;
            p.data = str.slice(nb);
          }
  
          break;
        }
  
        ++c;
      }
  
      this.length -= c;
      return ret;
    } // Consumes a specified amount of bytes from the buffered data.
    ;
  
    _proto._getBuffer = function _getBuffer(n) {
      var ret = Buffer.allocUnsafe(n);
      var p = this.head;
      var c = 1;
      p.data.copy(ret);
      n -= p.data.length;
  
      while (p = p.next) {
        var buf = p.data;
        var nb = n > buf.length ? buf.length : n;
        buf.copy(ret, ret.length - n, 0, nb);
        n -= nb;
  
        if (n === 0) {
          if (nb === buf.length) {
            ++c;
            if (p.next) this.head = p.next;else this.head = this.tail = null;
          } else {
            this.head = p;
            p.data = buf.slice(nb);
          }
  
          break;
        }
  
        ++c;
      }
  
      this.length -= c;
      return ret;
    } // Make sure the linked list only shows the minimal necessary information.
    ;
  
    _proto[custom] = function (_, options) {
      return inspect(this, _objectSpread({}, options, {
        // Only inspect one level.
        depth: 0,
        // It should not recurse.
        customInspect: false
      }));
    };
  
    return BufferList;
  }();
  
  /***/ }),
  
  /***/ 253:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var fs = __webpack_require__(66);
  var p = __webpack_require__(589);
  var minimatch = __webpack_require__(620);
  
  function patternMatcher(pattern) {
    return function(path, stats) {
      var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path);
    };
  }
  
  function toMatcherFunction(ignoreEntry) {
    if (typeof ignoreEntry == "function") {
      return ignoreEntry;
    } else {
      return patternMatcher(ignoreEntry);
    }
  }
  
  function readdir(path, ignores, callback) {
    if (typeof ignores == "function") {
      callback = ignores;
      ignores = [];
    }
  
    if (!callback) {
      return new Promise(function(resolve, reject) {
        readdir(path, ignores || [], function(err, data) {
          if (err) {
            reject(err);
          } else {
            resolve(data);
          }
        });
      });
    }
  
    ignores = ignores.map(toMatcherFunction);
  
    var list = [];
  
    fs.readdir(path, function(err, files) {
      if (err) {
        return callback(err);
      }
  
      var pending = files.length;
      if (!pending) {
        // we are done, woop woop
        return callback(null, list);
      }
  
      files.forEach(function(file) {
        var filePath = p.join(path, file);
        fs.stat(filePath, function(_err, stats) {
          if (_err) {
            return callback(_err);
          }
  
          if (
            ignores.some(function(matcher) {
              return matcher(filePath, stats);
            })
          ) {
            pending -= 1;
            if (!pending) {
              return callback(null, list);
            }
            return null;
          }
  
          if (stats.isDirectory()) {
            readdir(filePath, ignores, function(__err, res) {
              if (__err) {
                return callback(__err);
              }
  
              list = list.concat(res);
              pending -= 1;
              if (!pending) {
                return callback(null, list);
              }
            });
          } else {
            list.push(filePath);
            pending -= 1;
            if (!pending) {
              return callback(null, list);
            }
          }
        });
      });
    });
  }
  
  module.exports = readdir;
  
  
  /***/ }),
  
  /***/ 261:
  /***/ (function(module) {
  
  // generated by genversion
  module.exports = '3.0.1'
  
  
  /***/ }),
  
  /***/ 267:
  /***/ (function(module) {
  
  module.exports = require("zlib");
  
  /***/ }),
  
  /***/ 272:
  /***/ (function(module) {
  
  module.exports = require("querystring");
  
  /***/ }),
  
  /***/ 273:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  // TODO: enable this once graceful-fs supports bigint option.
  // const fs = require('graceful-fs')
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  const mkdirp = __webpack_require__(562).mkdirs
  const pathExists = __webpack_require__(734).pathExists
  const utimes = __webpack_require__(167).utimesMillis
  const stat = __webpack_require__(150)
  
  function copy (src, dest, opts, cb) {
    if (typeof opts === 'function' && !cb) {
      cb = opts
      opts = {}
    } else if (typeof opts === 'function') {
      opts = {filter: opts}
    }
  
    cb = cb || function () {}
    opts = opts || {}
  
    opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
    opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
  
    // Warn about using preserveTimestamps on 32-bit node
    if (opts.preserveTimestamps && process.arch === 'ia32') {
      console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
      see https://github.com/jprichardson/node-fs-extra/issues/269`)
    }
  
    stat.checkPaths(src, dest, 'copy', (err, stats) => {
      if (err) return cb(err)
      const { srcStat, destStat } = stats
      stat.checkParentPaths(src, srcStat, dest, 'copy', err => {
        if (err) return cb(err)
        if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb)
        return checkParentDir(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function checkParentDir (destStat, src, dest, opts, cb) {
    const destParent = path.dirname(dest)
    pathExists(destParent, (err, dirExists) => {
      if (err) return cb(err)
      if (dirExists) return startCopy(destStat, src, dest, opts, cb)
      mkdirp(destParent, err => {
        if (err) return cb(err)
        return startCopy(destStat, src, dest, opts, cb)
      })
    })
  }
  
  function handleFilter (onInclude, destStat, src, dest, opts, cb) {
    Promise.resolve(opts.filter(src, dest)).then(include => {
      if (include) return onInclude(destStat, src, dest, opts, cb)
      return cb()
    }, error => cb(error))
  }
  
  function startCopy (destStat, src, dest, opts, cb) {
    if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb)
    return getStats(destStat, src, dest, opts, cb)
  }
  
  function getStats (destStat, src, dest, opts, cb) {
    const stat = opts.dereference ? fs.stat : fs.lstat
    stat(src, (err, srcStat) => {
      if (err) return cb(err)
  
      if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isFile() ||
               srcStat.isCharacterDevice() ||
               srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb)
      else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb)
    })
  }
  
  function onFile (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return copyFile(srcStat, src, dest, opts, cb)
    return mayCopyFile(srcStat, src, dest, opts, cb)
  }
  
  function mayCopyFile (srcStat, src, dest, opts, cb) {
    if (opts.overwrite) {
      fs.unlink(dest, err => {
        if (err) return cb(err)
        return copyFile(srcStat, src, dest, opts, cb)
      })
    } else if (opts.errorOnExist) {
      return cb(new Error(`'${dest}' already exists`))
    } else return cb()
  }
  
  function copyFile (srcStat, src, dest, opts, cb) {
    if (typeof fs.copyFile === 'function') {
      return fs.copyFile(src, dest, err => {
        if (err) return cb(err)
        return setDestModeAndTimestamps(srcStat, dest, opts, cb)
      })
    }
    return copyFileFallback(srcStat, src, dest, opts, cb)
  }
  
  function copyFileFallback (srcStat, src, dest, opts, cb) {
    const rs = fs.createReadStream(src)
    rs.on('error', err => cb(err)).once('open', () => {
      const ws = fs.createWriteStream(dest, { mode: srcStat.mode })
      ws.on('error', err => cb(err))
        .on('open', () => rs.pipe(ws))
        .once('close', () => setDestModeAndTimestamps(srcStat, dest, opts, cb))
    })
  }
  
  function setDestModeAndTimestamps (srcStat, dest, opts, cb) {
    fs.chmod(dest, srcStat.mode, err => {
      if (err) return cb(err)
      if (opts.preserveTimestamps) {
        return utimes(dest, srcStat.atime, srcStat.mtime, cb)
      }
      return cb()
    })
  }
  
  function onDir (srcStat, destStat, src, dest, opts, cb) {
    if (!destStat) return mkDirAndCopy(srcStat, src, dest, opts, cb)
    if (destStat && !destStat.isDirectory()) {
      return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`))
    }
    return copyDir(src, dest, opts, cb)
  }
  
  function mkDirAndCopy (srcStat, src, dest, opts, cb) {
    fs.mkdir(dest, err => {
      if (err) return cb(err)
      copyDir(src, dest, opts, err => {
        if (err) return cb(err)
        return fs.chmod(dest, srcStat.mode, cb)
      })
    })
  }
  
  function copyDir (src, dest, opts, cb) {
    fs.readdir(src, (err, items) => {
      if (err) return cb(err)
      return copyDirItems(items, src, dest, opts, cb)
    })
  }
  
  function copyDirItems (items, src, dest, opts, cb) {
    const item = items.pop()
    if (!item) return cb()
    return copyDirItem(items, item, src, dest, opts, cb)
  }
  
  function copyDirItem (items, item, src, dest, opts, cb) {
    const srcItem = path.join(src, item)
    const destItem = path.join(dest, item)
    stat.checkPaths(srcItem, destItem, 'copy', (err, stats) => {
      if (err) return cb(err)
      const { destStat } = stats
      startCopy(destStat, srcItem, destItem, opts, err => {
        if (err) return cb(err)
        return copyDirItems(items, src, dest, opts, cb)
      })
    })
  }
  
  function onLink (destStat, src, dest, opts, cb) {
    fs.readlink(src, (err, resolvedSrc) => {
      if (err) return cb(err)
      if (opts.dereference) {
        resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
      }
  
      if (!destStat) {
        return fs.symlink(resolvedSrc, dest, cb)
      } else {
        fs.readlink(dest, (err, resolvedDest) => {
          if (err) {
            // dest exists and is a regular file or directory,
            // Windows may throw UNKNOWN error. If dest already exists,
            // fs throws error anyway, so no need to guard against it here.
            if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb)
            return cb(err)
          }
          if (opts.dereference) {
            resolvedDest = path.resolve(process.cwd(), resolvedDest)
          }
          if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
            return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`))
          }
  
          // do not copy if src is a subdir of dest since unlinking
          // dest in this case would result in removing src contents
          // and therefore a broken symlink would be created.
          if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
            return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`))
          }
          return copyLink(resolvedSrc, dest, cb)
        })
      }
    })
  }
  
  function copyLink (resolvedSrc, dest, cb) {
    fs.unlink(dest, err => {
      if (err) return cb(err)
      return fs.symlink(resolvedSrc, dest, cb)
    })
  }
  
  module.exports = copy
  
  
  /***/ }),
  
  /***/ 278:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _fs
  try {
    _fs = __webpack_require__(813)
  } catch (_) {
    _fs = __webpack_require__(66)
  }
  
  function readFile (file, options, callback) {
    if (callback == null) {
      callback = options
      options = {}
    }
  
    if (typeof options === 'string') {
      options = {encoding: options}
    }
  
    options = options || {}
    var fs = options.fs || _fs
  
    var shouldThrow = true
    if ('throws' in options) {
      shouldThrow = options.throws
    }
  
    fs.readFile(file, options, function (err, data) {
      if (err) return callback(err)
  
      data = stripBom(data)
  
      var obj
      try {
        obj = JSON.parse(data, options ? options.reviver : null)
      } catch (err2) {
        if (shouldThrow) {
          err2.message = file + ': ' + err2.message
          return callback(err2)
        } else {
          return callback(null, null)
        }
      }
  
      callback(null, obj)
    })
  }
  
  function readFileSync (file, options) {
    options = options || {}
    if (typeof options === 'string') {
      options = {encoding: options}
    }
  
    var fs = options.fs || _fs
  
    var shouldThrow = true
    if ('throws' in options) {
      shouldThrow = options.throws
    }
  
    try {
      var content = fs.readFileSync(file, options)
      content = stripBom(content)
      return JSON.parse(content, options.reviver)
    } catch (err) {
      if (shouldThrow) {
        err.message = file + ': ' + err.message
        throw err
      } else {
        return null
      }
    }
  }
  
  function stringify (obj, options) {
    var spaces
    var EOL = '\n'
    if (typeof options === 'object' && options !== null) {
      if (options.spaces) {
        spaces = options.spaces
      }
      if (options.EOL) {
        EOL = options.EOL
      }
    }
  
    var str = JSON.stringify(obj, options ? options.replacer : null, spaces)
  
    return str.replace(/\n/g, EOL) + EOL
  }
  
  function writeFile (file, obj, options, callback) {
    if (callback == null) {
      callback = options
      options = {}
    }
    options = options || {}
    var fs = options.fs || _fs
  
    var str = ''
    try {
      str = stringify(obj, options)
    } catch (err) {
      // Need to return whether a callback was passed or not
      if (callback) callback(err, null)
      return
    }
  
    fs.writeFile(file, str, options, callback)
  }
  
  function writeFileSync (file, obj, options) {
    options = options || {}
    var fs = options.fs || _fs
  
    var str = stringify(obj, options)
    // not sure if fs.writeFileSync returns anything, but just in case
    return fs.writeFileSync(file, str, options)
  }
  
  function stripBom (content) {
    // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
    if (Buffer.isBuffer(content)) content = content.toString('utf8')
    content = content.replace(/^\uFEFF/, '')
    return content
  }
  
  var jsonfile = {
    readFile: readFile,
    readFileSync: readFileSync,
    writeFile: writeFile,
    writeFileSync: writeFileSync
  }
  
  module.exports = jsonfile
  
  
  /***/ }),
  
  /***/ 282:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.version = "2.2.0";
  //# sourceMappingURL=version.js.map
  
  /***/ }),
  
  /***/ 298:
  /***/ (function(module) {
  
  module.exports = require("crypto");
  
  /***/ }),
  
  /***/ 301:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http2_1 = __webpack_require__(675);
  const url_1 = __webpack_require__(986);
  const already_1 = __webpack_require__(534);
  const body_1 = __webpack_require__(452);
  const core_1 = __webpack_require__(570);
  const headers_1 = __webpack_require__(191);
  const utils_1 = __webpack_require__(760);
  const { 
  // Required for a request
  HTTP2_HEADER_METHOD, HTTP2_HEADER_SCHEME, HTTP2_HEADER_PATH, 
  // Methods
  HTTP2_METHOD_GET, HTTP2_METHOD_HEAD, 
  // Requests
  HTTP2_HEADER_USER_AGENT, HTTP2_HEADER_ACCEPT, HTTP2_HEADER_COOKIE, HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_CONTENT_LENGTH, HTTP2_HEADER_ACCEPT_ENCODING, } = http2_1.constants;
  function ensureNotCircularRedirection(redirections) {
      const urls = [...redirections];
      const last = urls.pop();
      for (let i = 0; i < urls.length; ++i)
          if (urls[i] === last) {
              const err = new Error("Redirection loop detected");
              err.urls = urls.slice(i);
              throw err;
          }
  }
  const makeDefaultEncodings = (mul = 1) => utils_1.hasBuiltinBrotli()
      ? [
          { name: "br", score: 1.0 * mul },
          { name: "gzip", score: 0.8 * mul },
          { name: "deflate", score: 0.5 * mul },
      ]
      : [
          { name: "gzip", score: 1.0 * mul },
          { name: "deflate", score: 0.5 * mul },
      ];
  const defaultEncodings = makeDefaultEncodings();
  const fallbackEncodings = makeDefaultEncodings(0.8);
  const stringifyEncoding = (acceptEncoding) => `${acceptEncoding.name};q=${acceptEncoding.score}`;
  const stringifyEncodings = (accepts) => accepts
      .map(acceptEncoding => stringifyEncoding(acceptEncoding))
      .join(", ");
  function getEncodings(contentDecoders) {
      if (contentDecoders.length === 0)
          return stringifyEncodings(defaultEncodings);
      const makeScore = (index) => 1 - (index / (contentDecoders.length)) * 0.2;
      return stringifyEncodings([
          ...contentDecoders.map(({ name }, index) => ({ name, score: makeScore(index) })),
          ...fallbackEncodings,
      ]);
  }
  async function setupFetch(session, request, init = {}, extra) {
      const { redirected } = extra;
      ensureNotCircularRedirection(redirected);
      const { url, method, redirect, integrity } = request;
      const { signal, onTrailers } = init;
      const { origin, protocol, pathname, search, hash, } = new url_1.URL(url);
      const path = pathname + search + hash;
      const endStream = method === HTTP2_METHOD_GET || method === HTTP2_METHOD_HEAD;
      const headers = new headers_1.Headers(request.headers);
      const cookies = (await session.cookieJar.getCookies(url))
          .map(cookie => cookie.cookieString());
      const contentDecoders = session.contentDecoders();
      const acceptEncoding = getEncodings(contentDecoders);
      if (headers.has(HTTP2_HEADER_COOKIE))
          cookies.push(...utils_1.arrayify(headers.get(HTTP2_HEADER_COOKIE)));
      const headersToSend = {
          // Set required headers
          ...(session.protocol === "http1" ? {} : {
              [HTTP2_HEADER_METHOD]: method,
              [HTTP2_HEADER_SCHEME]: protocol.replace(/:.*/, ""),
              [HTTP2_HEADER_PATH]: path,
          }),
          // Set default headers
          [HTTP2_HEADER_ACCEPT]: session.accept(),
          [HTTP2_HEADER_USER_AGENT]: session.userAgent(),
          [HTTP2_HEADER_ACCEPT_ENCODING]: acceptEncoding,
      };
      if (cookies.length > 0)
          headersToSend[HTTP2_HEADER_COOKIE] = cookies.join("; ");
      for (const [key, val] of headers.entries()) {
          if (key === "host" && session.protocol === "http2")
              // Convert to :authority like curl does:
              // https://github.com/grantila/fetch-h2/issues/9
              headersToSend[":authority"] = val;
          else if (key !== HTTP2_HEADER_COOKIE)
              headersToSend[key] = val;
      }
      const inspector = new body_1.BodyInspector(request);
      if (!endStream &&
          inspector.length != null &&
          !request.headers.has(HTTP2_HEADER_CONTENT_LENGTH))
          headersToSend[HTTP2_HEADER_CONTENT_LENGTH] = "" + inspector.length;
      if (!endStream &&
          !request.headers.has("content-type") &&
          inspector.mime)
          headersToSend[HTTP2_HEADER_CONTENT_TYPE] = inspector.mime;
      function timeoutError() {
          return new core_1.TimeoutError(`${method} ${url} timed out after ${init.timeout} ms`);
      }
      const timeoutAt = extra.timeoutAt || (("timeout" in init && typeof init.timeout === "number")
          // Setting the timeoutAt here at first time allows async cookie
          // jar to not take part of timeout for at least the first request
          // (in a potential redirect chain)
          ? Date.now() + init.timeout
          : void 0);
      function setupTimeout() {
          if (!timeoutAt)
              return null;
          const now = Date.now();
          if (now >= timeoutAt)
              throw timeoutError();
          let timerId;
          return {
              clear: () => {
                  if (timerId)
                      clearTimeout(timerId);
              },
              promise: new Promise((_resolve, reject) => {
                  timerId = setTimeout(() => {
                      timerId = null;
                      reject(timeoutError());
                  }, timeoutAt - now);
              }),
          };
      }
      const timeoutInfo = setupTimeout();
      function abortError() {
          return new core_1.AbortError(`${method} ${url} aborted`);
      }
      if (signal && signal.aborted)
          throw abortError();
      let abortHandler;
      const signalPromise = signal
          ?
              new Promise((_resolve, reject) => {
                  signal.once("abort", abortHandler = () => {
                      reject(abortError());
                  });
              })
          : null;
      function cleanup() {
          if (timeoutInfo && timeoutInfo.clear)
              timeoutInfo.clear();
          if (signal && abortHandler)
              signal.removeListener("abort", abortHandler);
      }
      return {
          cleanup,
          contentDecoders,
          endStream,
          headersToSend,
          integrity,
          method,
          onTrailers,
          origin,
          redirect,
          redirected,
          request,
          signal,
          signalPromise,
          timeoutAt,
          timeoutInfo,
          url,
      };
  }
  exports.setupFetch = setupFetch;
  function handleSignalAndTimeout(signalPromise, timeoutInfo, cleanup, fetcher, onError) {
      return Promise.race([
          signalPromise,
          (timeoutInfo && timeoutInfo.promise),
          fetcher().catch(already_1.rethrow(onError)),
      ]
          .filter(promise => promise))
          .then(...already_1.Finally(cleanup));
  }
  exports.handleSignalAndTimeout = handleSignalAndTimeout;
  function make100Error() {
      return new Error("Request failed with 100 continue. " +
          "This can't happen unless a server failure");
  }
  exports.make100Error = make100Error;
  function makeAbortedError() {
      return new core_1.AbortError("Request aborted");
  }
  exports.makeAbortedError = makeAbortedError;
  function makeTimeoutError() {
      return new core_1.TimeoutError("Request timed out");
  }
  exports.makeTimeoutError = makeTimeoutError;
  function makeIllegalRedirectError() {
      return new Error("Server responded illegally with a " +
          "redirect code but missing 'location' header");
  }
  exports.makeIllegalRedirectError = makeIllegalRedirectError;
  function makeRedirectionError(location) {
      return new Error(`URL got redirected to ${location}`);
  }
  exports.makeRedirectionError = makeRedirectionError;
  function makeRedirectionMethodError(location, method) {
      return new Error(`URL got redirected to ${location}, which ` +
          `'fetch-h2' doesn't support for ${method}`);
  }
  exports.makeRedirectionMethodError = makeRedirectionMethodError;
  //# sourceMappingURL=fetch-common.js.map
  
  /***/ }),
  
  /***/ 323:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
  var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  };
  var __asyncValues = (this && this.__asyncValues) || function (o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const utils_1 = __webpack_require__(512);
  const deployment_status_1 = __importDefault(__webpack_require__(647));
  const query_string_1 = __webpack_require__(653);
  function createDeployment(metadata, files, options) {
      return __asyncGenerator(this, arguments, function* createDeployment_1() {
          const preparedFiles = utils_1.prepareFiles(files, options);
          let apiDeployments = metadata.version === 2 ? utils_1.API_DEPLOYMENTS : utils_1.API_DEPLOYMENTS_LEGACY;
          try {
              const dpl = yield __await(utils_1.fetch(`${apiDeployments}${query_string_1.generateQueryString(options)}`, options.token, {
                  method: 'POST',
                  headers: {
                      'Content-Type': 'application/json',
                      Authorization: `Bearer ${options.token}`
                  },
                  body: JSON.stringify(Object.assign({}, metadata, { files: preparedFiles }))
              }));
              const json = yield __await(dpl.json());
              if (!dpl.ok || json.error) {
                  // Return error object
                  return yield __await(yield yield __await({ type: 'error', payload: json.error || json }));
              }
              yield yield __await({ type: 'created', payload: json });
          }
          catch (e) {
              return yield __await(yield yield __await({ type: 'error', payload: e }));
          }
      });
  }
  const getDefaultName = (path, isDirectory, files) => {
      if (isDirectory && typeof path === 'string') {
          const segments = path.split('/');
          return segments[segments.length - 1];
      }
      else {
          const filePath = Array.from(files.values())[0].names[0];
          const segments = filePath.split('/');
          return segments[segments.length - 1];
      }
  };
  function deploy(files, options) {
      return __asyncGenerator(this, arguments, function* deploy_1() {
          var e_1, _a, e_2, _b;
          const nowJson = Array.from(files.values()).find((file) => {
              return Boolean(file.names.find((name) => name.includes('now.json')));
          });
          const nowJsonMetadata = utils_1.parseNowJSON(nowJson);
          const meta = options.metadata || {};
          const metadata = Object.assign({}, nowJsonMetadata, meta);
          // Check if we should default to a static deployment
          if (!metadata.version && !metadata.name) {
              metadata.version = 2;
              metadata.name =
                  options.totalFiles === 1
                      ? 'file'
                      : getDefaultName(options.path, options.isDirectory, files);
          }
          if (!metadata.name) {
              metadata.name =
                  options.defaultName ||
                      getDefaultName(options.path, options.isDirectory, files);
          }
          if (metadata.version === 1 && !metadata.deploymentType) {
              metadata.deploymentType = nowJsonMetadata.type;
          }
          delete metadata.github;
          delete metadata.scope;
          let deployment;
          try {
              try {
                  for (var _c = __asyncValues(createDeployment(metadata, files, options)), _d; _d = yield __await(_c.next()), !_d.done;) {
                      const event = _d.value;
                      if (event.type === 'created') {
                          deployment = event.payload;
                      }
                      yield yield __await(event);
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (_d && !_d.done && (_a = _c.return)) yield __await(_a.call(_c));
                  }
                  finally { if (e_1) throw e_1.error; }
              }
          }
          catch (e) {
              return yield __await(yield yield __await({ type: 'error', payload: e }));
          }
          if (deployment) {
              if (deployment.readyState === 'READY') {
                  return yield __await(yield yield __await({ type: 'ready', payload: deployment }));
              }
              try {
                  try {
                      for (var _e = __asyncValues(deployment_status_1.default(deployment, options.token, metadata.version, options.teamId)), _f; _f = yield __await(_e.next()), !_f.done;) {
                          const event = _f.value;
                          yield yield __await(event);
                      }
                  }
                  catch (e_2_1) { e_2 = { error: e_2_1 }; }
                  finally {
                      try {
                          if (_f && !_f.done && (_b = _e.return)) yield __await(_b.call(_e));
                      }
                      finally { if (e_2) throw e_2.error; }
                  }
              }
              catch (e) {
                  return yield __await(yield yield __await({ type: 'error', payload: e }));
              }
          }
      });
  }
  exports.default = deploy;
  
  
  /***/ }),
  
  /***/ 344:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  exports.fromCallback = function (fn) {
    return Object.defineProperty(function () {
      if (typeof arguments[arguments.length - 1] === 'function') fn.apply(this, arguments)
      else {
        return new Promise((resolve, reject) => {
          arguments[arguments.length] = (err, res) => {
            if (err) return reject(err)
            resolve(res)
          }
          arguments.length++
          fn.apply(this, arguments)
        })
      }
    }, 'name', { value: fn.name })
  }
  
  exports.fromPromise = function (fn) {
    return Object.defineProperty(function () {
      const cb = arguments[arguments.length - 1]
      if (typeof cb !== 'function') return fn.apply(this, arguments)
      else fn.apply(this, arguments).then(r => cb(null, r), cb)
    }, 'name', { value: fn.name })
  }
  
  
  /***/ }),
  
  /***/ 348:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var concatMap = __webpack_require__(20);
  var balanced = __webpack_require__(491);
  
  module.exports = expandTop;
  
  var escSlash = '\0SLASH'+Math.random()+'\0';
  var escOpen = '\0OPEN'+Math.random()+'\0';
  var escClose = '\0CLOSE'+Math.random()+'\0';
  var escComma = '\0COMMA'+Math.random()+'\0';
  var escPeriod = '\0PERIOD'+Math.random()+'\0';
  
  function numeric(str) {
    return parseInt(str, 10) == str
      ? parseInt(str, 10)
      : str.charCodeAt(0);
  }
  
  function escapeBraces(str) {
    return str.split('\\\\').join(escSlash)
              .split('\\{').join(escOpen)
              .split('\\}').join(escClose)
              .split('\\,').join(escComma)
              .split('\\.').join(escPeriod);
  }
  
  function unescapeBraces(str) {
    return str.split(escSlash).join('\\')
              .split(escOpen).join('{')
              .split(escClose).join('}')
              .split(escComma).join(',')
              .split(escPeriod).join('.');
  }
  
  
  // Basically just str.split(","), but handling cases
  // where we have nested braced sections, which should be
  // treated as individual members, like {a,{b,c},d}
  function parseCommaParts(str) {
    if (!str)
      return [''];
  
    var parts = [];
    var m = balanced('{', '}', str);
  
    if (!m)
      return str.split(',');
  
    var pre = m.pre;
    var body = m.body;
    var post = m.post;
    var p = pre.split(',');
  
    p[p.length-1] += '{' + body + '}';
    var postParts = parseCommaParts(post);
    if (post.length) {
      p[p.length-1] += postParts.shift();
      p.push.apply(p, postParts);
    }
  
    parts.push.apply(parts, p);
  
    return parts;
  }
  
  function expandTop(str) {
    if (!str)
      return [];
  
    // I don't know why Bash 4.3 does this, but it does.
    // Anything starting with {} will have the first two bytes preserved
    // but *only* at the top level, so {},a}b will not expand to anything,
    // but a{},b}c will be expanded to [a}c,abc].
    // One could argue that this is a bug in Bash, but since the goal of
    // this module is to match Bash's rules, we escape a leading {}
    if (str.substr(0, 2) === '{}') {
      str = '\\{\\}' + str.substr(2);
    }
  
    return expand(escapeBraces(str), true).map(unescapeBraces);
  }
  
  function identity(e) {
    return e;
  }
  
  function embrace(str) {
    return '{' + str + '}';
  }
  function isPadded(el) {
    return /^-?0\d/.test(el);
  }
  
  function lte(i, y) {
    return i <= y;
  }
  function gte(i, y) {
    return i >= y;
  }
  
  function expand(str, isTop) {
    var expansions = [];
  
    var m = balanced('{', '}', str);
    if (!m || /\$$/.test(m.pre)) return [str];
  
    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
    var isSequence = isNumericSequence || isAlphaSequence;
    var isOptions = m.body.indexOf(',') >= 0;
    if (!isSequence && !isOptions) {
      // {a},b}
      if (m.post.match(/,.*\}/)) {
        str = m.pre + '{' + m.body + escClose + m.post;
        return expand(str);
      }
      return [str];
    }
  
    var n;
    if (isSequence) {
      n = m.body.split(/\.\./);
    } else {
      n = parseCommaParts(m.body);
      if (n.length === 1) {
        // x{{a,b}}y ==> x{a}y x{b}y
        n = expand(n[0], false).map(embrace);
        if (n.length === 1) {
          var post = m.post.length
            ? expand(m.post, false)
            : [''];
          return post.map(function(p) {
            return m.pre + n[0] + p;
          });
        }
      }
    }
  
    // at this point, n is the parts, and we know it's not a comma set
    // with a single entry.
  
    // no need to expand pre, since it is guaranteed to be free of brace-sets
    var pre = m.pre;
    var post = m.post.length
      ? expand(m.post, false)
      : [''];
  
    var N;
  
    if (isSequence) {
      var x = numeric(n[0]);
      var y = numeric(n[1]);
      var width = Math.max(n[0].length, n[1].length)
      var incr = n.length == 3
        ? Math.abs(numeric(n[2]))
        : 1;
      var test = lte;
      var reverse = y < x;
      if (reverse) {
        incr *= -1;
        test = gte;
      }
      var pad = n.some(isPadded);
  
      N = [];
  
      for (var i = x; test(i, y); i += incr) {
        var c;
        if (isAlphaSequence) {
          c = String.fromCharCode(i);
          if (c === '\\')
            c = '';
        } else {
          c = String(i);
          if (pad) {
            var need = width - c.length;
            if (need > 0) {
              var z = new Array(need + 1).join('0');
              if (i < 0)
                c = '-' + z + c.slice(1);
              else
                c = z + c;
            }
          }
        }
        N.push(c);
      }
    } else {
      N = concatMap(n, function(el) { return expand(el, false) });
    }
  
    for (var j = 0; j < N.length; j++) {
      for (var k = 0; k < post.length; k++) {
        var expansion = pre + N[j] + post[k];
        if (!isTop || isSequence || expansion)
          expansions.push(expansion);
      }
    }
  
    return expansions;
  }
  
  
  
  /***/ }),
  
  /***/ 360:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const url_1 = __webpack_require__(986);
  const context_http1_1 = __webpack_require__(826);
  const context_http2_1 = __webpack_require__(121);
  const context_https_1 = __webpack_require__(436);
  const cookie_jar_1 = __webpack_require__(837);
  const core_1 = __webpack_require__(570);
  const fetch_http1_1 = __webpack_require__(554);
  const fetch_http2_1 = __webpack_require__(951);
  const version_1 = __webpack_require__(282);
  const request_1 = __webpack_require__(673);
  const utils_1 = __webpack_require__(760);
  function makeDefaultUserAgent() {
      const name = `fetch-h2/${version_1.version} (+https://github.com/grantila/fetch-h2)`;
      const node = `nodejs/${process.versions.node}`;
      const nghttp2 = `nghttp2/${process.versions.nghttp2}`;
      const uv = `uv/${process.versions.uv}`;
      return `${name} ${node} ${nghttp2} ${uv}`;
  }
  const defaultUserAgent = makeDefaultUserAgent();
  const defaultAccept = "application/json, text/*;0.9, */*;q=0.8";
  class Context {
      constructor(opts) {
          this._userAgent = "";
          this._overwriteUserAgent = false;
          this._accept = "";
          this._cookieJar = void 0;
          this._decoders = [];
          this._sessionOptions = {};
          this._httpProtocol = "http1";
          this._httpsProtocols = ["http2", "http1"];
          this._http1Options = {};
          this.setup(opts);
          this.h1Context = new context_http1_1.H1Context(this._http1Options);
          this.h2Context = new context_http2_1.H2Context(this.decoders.bind(this), this.sessionOptions.bind(this));
      }
      setup(opts) {
          opts = opts || {};
          this._cookieJar = "cookieJar" in opts
              ? (opts.cookieJar || new cookie_jar_1.CookieJar())
              : new cookie_jar_1.CookieJar();
          this._userAgent = core_1.parsePerOrigin(opts.userAgent, "");
          this._overwriteUserAgent =
              core_1.parsePerOrigin(opts.overwriteUserAgent, false);
          this._accept = core_1.parsePerOrigin(opts.accept, defaultAccept);
          this._decoders = core_1.parsePerOrigin(opts.decoders, []);
          this._sessionOptions = core_1.parsePerOrigin(opts.session, {});
          this._httpProtocol = core_1.parsePerOrigin(opts.httpProtocol, "http1");
          this._httpsProtocols = core_1.parsePerOrigin(opts.httpsProtocols, ["http2", "http1"]);
          Object.assign(this._http1Options, opts.http1 || {});
      }
      userAgent(origin) {
          const combine = (userAgent, overwriteUserAgent) => {
              const defaultUA = overwriteUserAgent ? "" : defaultUserAgent;
              return userAgent
                  ? defaultUA
                      ? userAgent + " " + defaultUA
                      : userAgent
                  : defaultUA;
          };
          return combine(core_1.getByOrigin(this._userAgent, origin), core_1.getByOrigin(this._overwriteUserAgent, origin));
      }
      decoders(origin) {
          return core_1.getByOrigin(this._decoders, origin);
      }
      sessionOptions(origin) {
          return core_1.getByOrigin(this._sessionOptions, origin);
      }
      onPush(pushHandler) {
          this.h2Context._pushHandler = pushHandler;
      }
      async fetch(input, init) {
          const { hostname, origin, port, protocol, url } = this.parseInput(input);
          // Rewrite url to get rid of "http1://" and "http2://"
          const request = input instanceof request_1.Request
              ? input.url !== url
                  ? input.clone(url)
                  : input
              : new request_1.Request(input, { ...(init || {}), url });
          const { rejectUnauthorized } = this.sessionOptions(origin);
          const makeSimpleSession = (protocol) => ({
              accept: () => core_1.getByOrigin(this._accept, origin),
              contentDecoders: () => core_1.getByOrigin(this._decoders, origin),
              cookieJar: this._cookieJar,
              protocol,
              userAgent: () => this.userAgent(origin),
          });
          const doFetchHttp1 = (socket, cleanup) => {
              const sessionGetterHttp1 = {
                  get: (url) => ({
                      cleanup,
                      req: this.getHttp1(url, socket, request, rejectUnauthorized),
                  }),
                  ...makeSimpleSession("http1"),
              };
              return fetch_http1_1.fetch(sessionGetterHttp1, request, init);
          };
          const doFetchHttp2 = () => {
              const sessionGetterHttp2 = {
                  get: (url) => this.getHttp2(url),
                  ...makeSimpleSession("http2"),
              };
              return fetch_http2_1.fetch(sessionGetterHttp2, request, init);
          };
          const tryWaitForHttp1 = async () => {
              const { socket: freeHttp1Socket, cleanup, shouldCreateNew } = this.h1Context.getFreeSocketForOrigin(origin);
              if (freeHttp1Socket)
                  return doFetchHttp1(freeHttp1Socket, cleanup);
              if (!shouldCreateNew) {
                  // We've maxed out HTTP/1 connections, wait for one to be
                  // freed.
                  const { socket, cleanup } = await this.h1Context.waitForSocket(origin);
                  return doFetchHttp1(socket, cleanup);
              }
          };
          if (protocol === "http1") {
              // Plain text HTTP/1(.1)
              const resp = await tryWaitForHttp1();
              if (resp)
                  return resp;
              const socket = await this.h1Context.makeNewConnection(url);
              const cleanup = this.h1Context.addUsedSocket(origin, socket);
              return doFetchHttp1(socket, cleanup);
          }
          else if (protocol === "http2") {
              // Plain text HTTP/2
              return doFetchHttp2();
          }
          else // protocol === "https"
           {
              // If we already have a session/socket open to this origin,
              // re-use it
              if (this.h2Context.hasOrigin(origin))
                  return doFetchHttp2();
              const resp = await tryWaitForHttp1();
              if (resp)
                  return resp;
              // TODO: Make queue for subsequent fetch requests to the same
              //       origin, so they can re-use the http2 session, or http1
              //       pool once we know what protocol will be used.
              //       This must apply to plain-text http1 too.
              // Use ALPN to figure out protocol lazily
              const { protocol, socket } = await context_https_1.connectTLS(hostname, port, core_1.getByOrigin(this._httpsProtocols, origin), core_1.getByOrigin(this._sessionOptions, origin));
              if (protocol === "http2") {
                  // Convert socket into http2 session, this will ref (*)
                  const { cleanup } = await this.h2Context.getOrCreateHttp2(origin, {
                      createConnection: () => socket,
                  });
                  // Session now lingering, it will be re-used by the next get()
                  const ret = doFetchHttp2();
                  // Unref lingering ref
                  cleanup();
                  return ret;
              }
              else // protocol === "http1"
               {
                  const cleanup = this.h1Context.addUsedSocket(origin, socket);
                  return doFetchHttp1(socket, cleanup);
              }
          }
      }
      async disconnect(url) {
          await Promise.all([
              this.h1Context.disconnect(url),
              this.h2Context.disconnect(url),
          ]);
      }
      async disconnectAll() {
          await Promise.all([
              this.h1Context.disconnectAll(),
              this.h2Context.disconnectAll(),
          ]);
      }
      getHttp1(url, socket, request, rejectUnauthorized) {
          return this.h1Context.connect(new url_1.URL(url), {
              createConnection: () => socket,
              rejectUnauthorized,
          }, request);
      }
      getOrCreateHttp2(origin, created = false) {
          const { didCreate, session, cleanup } = this.h2Context.getOrCreateHttp2(origin);
          return session
              .catch(err => {
              if (didCreate || created)
                  // Created in this request, forward error
                  throw err;
              // Not created in this request, try again
              return this.getOrCreateHttp2(origin, true)
                  .then(({ session }) => session);
          })
              .then(session => ({ session, cleanup }));
      }
      getHttp2(url) {
          const { origin } = typeof url === "string" ? new url_1.URL(url) : url;
          return this.getOrCreateHttp2(origin);
      }
      parseInput(input) {
          const { hostname, origin, port, protocol, url } = utils_1.parseInput(typeof input !== "string" ? input.url : input);
          const defaultHttp = this._httpProtocol;
          if ((protocol === "http" && defaultHttp === "http1")
              || protocol === "http1")
              return {
                  hostname,
                  origin,
                  port,
                  protocol: "http1",
                  url,
              };
          else if ((protocol === "http" && defaultHttp === "http2")
              || protocol === "http2")
              return {
                  hostname,
                  origin,
                  port,
                  protocol: "http2",
                  url,
              };
          else if (protocol === "https")
              return {
                  hostname,
                  origin,
                  port,
                  protocol: "https",
                  url,
              };
          else
              throw new core_1.FetchError(`Invalid protocol "${protocol}"`);
      }
  }
  exports.Context = Context;
  //# sourceMappingURL=context.js.map
  
  /***/ }),
  
  /***/ 366:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const pump = __webpack_require__(932);
  const bufferStream = __webpack_require__(922);
  
  class MaxBufferError extends Error {
  	constructor() {
  		super('maxBuffer exceeded');
  		this.name = 'MaxBufferError';
  	}
  }
  
  async function getStream(inputStream, options) {
  	if (!inputStream) {
  		return Promise.reject(new Error('Expected a stream'));
  	}
  
  	options = {
  		maxBuffer: Infinity,
  		...options
  	};
  
  	const {maxBuffer} = options;
  
  	let stream;
  	await new Promise((resolve, reject) => {
  		const rejectPromise = error => {
  			if (error) { // A null check
  				error.bufferedData = stream.getBufferedValue();
  			}
  
  			reject(error);
  		};
  
  		stream = pump(inputStream, bufferStream(options), error => {
  			if (error) {
  				rejectPromise(error);
  				return;
  			}
  
  			resolve();
  		});
  
  		stream.on('data', () => {
  			if (stream.getBufferedLength() > maxBuffer) {
  				rejectPromise(new MaxBufferError());
  			}
  		});
  	});
  
  	return stream.getBufferedValue();
  }
  
  module.exports = getStream;
  // TODO: Remove this for the next major release
  module.exports.default = getStream;
  module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
  module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
  module.exports.MaxBufferError = MaxBufferError;
  
  
  /***/ }),
  
  /***/ 376:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(589)
  
  // get drive on windows
  function getRootPath (p) {
    p = path.normalize(path.resolve(p)).split(path.sep)
    if (p.length > 0) return p[0]
    return null
  }
  
  // http://stackoverflow.com/a/62888/10333 contains more accurate
  // TODO: expand to include the rest
  const INVALID_PATH_CHARS = /[<>:"|?*]/
  
  function invalidWin32Path (p) {
    const rp = getRootPath(p)
    p = p.replace(rp, '')
    return INVALID_PATH_CHARS.test(p)
  }
  
  module.exports = {
    getRootPath,
    invalidWin32Path
  }
  
  
  /***/ }),
  
  /***/ 380:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  // Packages
  var retrier = __webpack_require__(565);
  
  function retry(fn, opts) {
    function run(resolve, reject) {
      var options = opts || {};
      var op = retrier.operation(options);
  
      // We allow the user to abort retrying
      // this makes sense in the cases where
      // knowledge is obtained that retrying
      // would be futile (e.g.: auth errors)
  
      function bail(err) {
        reject(err || new Error('Aborted'));
      }
  
      function onError(err, num) {
        if (err.bail) {
          bail(err);
          return;
        }
  
        if (!op.retry(err)) {
          reject(op.mainError());
        } else if (options.onRetry) {
          options.onRetry(err, num);
        }
      }
  
      function runAttempt(num) {
        var val;
  
        try {
          val = fn(bail, num);
        } catch (err) {
          onError(err, num);
          return;
        }
  
        Promise.resolve(val)
          .then(resolve)
          .catch(function catchIt(err) {
            onError(err, num);
          });
      }
  
      op.attempt(runAttempt);
    }
  
    return new Promise(run);
  }
  
  module.exports = retry;
  
  
  /***/ }),
  
  /***/ 381:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  module.exports = {
    copy: u(__webpack_require__(273))
  }
  
  
  /***/ }),
  
  /***/ 382:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function handle(handler, err, stacks) {
      try {
          var handledErr = stacks.length === 0 ? err : Object.create(err);
          if (stacks.length > 0) {
              handledErr.stack =
                  stacks.concat([err.stack]).join("\nFrom:\n")
                      .replace("\n\n", "\n");
          }
          try {
              handler(handledErr);
          }
          catch (err) {
              console.error("[callguard 1/2]: guard handler threw error", err);
              console.error("[callguard 2/2]: while handling", handledErr);
          }
      }
      catch (err) {
          console.error("[callguard] handle error (probably caused by non-Error throw)]", err);
      }
  }
  function syncGuard(handler, opts) {
      var captureCallstacks = opts && !!opts.longStackTraces;
      var defaultReturn = (opts && opts.defaultReturn != null)
          ? opts.defaultReturn
          : null;
      var stacks = [];
      return function (fn) {
          if (captureCallstacks)
              stacks.push((new Error("[callguard]")).stack);
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              if (captureCallstacks)
                  stacks.push((new Error("[callguard]")).stack);
              try {
                  var ret = fn.apply(void 0, args);
                  if (opts && opts.catchAsync) {
                      Promise.resolve(ret)
                          .catch(function (err) { return handle(handler, err, stacks); });
                  }
                  return ret;
              }
              catch (err) {
                  handle(handler, err, stacks);
                  return defaultReturn;
              }
          };
      };
  }
  exports.syncGuard = syncGuard;
  function asyncGuard(handler, opts) {
      var captureCallstacks = opts && !!opts.longStackTraces;
      var defaultReturn = (opts && opts.defaultReturn != null)
          ? opts.defaultReturn
          : null;
      var stacks = [];
      return function (fn) {
          if (captureCallstacks)
              stacks.push((new Error("[callguard]")).stack);
          return function () {
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              if (captureCallstacks)
                  stacks.push((new Error("[callguard]")).stack);
              try {
                  return Promise.resolve(fn.apply(void 0, args))
                      .catch(function (err) {
                      handle(handler, err, stacks);
                      return defaultReturn;
                  });
              }
              catch (err) {
                  handle(handler, err, stacks);
                  return defaultReturn;
              }
          };
      };
  }
  exports.asyncGuard = asyncGuard;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 393:
  /***/ (function(module) {
  
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 404:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  // a duplex stream is just a stream that is both readable and writable.
  // Since JS doesn't have multiple prototypal inheritance, this class
  // prototypally inherits from Readable, and then parasitically from
  // Writable.
  
  /*<replacement>*/
  
  var objectKeys = Object.keys || function (obj) {
    var keys = [];
  
    for (var key in obj) {
      keys.push(key);
    }
  
    return keys;
  };
  /*</replacement>*/
  
  
  module.exports = Duplex;
  
  var Readable = __webpack_require__(42);
  
  var Writable = __webpack_require__(200);
  
  __webpack_require__(207)(Duplex, Readable);
  
  {
    // Allow the keys array to be GC'ed.
    var keys = objectKeys(Writable.prototype);
  
    for (var v = 0; v < keys.length; v++) {
      var method = keys[v];
      if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
    }
  }
  
  function Duplex(options) {
    if (!(this instanceof Duplex)) return new Duplex(options);
    Readable.call(this, options);
    Writable.call(this, options);
    this.allowHalfOpen = true;
  
    if (options) {
      if (options.readable === false) this.readable = false;
      if (options.writable === false) this.writable = false;
  
      if (options.allowHalfOpen === false) {
        this.allowHalfOpen = false;
        this.once('end', onend);
      }
    }
  }
  
  Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState.highWaterMark;
    }
  });
  Object.defineProperty(Duplex.prototype, 'writableBuffer', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState && this._writableState.getBuffer();
    }
  });
  Object.defineProperty(Duplex.prototype, 'writableLength', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      return this._writableState.length;
    }
  }); // the no-half-open enforcer
  
  function onend() {
    // If the writable side ended, then we're ok.
    if (this._writableState.ended) return; // no more data can be written.
    // But allow more writes to happen in this tick.
  
    process.nextTick(onEndNT, this);
  }
  
  function onEndNT(self) {
    self.end();
  }
  
  Object.defineProperty(Duplex.prototype, 'destroyed', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function get() {
      if (this._readableState === undefined || this._writableState === undefined) {
        return false;
      }
  
      return this._readableState.destroyed && this._writableState.destroyed;
    },
    set: function set(value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (this._readableState === undefined || this._writableState === undefined) {
        return;
      } // backward compatibility, the user is explicitly
      // managing destroyed
  
  
      this._readableState.destroyed = value;
      this._writableState.destroyed = value;
    }
  });
  
  /***/ }),
  
  /***/ 415:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const fs = __webpack_require__(813)
  const path = __webpack_require__(589)
  const mkdir = __webpack_require__(562)
  const pathExists = __webpack_require__(734).pathExists
  
  function outputFile (file, data, encoding, callback) {
    if (typeof encoding === 'function') {
      callback = encoding
      encoding = 'utf8'
    }
  
    const dir = path.dirname(file)
    pathExists(dir, (err, itDoes) => {
      if (err) return callback(err)
      if (itDoes) return fs.writeFile(file, data, encoding, callback)
  
      mkdir.mkdirs(dir, err => {
        if (err) return callback(err)
  
        fs.writeFile(file, data, encoding, callback)
      })
    })
  }
  
  function outputFileSync (file, ...args) {
    const dir = path.dirname(file)
    if (fs.existsSync(dir)) {
      return fs.writeFileSync(file, ...args)
    }
    mkdir.mkdirsSync(dir)
    fs.writeFileSync(file, ...args)
  }
  
  module.exports = {
    outputFile: u(outputFile),
    outputFileSync
  }
  
  
  /***/ }),
  
  /***/ 421:
  /***/ (function(module) {
  
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 431:
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 436:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const tls_1 = __webpack_require__(806);
  const alpnProtocols = {
      http1: Buffer.from("\x08http/1.1"),
      http2: Buffer.from("\x02h2"),
  };
  const defaultMethod = ["http2", "http1"];
  function connectTLS(host, port, protocols, connOpts) {
      const usedProtocol = new Set();
      const _protocols = protocols.filter(protocol => {
          if (protocol !== "http1" && protocol !== "http2")
              return false;
          if (usedProtocol.has(protocol))
              return false;
          usedProtocol.add(protocol);
          return true;
      });
      const orderedProtocols = Buffer.concat((_protocols.length !== 0 ? _protocols : defaultMethod)
          .map(protocol => alpnProtocols[protocol]));
      const opts = {
          ...connOpts,
          ALPNProtocols: orderedProtocols,
          servername: host,
      };
      return new Promise((resolve, reject) => {
          const socket = tls_1.connect(parseInt(port, 10), host, opts, () => {
              const { authorized, authorizationError, alpnProtocol = "" } = socket;
              if (!authorized && opts.rejectUnauthorized !== false)
                  return reject(authorizationError);
              if (!["h2", "http/1.1", "http/1.0"].includes(alpnProtocol)) {
                  // Maybe the server doesn't understand ALPN, enforce
                  // user-provided protocol, or fallback to HTTP/1
                  if (_protocols.length === 1)
                      return resolve({ protocol: _protocols[0], socket });
                  else
                      return resolve({ protocol: "http1", socket });
              }
              const protocol = alpnProtocol === "h2" ? "http2" : "http1";
              resolve({ socket, protocol });
          });
          socket.once("error", reject);
      });
  }
  exports.connectTLS = connectTLS;
  //# sourceMappingURL=context-https.js.map
  
  /***/ }),
  
  /***/ 452:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const crypto_1 = __webpack_require__(298);
  const already_1 = __webpack_require__(534);
  const get_stream_1 = __webpack_require__(366);
  const through2 = __webpack_require__(874);
  const toArrayBuffer = __webpack_require__(715);
  const core_1 = __webpack_require__(570);
  function makeUnknownDataError() {
      return new Error("Unknown body data");
  }
  function throwIntegrityMismatch() {
      throw new Error("Resource integrity mismatch");
  }
  function throwLengthMismatch() {
      throw new RangeError("Resource length mismatch (possibly incomplete body)");
  }
  function parseIntegrity(integrity) {
      const [algorithm, ...expectedHash] = integrity.split("-");
      return { algorithm, hash: expectedHash.join("-") };
  }
  function isStream(body) {
      return body &&
          ("readable" in Object(body));
  }
  const emptyBuffer = new ArrayBuffer(0);
  class Body {
      constructor() {
          this._length = null;
          this._used = false;
          Object.defineProperties(this, {
              bodyUsed: {
                  enumerable: true,
                  get: () => this._used,
              },
          });
      }
      async arrayBuffer(allowIncomplete = false) {
          this._ensureUnused();
          this._ensureNotAborted();
          if (this._body == null)
              return this.validateIntegrity(emptyBuffer, allowIncomplete);
          else if (isStream(this._body))
              return get_stream_1.default.buffer(this._body)
                  .then(buffer => this.validateIntegrity(buffer, allowIncomplete))
                  .then(buffer => toArrayBuffer(buffer));
          else if (Buffer.isBuffer(this._body))
              return this.validateIntegrity(toArrayBuffer(this._body), allowIncomplete);
          else
              throw makeUnknownDataError();
      }
      async formData() {
          throw new Error("Body.formData() is not yet implemented");
      }
      async json() {
          this._ensureUnused();
          this._ensureNotAborted();
          if (this._body == null)
              return Promise.resolve(this.validateIntegrity(emptyBuffer, false))
                  .then(() => this._body);
          else if (isStream(this._body))
              return get_stream_1.default.buffer(this._body)
                  .then(already_1.tap(buffer => this.validateIntegrity(buffer, false)))
                  .then(buffer => JSON.parse(buffer.toString()));
          else if (Buffer.isBuffer(this._body))
              return Promise.resolve(this._body)
                  .then(already_1.tap(buffer => this.validateIntegrity(buffer, false)))
                  .then(buffer => JSON.parse(buffer.toString()));
          else
              throw makeUnknownDataError();
      }
      async text(allowIncomplete = false) {
          this._ensureUnused();
          this._ensureNotAborted();
          if (this._body == null)
              return Promise.resolve(this.validateIntegrity(emptyBuffer, allowIncomplete))
                  .then(() => this._body);
          else if (isStream(this._body))
              return get_stream_1.default.buffer(this._body)
                  .then(already_1.tap(buffer => this.validateIntegrity(buffer, allowIncomplete)))
                  .then(buffer => buffer.toString());
          else if (Buffer.isBuffer(this._body))
              return Promise.resolve(this._body)
                  .then(already_1.tap(buffer => this.validateIntegrity(buffer, allowIncomplete)))
                  .then(buffer => buffer.toString());
          else
              throw makeUnknownDataError();
      }
      async readable() {
          this._ensureUnused();
          this._ensureNotAborted();
          if (this._body == null) {
              const stream = through2();
              stream.end();
              return Promise.resolve(stream);
          }
          else if (isStream(this._body))
              return Promise.resolve(this._body);
          else if (Buffer.isBuffer(this._body))
              return Promise.resolve(through2())
                  .then(stream => {
                  stream.write(this._body);
                  stream.end();
                  return stream;
              });
          else
              throw makeUnknownDataError();
      }
      setSignal(signal) {
          this._signal = signal;
      }
      hasBody() {
          return "_body" in this;
      }
      setBody(body, mime, integrity, length = null) {
          this._ensureUnused();
          this._length = length;
          this._used = false;
          if (body instanceof Body) {
              body._ensureUnused();
              this._body = body._body;
              this._mime = body._mime;
          }
          else if (typeof body === "string")
              this._body = Buffer.from(body);
          else if (body != null)
              this._body = body;
          else
              this._body = body;
          if (Buffer.isBuffer(this._body))
              this._length = this._body.length;
          if (mime)
              this._mime = mime;
          if (integrity)
              this._integrity = integrity;
      }
      validateIntegrity(data, allowIncomplete) {
          this._ensureNotAborted();
          if (!allowIncomplete &&
              this._length != null &&
              data.byteLength !== this._length)
              throwLengthMismatch();
          if (!this._integrity)
              // This is valid
              return data;
          const { algorithm, hash: expectedHash } = parseIntegrity(this._integrity);
          // jest (I presume) modifies ArrayBuffer, breaking instanceof
          const instanceOfArrayBuffer = (val) => val && val.constructor && val.constructor.name === "ArrayBuffer";
          const hash = crypto_1.createHash(algorithm)
              .update(instanceOfArrayBuffer(data)
              ? new DataView(data)
              : data)
              .digest("base64");
          if (expectedHash.toLowerCase() !== hash.toLowerCase())
              throwIntegrityMismatch();
          return data;
      }
      _ensureNotAborted() {
          if (this._signal && this._signal.aborted)
              throw new core_1.AbortError("Response aborted");
      }
      _ensureUnused() {
          if (this._used)
              throw new ReferenceError("Body already used");
          this._used = true;
      }
      // @ts-ignore
      async blob() {
          throw new Error("Body.blob() is not implemented (makes no sense in Node.js), " +
              "use another getter.");
      }
  }
  exports.Body = Body;
  class JsonBody extends Body {
      constructor(obj) {
          super();
          const body = Buffer.from(JSON.stringify(obj));
          this.setBody(body, "application/json");
      }
  }
  exports.JsonBody = JsonBody;
  class StreamBody extends Body {
      constructor(readable) {
          super();
          this.setBody(readable);
      }
  }
  exports.StreamBody = StreamBody;
  class DataBody extends Body {
      constructor(data) {
          super();
          this.setBody(data);
      }
  }
  exports.DataBody = DataBody;
  class BodyInspector extends Body {
      constructor(body) {
          super();
          this._ref = body;
      }
      _getMime() {
          return this._mime;
      }
      _getLength() {
          return this._length;
      }
      get mime() {
          return this._getMime.call(this._ref);
      }
      get length() {
          return this._getLength.call(this._ref);
      }
  }
  exports.BodyInspector = BodyInspector;
  //# sourceMappingURL=body.js.map
  
  /***/ }),
  
  /***/ 471:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  /*jshint unused:false */
  
  function Store() {
  }
  exports.Store = Store;
  
  // Stores may be synchronous, but are still required to use a
  // Continuation-Passing Style API.  The CookieJar itself will expose a "*Sync"
  // API that converts from synchronous-callbacks to imperative style.
  Store.prototype.synchronous = false;
  
  Store.prototype.findCookie = function(domain, path, key, cb) {
    throw new Error('findCookie is not implemented');
  };
  
  Store.prototype.findCookies = function(domain, path, cb) {
    throw new Error('findCookies is not implemented');
  };
  
  Store.prototype.putCookie = function(cookie, cb) {
    throw new Error('putCookie is not implemented');
  };
  
  Store.prototype.updateCookie = function(oldCookie, newCookie, cb) {
    // recommended default implementation:
    // return this.putCookie(newCookie, cb);
    throw new Error('updateCookie is not implemented');
  };
  
  Store.prototype.removeCookie = function(domain, path, key, cb) {
    throw new Error('removeCookie is not implemented');
  };
  
  Store.prototype.removeCookies = function(domain, path, cb) {
    throw new Error('removeCookies is not implemented');
  };
  
  Store.prototype.removeAllCookies = function(cb) {
    throw new Error('removeAllCookies is not implemented');
  }
  
  Store.prototype.getAllCookies = function(cb) {
    throw new Error('getAllCookies is not implemented (therefore jar cannot be serialized)');
  };
  
  
  /***/ }),
  
  /***/ 480:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  
  function symlinkType (srcpath, type, callback) {
    callback = (typeof type === 'function') ? type : callback
    type = (typeof type === 'function') ? false : type
    if (type) return callback(null, type)
    fs.lstat(srcpath, (err, stats) => {
      if (err) return callback(null, 'file')
      type = (stats && stats.isDirectory()) ? 'dir' : 'file'
      callback(null, type)
    })
  }
  
  function symlinkTypeSync (srcpath, type) {
    let stats
  
    if (type) return type
    try {
      stats = fs.lstatSync(srcpath)
    } catch (e) {
      return 'file'
    }
    return (stats && stats.isDirectory()) ? 'dir' : 'file'
  }
  
  module.exports = {
    symlinkType,
    symlinkTypeSync
  }
  
  
  /***/ }),
  
  /***/ 485:
  /***/ (function(module) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 491:
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = balanced;
  function balanced(a, b, str) {
    if (a instanceof RegExp) a = maybeMatch(a, str);
    if (b instanceof RegExp) b = maybeMatch(b, str);
  
    var r = range(a, b, str);
  
    return r && {
      start: r[0],
      end: r[1],
      pre: str.slice(0, r[0]),
      body: str.slice(r[0] + a.length, r[1]),
      post: str.slice(r[1] + b.length)
    };
  }
  
  function maybeMatch(reg, str) {
    var m = str.match(reg);
    return m ? m[0] : null;
  }
  
  balanced.range = range;
  function range(a, b, str) {
    var begs, beg, left, right, result;
    var ai = str.indexOf(a);
    var bi = str.indexOf(b, ai + 1);
    var i = ai;
  
    if (ai >= 0 && bi > 0) {
      begs = [];
      left = str.length;
  
      while (i >= 0 && !result) {
        if (i == ai) {
          begs.push(i);
          ai = str.indexOf(a, i + 1);
        } else if (begs.length == 1) {
          result = [ begs.pop(), bi ];
        } else {
          beg = begs.pop();
          if (beg < left) {
            left = beg;
            right = bi;
          }
  
          bi = str.indexOf(b, i + 1);
        }
  
        i = ai < bi && ai >= 0 ? ai : bi;
      }
  
      if (begs.length) {
        result = [ left, right ];
      }
    }
  
    return result;
  }
  
  
  /***/ }),
  
  /***/ 501:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  /*!
   * Copyright (c) 2018, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  var psl = __webpack_require__(672);
  
  function getPublicSuffix(domain) {
    return psl.get(domain);
  }
  
  exports.getPublicSuffix = getPublicSuffix;
  
  
  /***/ }),
  
  /***/ 507:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  
  /**
   * For Node.js, simply re-export the core `util.deprecate` function.
   */
  
  module.exports = __webpack_require__(64).deprecate;
  
  
  /***/ }),
  
  /***/ 512:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const url_1 = __webpack_require__(986);
  const fetch_h2_1 = __webpack_require__(604);
  const fs_extra_1 = __webpack_require__(77);
  const path_1 = __webpack_require__(589);
  const querystring_1 = __importDefault(__webpack_require__(272));
  const package_json_1 = __importDefault(__webpack_require__(818));
  exports.API_FILES = 'https://api.zeit.co/v2/now/files';
  exports.API_DEPLOYMENTS = 'https://api.zeit.co/v9/now/deployments';
  exports.API_DEPLOYMENTS_LEGACY = 'https://api.zeit.co/v3/now/deployments';
  exports.API_DELETE_DEPLOYMENTS_LEGACY = 'https://api.zeit.co/v2/now/deployments';
  exports.EVENTS = new Set([
      // File events
      'hashes-calculated',
      'file-uploaded',
      'all-files-uploaded',
      // Deployment events
      'created',
      'ready',
      'error',
      // Build events
      'build-state-changed'
  ]);
  function parseNowJSON(file) {
      if (!file) {
          return {};
      }
      try {
          const jsonString = file.data.toString();
          return JSON.parse(jsonString);
      }
      catch (e) {
          // eslint-disable-next-line no-console
          console.error(e);
          return {};
      }
  }
  exports.parseNowJSON = parseNowJSON;
  async function getNowIgnore(files, path) {
      let ignores = [
          '.hg',
          '.git',
          '.gitmodules',
          '.svn',
          '.cache',
          '.next',
          '.now',
          '.npmignore',
          '.dockerignore',
          '.gitignore',
          '.*.swp',
          '.DS_Store',
          '.wafpicke-*',
          '.lock-wscript',
          '.env',
          '.env.build',
          '.venv',
          'npm-debug.log',
          'config.gypi',
          'node_modules',
          '__pycache__/',
          'venv/',
          'CVS'
      ];
      await Promise.all(files.map(async (file) => {
          if (file.includes('.nowignore')) {
              const filePath = Array.isArray(path)
                  ? file
                  : file.includes(path)
                      ? file
                      : path_1.join(path, file);
              const nowIgnore = await fs_extra_1.readFile(filePath);
              nowIgnore
                  .toString()
                  .split('\n')
                  .filter((s) => s.length > 0)
                  .forEach((entry) => ignores.push(entry));
          }
      }));
      return ignores;
  }
  exports.getNowIgnore = getNowIgnore;
  exports.fetch = (url, token, opts = {}) => {
      if (opts.teamId) {
          const parsedUrl = url_1.parse(url, true);
          const query = parsedUrl.query;
          query.teamId = opts.teamId;
          url = `${parsedUrl.href}?${querystring_1.default.encode(query)}`;
          delete opts.teamId;
      }
      opts.headers = opts.headers || {};
      // @ts-ignore
      opts.headers.authorization = `Bearer ${token}`;
      // @ts-ignore
      opts.headers['user-agent'] = `now-client-v${package_json_1.default.version}`;
      return fetch_h2_1.fetch(url, opts);
  };
  exports.prepareFiles = (files, options) => {
      const preparedFiles = [...files.keys()].reduce((acc, sha) => {
          const next = [...acc];
          const file = files.get(sha);
          for (const name of file.names) {
              let fileName;
              if (options.isDirectory) {
                  // Directory
                  fileName = options.path ? name.replace(`${options.path}/`, '') : name;
              }
              else {
                  // Array of files or single file
                  const segments = name.split('/');
                  fileName = segments[segments.length - 1];
              }
              next.push({
                  file: fileName,
                  size: file.data.byteLength || file.data.length,
                  sha
              });
          }
          return next;
      }, []);
      return preparedFiles;
  };
  
  
  /***/ }),
  
  /***/ 534:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const throat = __webpack_require__(952);
  exports.default = {
      Finally,
      Try,
      defer,
      delay,
      delayChain,
      each,
      filter,
      finally: Finally,
      finallyDelay,
      funnel,
      inspect,
      map,
      once,
      props,
      reduce,
      rethrow,
      retry,
      some,
      specific,
      tap,
      wrapFunction,
  };
  function toReadonlyArray(arr) {
      /* istanbul ignore else */
      if (typeof arr.map === "function")
          return arr;
      else
          return Array.from(arr);
  }
  function delay(milliseconds, t) {
      return new Promise((resolve, reject) => {
          setTimeout(() => resolve(t), milliseconds);
      });
  }
  exports.delay = delay;
  function delayChain(milliseconds) {
      return tap(() => delay(milliseconds));
  }
  exports.delayChain = delayChain;
  function finallyDelay(milliseconds) {
      return Finally(() => delay(milliseconds));
  }
  exports.finallyDelay = finallyDelay;
  function Finally(fn) {
      async function _then(t) {
          await fn();
          return t;
      }
      async function _catch(err) {
          await fn();
          throw err;
      }
      return [_then, _catch];
  }
  exports.Finally = Finally;
  function tap(fn) {
      return async (t) => {
          await fn(t);
          return t;
      };
  }
  exports.tap = tap;
  function props(obj) {
      const ret = {};
      const awaiters = [];
      for (const prop of Object.keys(obj))
          awaiters.push(Promise.resolve(obj[prop])
              .then(val => { ret[prop] = val; }));
      return Promise.all(awaiters).then(() => ret);
  }
  exports.props = props;
  const defaultFilterMapOptions = { concurrency: Infinity };
  function filter(arr, opts, filterFn) {
      if (Array.isArray(arr)) {
          if (typeof opts === "function") {
              filterFn = opts;
              opts = defaultFilterMapOptions;
          }
          const intermediate = filter(opts, filterFn);
          return intermediate(arr);
      }
      filterFn = typeof arr === "function" ? arr : opts;
      opts =
          typeof arr === "function"
              ? defaultFilterMapOptions
              : arr;
      const wrappedFilterFn = (val, index, arr) => Promise.resolve(filterFn(val, index, arr))
          .then(ok => ({ ok, val }));
      return (t) => {
          return map(opts, wrappedFilterFn)(t)
              .then(values => values
              .filter(({ ok }) => ok)
              .map(({ val }) => val));
      };
  }
  exports.filter = filter;
  function map(arr, opts, mapFn) {
      if (Array.isArray(arr)) {
          if (typeof opts === "function") {
              mapFn = opts;
              opts = defaultFilterMapOptions;
          }
          return map(opts, mapFn)(arr);
      }
      mapFn = typeof arr === "function" ? arr : opts;
      opts =
          typeof arr === "function"
              ? defaultFilterMapOptions
              : arr;
      const { concurrency = Infinity } = opts;
      const promiseMapFn = (t, index, arr) => Promise.resolve(mapFn(t, index, arr));
      const throated = throat(concurrency);
      return (t) => {
          return Promise.resolve(t)
              .then((values) => toReadonlyArray(values).map((val, index, arr) => throated(() => Promise.resolve(val))
              .then((val) => throated(() => promiseMapFn(val, index, arr)))))
              .then(values => Promise.all(values));
      };
  }
  exports.map = map;
  function reduce(input, reducer, initialValue) {
      if (typeof input === "function") {
          initialValue = reducer;
          const _reducer = input;
          return async (input) => {
              return reduceImpl(input, _reducer, initialValue);
          };
      }
      return reduceImpl(input, reducer, initialValue);
  }
  exports.reduce = reduce;
  async function reduceImpl(input, reducer, initialValue) {
      const _input = Array.from(await input);
      const _initialValue = await initialValue;
      if (_input.length === 0)
          return _initialValue;
      const usingInitialValue = typeof _initialValue !== "undefined";
      const length = _input.length;
      let index = usingInitialValue ? 0 : 1;
      let accumulator = usingInitialValue
          ? _initialValue
          // This cast should be safe if the interface is respected
          : await _input.shift();
      while (_input.length > 0)
          accumulator = await reducer(accumulator, await _input.shift(), index++, length);
      return accumulator;
  }
  function each(arr, eachFn) {
      if (Array.isArray(arr))
          return eachImpl(eachFn)(arr);
      return eachImpl(arr);
  }
  exports.each = each;
  function eachImpl(eachFn) {
      return async (arr) => {
          const length = arr.length;
          async function iterator(t, index) {
              await eachFn(t, index, length);
              return t;
          }
          return map(arr, { concurrency: 1 }, iterator);
      };
  }
  exports.eachImpl = eachImpl;
  function some(list, fn) {
      if (typeof list === "function") {
          fn = list;
          return (list) => someImpl(list, fn);
      }
      return someImpl(list, fn);
  }
  exports.some = some;
  async function someImpl(list, fn) {
      const _list = toReadonlyArray(await list);
      for (const val of _list) {
          const ret = await fn(await val);
          if (ret)
              return ret;
      }
      return false;
  }
  function once(fn) {
      if (fn) {
          const _once = onceDynamic();
          return () => _once(fn);
      }
      else
          return onceDynamic();
  }
  exports.once = once;
  function onceDynamic() {
      const state = new WeakMap();
      const ensureState = (fn) => {
          if (!state.has(fn))
              state.set(fn, { hasRun: false });
      };
      return (fn) => {
          ensureState(fn);
          const stateObject = state.get(fn);
          if (stateObject.hasRun) {
              if (stateObject.deferred)
                  return stateObject.deferred.promise;
              return stateObject.returnValue;
          }
          stateObject.hasRun = true;
          const ret = fn();
          const pret = ret;
          if (pret !== undefined && pret && typeof pret.then === "function") {
              stateObject.deferred = defer(void 0);
              return pret
                  .then(stateObject.deferred.resolve, rethrow(stateObject.deferred.reject))
                  .then(() => stateObject.deferred.promise);
          }
          stateObject.returnValue = ret;
          return ret;
      };
  }
  function retry(times, fn, retryable = () => true) {
      const retryAsync = (promise) => promise
          .catch((err) => {
          if (--times < 0 || !retryable(err))
              throw err;
          return retryAsync(fn());
      });
      const retrySync = (_err) => {
          while (--times >= 0) {
              try {
                  return fn();
              }
              catch (err) {
                  if (!retryable(err))
                      throw err;
                  _err = err;
              }
          }
          throw _err;
      };
      try {
          const ret = fn();
          if (ret &&
              typeof ret === "object" &&
              typeof ret.then === "function") {
              return retryAsync(ret);
          }
          return ret;
      }
      catch (err) {
          if (!retryable(err))
              throw err;
          return retrySync(err);
      }
  }
  exports.retry = retry;
  function defer() {
      const deferred = {};
      deferred.promise = new Promise((resolve, reject) => {
          deferred.resolve = resolve;
          deferred.reject = reject;
      });
      return deferred;
  }
  exports.defer = defer;
  function reflect(promise) {
      const inspection = inspect(promise);
      function handleResolution(value) {
          return {
              isRejected: false,
              isResolved: true,
              value,
          };
      }
      function handleRejection(error) {
          return {
              error,
              isRejected: true,
              isResolved: false,
          };
      }
      return inspection.promise
          .then(handleResolution, handleRejection);
  }
  exports.reflect = reflect;
  function inspect(promise) {
      const inspectable = {
          isPending: true,
          isRejected: false,
          isResolved: false,
          promise: void 0,
      };
      inspectable.promise = promise.then(value => {
          inspectable.isResolved = true;
          inspectable.isPending = false;
          return value;
      })
          .catch(err => {
          inspectable.isRejected = true;
          inspectable.isPending = false;
          return Promise.reject(err);
      });
      return inspectable;
  }
  exports.inspect = inspect;
  function deferInspectable() {
      const deferred = defer();
      const ret = {
          isPending: true,
          isRejected: false,
          isResolved: false,
          promise: deferred.promise,
          resolve(t) {
              if (!ret.isPending)
                  return;
              deferred.resolve(t);
              ret.isPending = false;
              ret.isRejected = false;
              ret.isResolved = true;
          },
          reject(err) {
              if (!ret.isPending)
                  return;
              deferred.reject(err);
              ret.isPending = false;
              ret.isRejected = true;
              ret.isResolved = false;
          },
      };
      return ret;
  }
  exports.deferInspectable = deferInspectable;
  async function Try(cb) {
      return cb();
  }
  exports.Try = Try;
  // This logic is taken from Bluebird
  function catchFilter(filters, err) {
      return (Array.isArray(filters) ? filters : [filters])
          .some((filter) => {
          if (filter == null)
              return false;
          if (filter === Error ||
              filter.prototype instanceof Error) {
              if (err instanceof filter)
                  return true;
          }
          else if (typeof filter === "function") {
              const filterFn = filter;
              // It is "ok" for this to throw. It'll be thrown back to the catch
              // handler, and the promise chain will contain this error.
              return filterFn(err);
          }
          else if (typeof filter === "object") {
              const obj = filter;
              for (const key of Object.keys(obj))
                  if (obj[key] !== err[key])
                      return false;
              return true;
          }
          return false;
      });
  }
  function specific(filters, handler) {
      return (err) => {
          if (!catchFilter(filters, err))
              throw err;
          return handler(err);
      };
  }
  exports.specific = specific;
  function rethrow(fn) {
      return async (err) => {
          await fn(err);
          throw err;
      };
  }
  exports.rethrow = rethrow;
  function wrapFunction(wrap) {
      // tslint:disable-next-line
      return function (t, cb) {
          if (arguments.length === 1) {
              if (wrap.length > 0)
                  throw new EvalError("Invalid invocation, function requires 2 arguments");
              cb = t;
              t = void 0;
          }
          const anyCleanup = wrap(t);
          const callCleanup = (cleanup) => {
              if (typeof cleanup === "function")
                  return cleanup();
              else if (cleanup != null)
                  // Allow 'before' to just return null/undefined, but non-empty
                  // value would've been silently ignored.
                  throw new EvalError("Invalid return value in 'before' handler");
          };
          if (anyCleanup &&
              typeof anyCleanup.then === "function") {
              let doCleanup;
              return anyCleanup
                  .then(async (cleanup) => {
                  doCleanup = () => callCleanup(cleanup);
                  return cb();
              })
                  .then(...Finally(() => {
                  if (doCleanup)
                      return doCleanup();
              }));
          }
          else {
              const cleanup = anyCleanup;
              let cbRet;
              try {
                  cbRet = cb();
              }
              catch (err) {
                  const cleanupRet = callCleanup(cleanup);
                  if (cleanupRet &&
                      typeof cleanupRet.then === "function") {
                      return cleanupRet
                          .then(() => { throw err; });
                  }
                  else {
                      throw err;
                  }
              }
              if (cbRet && typeof cbRet.then === "function") {
                  return cbRet
                      .then(...Finally(() => callCleanup(cleanup)));
              }
              else {
                  const cleanupRet = callCleanup(cleanup);
                  if (cleanupRet &&
                      typeof cleanupRet.then === "function") {
                      return cleanupRet
                          .then(() => cbRet);
                  }
                  else {
                      return cbRet;
                  }
              }
          }
      };
  }
  exports.wrapFunction = wrapFunction;
  function funnel(opts = {}) {
      const { onComplete = () => { }, fifo = true } = (opts || {});
      const _onComplete = () => onComplete && onComplete();
      const waiters = [];
      const retryers = new WeakMap();
      const stores = new Set();
      const waitFor = (t) => {
          waiters.push(t);
      };
      const hasSiblingFirst = (store) => {
          if (waiters.length === 0)
              return false;
          const firstStoreInCall = store.call[0];
          return waiters[0] === firstStoreInCall;
      };
      const completeStore = (store) => {
          const indexCall = store.call.indexOf(store);
          store.call.splice(indexCall, 1);
          const indexWaiters = waiters.indexOf(store);
          waiters.splice(indexWaiters, 1);
          stores.delete(store);
          return store.call.length === 0;
      };
      const triggerWaiter = () => {
          if (waiters.length === 0 && stores.size === 0)
              _onComplete();
          else {
              const first = waiters[0];
              const nextRetryer = retryers.get(first);
              nextRetryer && nextRetryer();
          }
      };
      const finalizeRetry = (store) => {
          const completed = completeStore(store);
          if (completed)
              triggerWaiter();
      };
      const runner = (fn, call) => {
          const fnDeferred = defer();
          const store = {
              call,
              ret: fnDeferred.promise,
          };
          call.push(store);
          stores.add(store);
          let hasPassedRetry = false;
          let hasFinalized = false;
          const finalize = () => {
              if (hasFinalized)
                  return;
              hasFinalized = true;
              finalizeRetry(store);
          };
          const shouldRetry = () => {
              const firstAndOnly = waiters.length === 0;
              const firstInQueue = hasSiblingFirst(store);
              const result = firstAndOnly || firstInQueue;
              if (result && !fifo)
                  waitFor(store);
              if (result) {
                  hasPassedRetry = true;
                  // If first in queue, schedule waiting for the return promise
                  // to trigger the rest of the queue.
                  store.ret.then(...Finally(finalize));
              }
              return !result;
          };
          const retry = () => {
              const deferred = defer();
              const retryer = () => deferred.resolve(runner(fn, call));
              retryers.set(store, retryer);
              if (!fifo)
                  waitFor(store);
              hasPassedRetry = true;
              // When retrying, when the final result is finally complete, it's
              // always first in queue.
              deferred.promise.then(...Finally(finalize));
              return deferred.promise;
          };
          const shortcut = () => {
              if (hasPassedRetry)
                  finalize();
          };
          if (fifo)
              waitFor(store);
          Try(() => fn(shouldRetry, retry, shortcut))
              .then(fnDeferred.resolve, fnDeferred.reject);
          return store.ret;
      };
      return (fn) => {
          return runner(fn, []);
      };
  }
  exports.funnel = funnel;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 548:
  /***/ (function(module) {
  
  "use strict";
  
  
  const v4 = '(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])(?:\\.(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])){3}';
  
  const v6seg = '[0-9a-fA-F]{1,4}';
  const v6 = `
  (
  (?:${v6seg}:){7}(?:${v6seg}|:)|                                // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
  (?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                         // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
  (?:${v6seg}:){5}(?::${v4}|(:${v6seg}){1,2}|:)|                 // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
  (?:${v6seg}:){4}(?:(:${v6seg}){0,1}:${v4}|(:${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
  (?:${v6seg}:){3}(?:(:${v6seg}){0,2}:${v4}|(:${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
  (?:${v6seg}:){2}(?:(:${v6seg}){0,3}:${v4}|(:${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
  (?:${v6seg}:){1}(?:(:${v6seg}){0,4}:${v4}|(:${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
  (?::((?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))           // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
  )(%[0-9a-zA-Z]{1,})?                                           // %eth0            %1
  `.replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim();
  
  const ip = module.exports = opts => opts && opts.exact ?
  	new RegExp(`(?:^${v4}$)|(?:^${v6}$)`) :
  	new RegExp(`(?:${v4})|(?:${v6})`, 'g');
  
  ip.v4 = opts => opts && opts.exact ? new RegExp(`^${v4}$`) : new RegExp(v4, 'g');
  ip.v6 = opts => opts && opts.exact ? new RegExp(`^${v6}$`) : new RegExp(v6, 'g');
  
  
  /***/ }),
  
  /***/ 551:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = {
    moveSync: __webpack_require__(19)
  }
  
  
  /***/ }),
  
  /***/ 552:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const jsonFile = __webpack_require__(278)
  
  module.exports = {
    // jsonfile exports
    readJson: u(jsonFile.readFile),
    readJsonSync: jsonFile.readFileSync,
    writeJson: u(jsonFile.writeFile),
    writeJsonSync: jsonFile.writeFileSync
  }
  
  
  /***/ }),
  
  /***/ 554:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http2_1 = __webpack_require__(675);
  const callguard_1 = __webpack_require__(382);
  const abort_1 = __webpack_require__(132);
  const fetch_common_1 = __webpack_require__(301);
  const headers_1 = __webpack_require__(191);
  const response_1 = __webpack_require__(973);
  const utils_1 = __webpack_require__(760);
  const { 
  // Responses, these are the same in HTTP/1.1 and HTTP/2
  HTTP2_HEADER_LOCATION: HTTP1_HEADER_LOCATION, HTTP2_HEADER_SET_COOKIE: HTTP1_HEADER_SET_COOKIE, } = http2_1.constants;
  async function fetchImpl(session, input, init = {}, extra) {
      const { cleanup, contentDecoders, endStream, headersToSend, integrity, method, onTrailers, redirect, redirected, request, signal, signalPromise, timeoutAt, timeoutInfo, url, } = await fetch_common_1.setupFetch(session, input, init, extra);
      const { req, cleanup: socketCleanup } = session.get(url);
      const doFetch = async () => {
          for (const [key, value] of Object.entries(headersToSend)) {
              if (value != null)
                  req.setHeader(key, value);
          }
          const response = new Promise((resolve, reject) => {
              const guard = callguard_1.syncGuard(reject, { catchAsync: true });
              req.once("error", reject);
              req.once("aborted", guard(() => {
                  reject(fetch_common_1.makeAbortedError());
              }));
              req.once("continue", guard(() => {
                  reject(fetch_common_1.make100Error());
              }));
              req.once("information", guard((res) => {
                  resolve(new response_1.Response(null, // No body
                  { status: res.statusCode }));
              }));
              req.once("timeout", guard(() => {
                  reject(fetch_common_1.makeTimeoutError());
                  req.abort();
              }));
              req.once("upgrade", guard((_res, _socket, _upgradeHead) => {
                  reject(new Error("Upgrade not implemented!"));
                  req.abort();
              }));
              req.once("response", guard((res) => {
                  res.once("end", socketCleanup);
                  const { signal: bodySignal = void 0, abort: bodyAbort = void 0, } = signal ? new abort_1.AbortController() : {};
                  if (signal) {
                      const abortHandler = () => {
                          bodyAbort();
                          req.abort();
                          res.destroy();
                      };
                      if (signal.aborted) {
                          // No reason to continue, the request is aborted
                          abortHandler();
                          return;
                      }
                      signal.once("abort", abortHandler);
                      res.once("end", () => {
                          signal.removeListener("abort", abortHandler);
                      });
                  }
                  const { headers, statusCode } = res;
                  res.once("end", guard(() => {
                      if (!onTrailers)
                          return;
                      try {
                          const { trailers } = res;
                          const headers = new headers_1.GuardedHeaders("response");
                          Object.keys(trailers).forEach(key => {
                              if (trailers[key] != null)
                                  headers.set(key, "" + trailers[key]);
                          });
                          onTrailers(headers);
                      }
                      catch (err) {
                          // TODO: Implement #8
                          // tslint:disable-next-line
                          console.warn("Trailer handling failed", err);
                      }
                  }));
                  const location = utils_1.parseLocation(headers[HTTP1_HEADER_LOCATION], url);
                  const isRedirected = utils_1.isRedirectStatus["" + statusCode];
                  if (headers[HTTP1_HEADER_SET_COOKIE]) {
                      const setCookies = utils_1.arrayify(headers[HTTP1_HEADER_SET_COOKIE]);
                      session.cookieJar.setCookies(setCookies, url);
                  }
                  if (!input.allowForbiddenHeaders) {
                      delete headers["set-cookie"];
                      delete headers["set-cookie2"];
                  }
                  if (isRedirected && !location)
                      return reject(fetch_common_1.makeIllegalRedirectError());
                  if (!isRedirected || redirect === "manual")
                      return resolve(new response_1.StreamResponse(contentDecoders, url, res, headers, redirect === "manual"
                          ? false
                          : extra.redirected.length > 0, {
                          status: res.statusCode,
                          statusText: res.statusMessage,
                      }, bodySignal, 1, input.allowForbiddenHeaders, integrity));
                  if (redirect === "error")
                      return reject(fetch_common_1.makeRedirectionError(location));
                  // redirect is 'follow'
                  // We don't support re-sending a non-GET/HEAD request (as
                  // we don't want to [can't, if its' streamed] re-send the
                  // body). The concept is fundementally broken anyway...
                  if (!endStream)
                      return reject(fetch_common_1.makeRedirectionMethodError(location, method));
                  if (!location)
                      return reject(fetch_common_1.makeIllegalRedirectError());
                  res.destroy();
                  resolve(fetchImpl(session, request.clone(location), { signal, onTrailers }, {
                      redirected: redirected.concat(url),
                      timeoutAt,
                  }));
              }));
          });
          if (endStream)
              req.end();
          else
              await request.readable()
                  .then(readable => {
                  readable.pipe(req);
              });
          return response;
      };
      return fetch_common_1.handleSignalAndTimeout(signalPromise, timeoutInfo, cleanup, doFetch, socketCleanup);
  }
  exports.fetchImpl = fetchImpl;
  function fetch(session, input, init) {
      const timeoutAt = void 0;
      const extra = { timeoutAt, redirected: [] };
      return fetchImpl(session, input, init, extra);
  }
  exports.fetch = fetch;
  //# sourceMappingURL=fetch-http1.js.map
  
  /***/ }),
  
  /***/ 560:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.isReady = ({ readyState }) => readyState === 'READY';
  exports.isFailed = ({ readyState }) => readyState.endsWith('_ERROR') || readyState === 'ERROR';
  exports.isDone = (buildOrDeployment) => exports.isReady(buildOrDeployment) || exports.isFailed(buildOrDeployment);
  
  
  /***/ }),
  
  /***/ 562:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const u = __webpack_require__(344).fromCallback
  const mkdirs = u(__webpack_require__(55))
  const mkdirsSync = __webpack_require__(798)
  
  module.exports = {
    mkdirs,
    mkdirsSync,
    // alias
    mkdirp: mkdirs,
    mkdirpSync: mkdirsSync,
    ensureDir: mkdirs,
    ensureDirSync: mkdirsSync
  }
  
  
  /***/ }),
  
  /***/ 563:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const path = __webpack_require__(589)
  const fs = __webpack_require__(813)
  const _mkdirs = __webpack_require__(562)
  const mkdirs = _mkdirs.mkdirs
  const mkdirsSync = _mkdirs.mkdirsSync
  
  const _symlinkPaths = __webpack_require__(903)
  const symlinkPaths = _symlinkPaths.symlinkPaths
  const symlinkPathsSync = _symlinkPaths.symlinkPathsSync
  
  const _symlinkType = __webpack_require__(480)
  const symlinkType = _symlinkType.symlinkType
  const symlinkTypeSync = _symlinkType.symlinkTypeSync
  
  const pathExists = __webpack_require__(734).pathExists
  
  function createSymlink (srcpath, dstpath, type, callback) {
    callback = (typeof type === 'function') ? type : callback
    type = (typeof type === 'function') ? false : type
  
    pathExists(dstpath, (err, destinationExists) => {
      if (err) return callback(err)
      if (destinationExists) return callback(null)
      symlinkPaths(srcpath, dstpath, (err, relative) => {
        if (err) return callback(err)
        srcpath = relative.toDst
        symlinkType(relative.toCwd, type, (err, type) => {
          if (err) return callback(err)
          const dir = path.dirname(dstpath)
          pathExists(dir, (err, dirExists) => {
            if (err) return callback(err)
            if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
            mkdirs(dir, err => {
              if (err) return callback(err)
              fs.symlink(srcpath, dstpath, type, callback)
            })
          })
        })
      })
    })
  }
  
  function createSymlinkSync (srcpath, dstpath, type) {
    const destinationExists = fs.existsSync(dstpath)
    if (destinationExists) return undefined
  
    const relative = symlinkPathsSync(srcpath, dstpath)
    srcpath = relative.toDst
    type = symlinkTypeSync(relative.toCwd, type)
    const dir = path.dirname(dstpath)
    const exists = fs.existsSync(dir)
    if (exists) return fs.symlinkSync(srcpath, dstpath, type)
    mkdirsSync(dir)
    return fs.symlinkSync(srcpath, dstpath, type)
  }
  
  module.exports = {
    createSymlink: u(createSymlink),
    createSymlinkSync
  }
  
  
  /***/ }),
  
  /***/ 565:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = __webpack_require__(10);
  
  /***/ }),
  
  /***/ 570:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  class FetchError extends Error {
      constructor(message) {
          super(message);
          Object.setPrototypeOf(this, FetchError.prototype);
      }
  }
  exports.FetchError = FetchError;
  class AbortError extends Error {
      constructor(message) {
          super(message);
          Object.setPrototypeOf(this, AbortError.prototype);
      }
  }
  exports.AbortError = AbortError;
  class TimeoutError extends Error {
      constructor(message) {
          super(message);
          Object.setPrototypeOf(this, TimeoutError.prototype);
      }
  }
  exports.TimeoutError = TimeoutError;
  function getByOrigin(val, origin) {
      return typeof val === "function"
          ? val(origin)
          : val;
  }
  exports.getByOrigin = getByOrigin;
  function parsePerOrigin(val, _default) {
      if (val == null) {
          return _default;
      }
      if (typeof val === "function")
          return (origin) => {
              const ret = val(origin);
              if (ret == null)
                  return _default;
              return ret;
          };
      return val;
  }
  exports.parsePerOrigin = parsePerOrigin;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 571:
  /***/ (function(module) {
  
  "use strict";
  
  /* eslint-disable node/no-deprecated-api */
  module.exports = function (size) {
    if (typeof Buffer.allocUnsafe === 'function') {
      try {
        return Buffer.allocUnsafe(size)
      } catch (e) {
        return new Buffer(size)
      }
    }
    return new Buffer(size)
  }
  
  
  /***/ }),
  
  /***/ 589:
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 592:
  /***/ (function(module, exports, __webpack_require__) {
  
  var Stream = __webpack_require__(688);
  if (process.env.READABLE_STREAM === 'disable' && Stream) {
    module.exports = Stream.Readable;
    Object.assign(module.exports, Stream);
    module.exports.Stream = Stream;
  } else {
    exports = module.exports = __webpack_require__(42);
    exports.Stream = Stream || exports;
    exports.Readable = exports;
    exports.Writable = __webpack_require__(200);
    exports.Duplex = __webpack_require__(404);
    exports.Transform = __webpack_require__(598);
    exports.PassThrough = __webpack_require__(148);
    exports.finished = __webpack_require__(744);
    exports.pipeline = __webpack_require__(861);
  }
  
  
  /***/ }),
  
  /***/ 594:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const path = __webpack_require__(589)
  const fs = __webpack_require__(813)
  const mkdir = __webpack_require__(562)
  const pathExists = __webpack_require__(734).pathExists
  
  function createFile (file, callback) {
    function makeFile () {
      fs.writeFile(file, '', err => {
        if (err) return callback(err)
        callback()
      })
    }
  
    fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err
      if (!err && stats.isFile()) return callback()
      const dir = path.dirname(file)
      pathExists(dir, (err, dirExists) => {
        if (err) return callback(err)
        if (dirExists) return makeFile()
        mkdir.mkdirs(dir, err => {
          if (err) return callback(err)
          makeFile()
        })
      })
    })
  }
  
  function createFileSync (file) {
    let stats
    try {
      stats = fs.statSync(file)
    } catch (e) {}
    if (stats && stats.isFile()) return
  
    const dir = path.dirname(file)
    if (!fs.existsSync(dir)) {
      mkdir.mkdirsSync(dir)
    }
  
    fs.writeFileSync(file, '')
  }
  
  module.exports = {
    createFile: u(createFile),
    createFileSync
  }
  
  
  /***/ }),
  
  /***/ 597:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var Stream = __webpack_require__(688).Stream
  
  module.exports = legacy
  
  function legacy (fs) {
    return {
      ReadStream: ReadStream,
      WriteStream: WriteStream
    }
  
    function ReadStream (path, options) {
      if (!(this instanceof ReadStream)) return new ReadStream(path, options);
  
      Stream.call(this);
  
      var self = this;
  
      this.path = path;
      this.fd = null;
      this.readable = true;
      this.paused = false;
  
      this.flags = 'r';
      this.mode = 438; /*=0666*/
      this.bufferSize = 64 * 1024;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.encoding) this.setEncoding(this.encoding);
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.end === undefined) {
          this.end = Infinity;
        } else if ('number' !== typeof this.end) {
          throw TypeError('end must be a Number');
        }
  
        if (this.start > this.end) {
          throw new Error('start must be <= end');
        }
  
        this.pos = this.start;
      }
  
      if (this.fd !== null) {
        process.nextTick(function() {
          self._read();
        });
        return;
      }
  
      fs.open(this.path, this.flags, this.mode, function (err, fd) {
        if (err) {
          self.emit('error', err);
          self.readable = false;
          return;
        }
  
        self.fd = fd;
        self.emit('open', fd);
        self._read();
      })
    }
  
    function WriteStream (path, options) {
      if (!(this instanceof WriteStream)) return new WriteStream(path, options);
  
      Stream.call(this);
  
      this.path = path;
      this.fd = null;
      this.writable = true;
  
      this.flags = 'w';
      this.encoding = 'binary';
      this.mode = 438; /*=0666*/
      this.bytesWritten = 0;
  
      options = options || {};
  
      // Mixin options into this
      var keys = Object.keys(options);
      for (var index = 0, length = keys.length; index < length; index++) {
        var key = keys[index];
        this[key] = options[key];
      }
  
      if (this.start !== undefined) {
        if ('number' !== typeof this.start) {
          throw TypeError('start must be a Number');
        }
        if (this.start < 0) {
          throw new Error('start must be >= zero');
        }
  
        this.pos = this.start;
      }
  
      this.busy = false;
      this._queue = [];
  
      if (this.fd === null) {
        this._open = fs.open;
        this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
        this.flush();
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 598:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  // a transform stream is a readable/writable stream where you do
  // something with the data.  Sometimes it's called a "filter",
  // but that's not a great name for it, since that implies a thing where
  // some bits pass through, and others are simply ignored.  (That would
  // be a valid example of a transform, of course.)
  //
  // While the output is causally related to the input, it's not a
  // necessarily symmetric or synchronous transformation.  For example,
  // a zlib stream might take multiple plain-text writes(), and then
  // emit a single compressed chunk some time in the future.
  //
  // Here's how this works:
  //
  // The Transform stream has all the aspects of the readable and writable
  // stream classes.  When you write(chunk), that calls _write(chunk,cb)
  // internally, and returns false if there's a lot of pending writes
  // buffered up.  When you call read(), that calls _read(n) until
  // there's enough pending readable data buffered up.
  //
  // In a transform stream, the written data is placed in a buffer.  When
  // _read(n) is called, it transforms the queued up data, calling the
  // buffered _write cb's as it consumes chunks.  If consuming a single
  // written chunk would result in multiple output chunks, then the first
  // outputted bit calls the readcb, and subsequent chunks just go into
  // the read buffer, and will cause it to emit 'readable' if necessary.
  //
  // This way, back-pressure is actually determined by the reading side,
  // since _read has to be called to start processing a new chunk.  However,
  // a pathological inflate type of transform can cause excessive buffering
  // here.  For example, imagine a stream where every byte of input is
  // interpreted as an integer from 0-255, and then results in that many
  // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
  // 1kb of data being output.  In this case, you could write a very small
  // amount of input, and end up with a very large amount of output.  In
  // such a pathological inflating mechanism, there'd be no way to tell
  // the system to stop doing the transform.  A single 4MB write could
  // cause the system to run out of memory.
  //
  // However, even in such a pathological case, only a single written chunk
  // would be consumed, and then the rest would wait (un-transformed) until
  // the results of the previous transformed chunk were consumed.
  
  
  module.exports = Transform;
  
  var _require$codes = __webpack_require__(854).codes,
      ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
      ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
      ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
      ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
  
  var Duplex = __webpack_require__(404);
  
  __webpack_require__(207)(Transform, Duplex);
  
  function afterTransform(er, data) {
    var ts = this._transformState;
    ts.transforming = false;
    var cb = ts.writecb;
  
    if (cb === null) {
      return this.emit('error', new ERR_MULTIPLE_CALLBACK());
    }
  
    ts.writechunk = null;
    ts.writecb = null;
    if (data != null) // single equals check for both `null` and `undefined`
      this.push(data);
    cb(er);
    var rs = this._readableState;
    rs.reading = false;
  
    if (rs.needReadable || rs.length < rs.highWaterMark) {
      this._read(rs.highWaterMark);
    }
  }
  
  function Transform(options) {
    if (!(this instanceof Transform)) return new Transform(options);
    Duplex.call(this, options);
    this._transformState = {
      afterTransform: afterTransform.bind(this),
      needTransform: false,
      transforming: false,
      writecb: null,
      writechunk: null,
      writeencoding: null
    }; // start out asking for a readable event once data is transformed.
  
    this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
    // that Readable wants before the first _read call, so unset the
    // sync guard flag.
  
    this._readableState.sync = false;
  
    if (options) {
      if (typeof options.transform === 'function') this._transform = options.transform;
      if (typeof options.flush === 'function') this._flush = options.flush;
    } // When the writable side finishes, then flush out anything remaining.
  
  
    this.on('prefinish', prefinish);
  }
  
  function prefinish() {
    var _this = this;
  
    if (typeof this._flush === 'function' && !this._readableState.destroyed) {
      this._flush(function (er, data) {
        done(_this, er, data);
      });
    } else {
      done(this, null, null);
    }
  }
  
  Transform.prototype.push = function (chunk, encoding) {
    this._transformState.needTransform = false;
    return Duplex.prototype.push.call(this, chunk, encoding);
  }; // This is the part where you do stuff!
  // override this function in implementation classes.
  // 'chunk' is an input chunk.
  //
  // Call `push(newChunk)` to pass along transformed output
  // to the readable side.  You may call 'push' zero or more times.
  //
  // Call `cb(err)` when you are done with this chunk.  If you pass
  // an error, then that'll put the hurt on the whole operation.  If you
  // never call cb(), then you'll never get another chunk.
  
  
  Transform.prototype._transform = function (chunk, encoding, cb) {
    cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
  };
  
  Transform.prototype._write = function (chunk, encoding, cb) {
    var ts = this._transformState;
    ts.writecb = cb;
    ts.writechunk = chunk;
    ts.writeencoding = encoding;
  
    if (!ts.transforming) {
      var rs = this._readableState;
      if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
    }
  }; // Doesn't matter what the args are here.
  // _transform does all the work.
  // That we got here means that the readable side wants more data.
  
  
  Transform.prototype._read = function (n) {
    var ts = this._transformState;
  
    if (ts.writechunk !== null && !ts.transforming) {
      ts.transforming = true;
  
      this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
    } else {
      // mark that we need a transform, so that any data that comes in
      // will get processed, now that we've asked for it.
      ts.needTransform = true;
    }
  };
  
  Transform.prototype._destroy = function (err, cb) {
    Duplex.prototype._destroy.call(this, err, function (err2) {
      cb(err2);
    });
  };
  
  function done(stream, er, data) {
    if (er) return stream.emit('error', er);
    if (data != null) // single equals check for both `null` and `undefined`
      stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
    // if there's nothing in the write buffer, then that means
    // that nothing more will ever be provided
  
    if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
    if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
    return stream.push(null);
  }
  
  /***/ }),
  
  /***/ 604:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const abort_1 = __webpack_require__(132);
  exports.AbortController = abort_1.AbortController;
  const body_1 = __webpack_require__(452);
  exports.Body = body_1.Body;
  exports.DataBody = body_1.DataBody;
  exports.JsonBody = body_1.JsonBody;
  exports.StreamBody = body_1.StreamBody;
  const context_1 = __webpack_require__(360);
  const cookie_jar_1 = __webpack_require__(837);
  exports.CookieJar = cookie_jar_1.CookieJar;
  const core_1 = __webpack_require__(570);
  exports.AbortError = core_1.AbortError;
  exports.TimeoutError = core_1.TimeoutError;
  const headers_1 = __webpack_require__(191);
  exports.Headers = headers_1.Headers;
  const request_1 = __webpack_require__(673);
  exports.Request = request_1.Request;
  const response_1 = __webpack_require__(973);
  exports.Response = response_1.Response;
  const defaultContext = new context_1.Context();
  const setup = (opts) => defaultContext.setup(opts);
  exports.setup = setup;
  const fetch = (input, init) => defaultContext.fetch(input, init);
  exports.fetch = fetch;
  const disconnect = (url) => defaultContext.disconnect(url);
  exports.disconnect = disconnect;
  const disconnectAll = () => defaultContext.disconnectAll();
  exports.disconnectAll = disconnectAll;
  const onPush = (handler) => defaultContext.onPush(handler);
  exports.onPush = onPush;
  function context(opts) {
      const ctx = new context_1.Context(opts);
      return {
          disconnect: ctx.disconnect.bind(ctx),
          disconnectAll: ctx.disconnectAll.bind(ctx),
          fetch: ctx.fetch.bind(ctx),
          onPush: ctx.onPush.bind(ctx),
          setup: ctx.setup.bind(ctx),
      };
  }
  exports.context = context;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 610:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  class DeploymentError extends Error {
      constructor(err) {
          super(err.message);
          this.code = err.code;
          this.name = 'DeploymentError';
      }
  }
  exports.DeploymentError = DeploymentError;
  
  
  /***/ }),
  
  /***/ 620:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = minimatch
  minimatch.Minimatch = Minimatch
  
  var path = { sep: '/' }
  try {
    path = __webpack_require__(589)
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
  var expand = __webpack_require__(348)
  
  var plTypes = {
    '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
    '?': { open: '(?:', close: ')?' },
    '+': { open: '(?:', close: ')+' },
    '*': { open: '(?:', close: ')*' },
    '@': { open: '(?:', close: ')' }
  }
  
  // any single thing other than /
  // don't need to escape / when using new RegExp()
  var qmark = '[^/]'
  
  // * => any number of characters
  var star = qmark + '*?'
  
  // ** when dots are allowed.  Anything goes, except .. and .
  // not (^ or / followed by one or two dots followed by $ or /),
  // followed by anything, any number of times.
  var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
  
  // not a ^ or / followed by a dot,
  // followed by anything, any number of times.
  var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
  
  // characters that need to be escaped in RegExp.
  var reSpecials = charSet('().*{}+?[]^$\\!')
  
  // "abc" -> { a:true, b:true, c:true }
  function charSet (s) {
    return s.split('').reduce(function (set, c) {
      set[c] = true
      return set
    }, {})
  }
  
  // normalizes slashes.
  var slashSplit = /\/+/
  
  minimatch.filter = filter
  function filter (pattern, options) {
    options = options || {}
    return function (p, i, list) {
      return minimatch(p, pattern, options)
    }
  }
  
  function ext (a, b) {
    a = a || {}
    b = b || {}
    var t = {}
    Object.keys(b).forEach(function (k) {
      t[k] = b[k]
    })
    Object.keys(a).forEach(function (k) {
      t[k] = a[k]
    })
    return t
  }
  
  minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return minimatch
  
    var orig = minimatch
  
    var m = function minimatch (p, pattern, options) {
      return orig.minimatch(p, pattern, ext(def, options))
    }
  
    m.Minimatch = function Minimatch (pattern, options) {
      return new orig.Minimatch(pattern, ext(def, options))
    }
  
    return m
  }
  
  Minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return Minimatch
    return minimatch.defaults(def).Minimatch
  }
  
  function minimatch (p, pattern, options) {
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
  
    // shortcut: comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      return false
    }
  
    // "" only matches ""
    if (pattern.trim() === '') return p === ''
  
    return new Minimatch(pattern, options).match(p)
  }
  
  function Minimatch (pattern, options) {
    if (!(this instanceof Minimatch)) {
      return new Minimatch(pattern, options)
    }
  
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
    pattern = pattern.trim()
  
    // windows support: need to use /, not \
    if (path.sep !== '/') {
      pattern = pattern.split(path.sep).join('/')
    }
  
    this.options = options
    this.set = []
    this.pattern = pattern
    this.regexp = null
    this.negate = false
    this.comment = false
    this.empty = false
  
    // make the set of regexps etc.
    this.make()
  }
  
  Minimatch.prototype.debug = function () {}
  
  Minimatch.prototype.make = make
  function make () {
    // don't do it more than once.
    if (this._made) return
  
    var pattern = this.pattern
    var options = this.options
  
    // empty patterns and comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      this.comment = true
      return
    }
    if (!pattern) {
      this.empty = true
      return
    }
  
    // step 1: figure out negation, etc.
    this.parseNegate()
  
    // step 2: expand braces
    var set = this.globSet = this.braceExpand()
  
    if (options.debug) this.debug = console.error
  
    this.debug(this.pattern, set)
  
    // step 3: now we have a set, so turn each one into a series of path-portion
    // matching patterns.
    // These will be regexps, except in the case of "**", which is
    // set to the GLOBSTAR object for globstar behavior,
    // and will not contain any / characters
    set = this.globParts = set.map(function (s) {
      return s.split(slashSplit)
    })
  
    this.debug(this.pattern, set)
  
    // glob --> regexps
    set = set.map(function (s, si, set) {
      return s.map(this.parse, this)
    }, this)
  
    this.debug(this.pattern, set)
  
    // filter out everything that didn't compile properly.
    set = set.filter(function (s) {
      return s.indexOf(false) === -1
    })
  
    this.debug(this.pattern, set)
  
    this.set = set
  }
  
  Minimatch.prototype.parseNegate = parseNegate
  function parseNegate () {
    var pattern = this.pattern
    var negate = false
    var options = this.options
    var negateOffset = 0
  
    if (options.nonegate) return
  
    for (var i = 0, l = pattern.length
      ; i < l && pattern.charAt(i) === '!'
      ; i++) {
      negate = !negate
      negateOffset++
    }
  
    if (negateOffset) this.pattern = pattern.substr(negateOffset)
    this.negate = negate
  }
  
  // Brace expansion:
  // a{b,c}d -> abd acd
  // a{b,}c -> abc ac
  // a{0..3}d -> a0d a1d a2d a3d
  // a{b,c{d,e}f}g -> abg acdfg acefg
  // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
  //
  // Invalid sets are not expanded.
  // a{2..}b -> a{2..}b
  // a{b}c -> a{b}c
  minimatch.braceExpand = function (pattern, options) {
    return braceExpand(pattern, options)
  }
  
  Minimatch.prototype.braceExpand = braceExpand
  
  function braceExpand (pattern, options) {
    if (!options) {
      if (this instanceof Minimatch) {
        options = this.options
      } else {
        options = {}
      }
    }
  
    pattern = typeof pattern === 'undefined'
      ? this.pattern : pattern
  
    if (typeof pattern === 'undefined') {
      throw new TypeError('undefined pattern')
    }
  
    if (options.nobrace ||
      !pattern.match(/\{.*\}/)) {
      // shortcut. no need to expand.
      return [pattern]
    }
  
    return expand(pattern)
  }
  
  // parse a component of the expanded set.
  // At this point, no pattern may contain "/" in it
  // so we're going to return a 2d array, where each entry is the full
  // pattern, split on '/', and then turned into a regular expression.
  // A regexp is made at the end which joins each array with an
  // escaped /, and another full one which joins each regexp with |.
  //
  // Following the lead of Bash 4.1, note that "**" only has special meaning
  // when it is the *only* thing in a path portion.  Otherwise, any series
  // of * is equivalent to a single *.  Globstar behavior is enabled by
  // default, and can be disabled by setting options.noglobstar.
  Minimatch.prototype.parse = parse
  var SUBPARSE = {}
  function parse (pattern, isSub) {
    if (pattern.length > 1024 * 64) {
      throw new TypeError('pattern is too long')
    }
  
    var options = this.options
  
    // shortcuts
    if (!options.noglobstar && pattern === '**') return GLOBSTAR
    if (pattern === '') return ''
  
    var re = ''
    var hasMagic = !!options.nocase
    var escaping = false
    // ? => one single character
    var patternListStack = []
    var negativeLists = []
    var stateChar
    var inClass = false
    var reClassStart = -1
    var classStart = -1
    // . and .. never match anything that doesn't start with .,
    // even when options.dot is set.
    var patternStart = pattern.charAt(0) === '.' ? '' // anything
    // not (start or / followed by . or .. followed by / or end)
    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
    : '(?!\\.)'
    var self = this
  
    function clearStateChar () {
      if (stateChar) {
        // we had some state-tracking character
        // that wasn't consumed by this pass.
        switch (stateChar) {
          case '*':
            re += star
            hasMagic = true
          break
          case '?':
            re += qmark
            hasMagic = true
          break
          default:
            re += '\\' + stateChar
          break
        }
        self.debug('clearStateChar %j %j', stateChar, re)
        stateChar = false
      }
    }
  
    for (var i = 0, len = pattern.length, c
      ; (i < len) && (c = pattern.charAt(i))
      ; i++) {
      this.debug('%s\t%s %s %j', pattern, i, re, c)
  
      // skip over any that are escaped.
      if (escaping && reSpecials[c]) {
        re += '\\' + c
        escaping = false
        continue
      }
  
      switch (c) {
        case '/':
          // completely not allowed, even escaped.
          // Should already be path-split by now.
          return false
  
        case '\\':
          clearStateChar()
          escaping = true
        continue
  
        // the various stateChar values
        // for the "extglob" stuff.
        case '?':
        case '*':
        case '+':
        case '@':
        case '!':
          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
  
          // all of those are literals inside a class, except that
          // the glob [!a] means [^a] in regexp
          if (inClass) {
            this.debug('  in class')
            if (c === '!' && i === classStart + 1) c = '^'
            re += c
            continue
          }
  
          // if we already have a stateChar, then it means
          // that there was something like ** or +? in there.
          // Handle the stateChar, then proceed with this one.
          self.debug('call clearStateChar %j', stateChar)
          clearStateChar()
          stateChar = c
          // if extglob is disabled, then +(asdf|foo) isn't a thing.
          // just clear the statechar *now*, rather than even diving into
          // the patternList stuff.
          if (options.noext) clearStateChar()
        continue
  
        case '(':
          if (inClass) {
            re += '('
            continue
          }
  
          if (!stateChar) {
            re += '\\('
            continue
          }
  
          patternListStack.push({
            type: stateChar,
            start: i - 1,
            reStart: re.length,
            open: plTypes[stateChar].open,
            close: plTypes[stateChar].close
          })
          // negation is (?:(?!js)[^/]*)
          re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
          this.debug('plType %j %j', stateChar, re)
          stateChar = false
        continue
  
        case ')':
          if (inClass || !patternListStack.length) {
            re += '\\)'
            continue
          }
  
          clearStateChar()
          hasMagic = true
          var pl = patternListStack.pop()
          // negation is (?:(?!js)[^/]*)
          // The others are (?:<pattern>)<type>
          re += pl.close
          if (pl.type === '!') {
            negativeLists.push(pl)
          }
          pl.reEnd = re.length
        continue
  
        case '|':
          if (inClass || !patternListStack.length || escaping) {
            re += '\\|'
            escaping = false
            continue
          }
  
          clearStateChar()
          re += '|'
        continue
  
        // these are mostly the same in regexp and glob
        case '[':
          // swallow any state-tracking char before the [
          clearStateChar()
  
          if (inClass) {
            re += '\\' + c
            continue
          }
  
          inClass = true
          classStart = i
          reClassStart = re.length
          re += c
        continue
  
        case ']':
          //  a right bracket shall lose its special
          //  meaning and represent itself in
          //  a bracket expression if it occurs
          //  first in the list.  -- POSIX.2 2.8.3.2
          if (i === classStart + 1 || !inClass) {
            re += '\\' + c
            escaping = false
            continue
          }
  
          // handle the case where we left a class open.
          // "[z-a]" is valid, equivalent to "\[z-a\]"
          if (inClass) {
            // split where the last [ was, make sure we don't have
            // an invalid re. if so, re-walk the contents of the
            // would-be class to re-translate any characters that
            // were passed through as-is
            // TODO: It would probably be faster to determine this
            // without a try/catch and a new RegExp, but it's tricky
            // to do safely.  For now, this is safe and works.
            var cs = pattern.substring(classStart + 1, i)
            try {
              RegExp('[' + cs + ']')
            } catch (er) {
              // not a valid class!
              var sp = this.parse(cs, SUBPARSE)
              re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
              hasMagic = hasMagic || sp[1]
              inClass = false
              continue
            }
          }
  
          // finish up the class.
          hasMagic = true
          inClass = false
          re += c
        continue
  
        default:
          // swallow any state char that wasn't consumed
          clearStateChar()
  
          if (escaping) {
            // no need
            escaping = false
          } else if (reSpecials[c]
            && !(c === '^' && inClass)) {
            re += '\\'
          }
  
          re += c
  
      } // switch
    } // for
  
    // handle the case where we left a class open.
    // "[abc" is valid, equivalent to "\[abc"
    if (inClass) {
      // split where the last [ was, and escape it
      // this is a huge pita.  We now have to re-walk
      // the contents of the would-be class to re-translate
      // any characters that were passed through as-is
      cs = pattern.substr(classStart + 1)
      sp = this.parse(cs, SUBPARSE)
      re = re.substr(0, reClassStart) + '\\[' + sp[0]
      hasMagic = hasMagic || sp[1]
    }
  
    // handle the case where we had a +( thing at the *end*
    // of the pattern.
    // each pattern list stack adds 3 chars, and we need to go through
    // and escape any | chars that were passed through as-is for the regexp.
    // Go through and escape them, taking care not to double-escape any
    // | chars that were already escaped.
    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
      var tail = re.slice(pl.reStart + pl.open.length)
      this.debug('setting tail', re, pl)
      // maybe some even number of \, then maybe 1 \, followed by a |
      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
        if (!$2) {
          // the | isn't already escaped, so escape it.
          $2 = '\\'
        }
  
        // need to escape all those slashes *again*, without escaping the
        // one that we need for escaping the | character.  As it works out,
        // escaping an even number of slashes can be done by simply repeating
        // it exactly after itself.  That's why this trick works.
        //
        // I am sorry that you have to see this.
        return $1 + $1 + $2 + '|'
      })
  
      this.debug('tail=%j\n   %s', tail, tail, pl, re)
      var t = pl.type === '*' ? star
        : pl.type === '?' ? qmark
        : '\\' + pl.type
  
      hasMagic = true
      re = re.slice(0, pl.reStart) + t + '\\(' + tail
    }
  
    // handle trailing things that only matter at the very end.
    clearStateChar()
    if (escaping) {
      // trailing \\
      re += '\\\\'
    }
  
    // only need to apply the nodot start if the re starts with
    // something that could conceivably capture a dot
    var addPatternStart = false
    switch (re.charAt(0)) {
      case '.':
      case '[':
      case '(': addPatternStart = true
    }
  
    // Hack to work around lack of negative lookbehind in JS
    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
    // like 'a.xyz.yz' doesn't match.  So, the first negative
    // lookahead, has to look ALL the way ahead, to the end of
    // the pattern.
    for (var n = negativeLists.length - 1; n > -1; n--) {
      var nl = negativeLists[n]
  
      var nlBefore = re.slice(0, nl.reStart)
      var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
      var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
      var nlAfter = re.slice(nl.reEnd)
  
      nlLast += nlAfter
  
      // Handle nested stuff like *(*.js|!(*.json)), where open parens
      // mean that we should *not* include the ) in the bit that is considered
      // "after" the negated section.
      var openParensBefore = nlBefore.split('(').length - 1
      var cleanAfter = nlAfter
      for (i = 0; i < openParensBefore; i++) {
        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
      }
      nlAfter = cleanAfter
  
      var dollar = ''
      if (nlAfter === '' && isSub !== SUBPARSE) {
        dollar = '$'
      }
      var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
      re = newRe
    }
  
    // if the re is not "" at this point, then we need to make sure
    // it doesn't match against an empty path part.
    // Otherwise a/* will match a/, which it should not.
    if (re !== '' && hasMagic) {
      re = '(?=.)' + re
    }
  
    if (addPatternStart) {
      re = patternStart + re
    }
  
    // parsing just a piece of a larger pattern.
    if (isSub === SUBPARSE) {
      return [re, hasMagic]
    }
  
    // skip the regexp for non-magical patterns
    // unescape anything in it, though, so that it'll be
    // an exact match against a file etc.
    if (!hasMagic) {
      return globUnescape(pattern)
    }
  
    var flags = options.nocase ? 'i' : ''
    try {
      var regExp = new RegExp('^' + re + '$', flags)
    } catch (er) {
      // If it was an invalid regular expression, then it can't match
      // anything.  This trick looks for a character after the end of
      // the string, which is of course impossible, except in multi-line
      // mode, but it's not a /m regex.
      return new RegExp('$.')
    }
  
    regExp._glob = pattern
    regExp._src = re
  
    return regExp
  }
  
  minimatch.makeRe = function (pattern, options) {
    return new Minimatch(pattern, options || {}).makeRe()
  }
  
  Minimatch.prototype.makeRe = makeRe
  function makeRe () {
    if (this.regexp || this.regexp === false) return this.regexp
  
    // at this point, this.set is a 2d array of partial
    // pattern strings, or "**".
    //
    // It's better to use .match().  This function shouldn't
    // be used, really, but it's pretty convenient sometimes,
    // when you just want to work with a regex.
    var set = this.set
  
    if (!set.length) {
      this.regexp = false
      return this.regexp
    }
    var options = this.options
  
    var twoStar = options.noglobstar ? star
      : options.dot ? twoStarDot
      : twoStarNoDot
    var flags = options.nocase ? 'i' : ''
  
    var re = set.map(function (pattern) {
      return pattern.map(function (p) {
        return (p === GLOBSTAR) ? twoStar
        : (typeof p === 'string') ? regExpEscape(p)
        : p._src
      }).join('\\\/')
    }).join('|')
  
    // must match entire pattern
    // ending in a * or ** will make it less strict.
    re = '^(?:' + re + ')$'
  
    // can match anything, as long as it's not this.
    if (this.negate) re = '^(?!' + re + ').*$'
  
    try {
      this.regexp = new RegExp(re, flags)
    } catch (ex) {
      this.regexp = false
    }
    return this.regexp
  }
  
  minimatch.match = function (list, pattern, options) {
    options = options || {}
    var mm = new Minimatch(pattern, options)
    list = list.filter(function (f) {
      return mm.match(f)
    })
    if (mm.options.nonull && !list.length) {
      list.push(pattern)
    }
    return list
  }
  
  Minimatch.prototype.match = match
  function match (f, partial) {
    this.debug('match', f, this.pattern)
    // short-circuit in the case of busted things.
    // comments, etc.
    if (this.comment) return false
    if (this.empty) return f === ''
  
    if (f === '/' && partial) return true
  
    var options = this.options
  
    // windows: need to use /, not \
    if (path.sep !== '/') {
      f = f.split(path.sep).join('/')
    }
  
    // treat the test path as a set of pathparts.
    f = f.split(slashSplit)
    this.debug(this.pattern, 'split', f)
  
    // just ONE of the pattern sets in this.set needs to match
    // in order for it to be valid.  If negating, then just one
    // match means that we have failed.
    // Either way, return on the first hit.
  
    var set = this.set
    this.debug(this.pattern, 'set', set)
  
    // Find the basename of the path by looking for the last non-empty segment
    var filename
    var i
    for (i = f.length - 1; i >= 0; i--) {
      filename = f[i]
      if (filename) break
    }
  
    for (i = 0; i < set.length; i++) {
      var pattern = set[i]
      var file = f
      if (options.matchBase && pattern.length === 1) {
        file = [filename]
      }
      var hit = this.matchOne(file, pattern, partial)
      if (hit) {
        if (options.flipNegate) return true
        return !this.negate
      }
    }
  
    // didn't get any hits.  this is success if it's a negative
    // pattern, failure otherwise.
    if (options.flipNegate) return false
    return this.negate
  }
  
  // set partial to true to test if, for example,
  // "/a/b" matches the start of "/*/b/*/d"
  // Partial means, if you run out of file before you run
  // out of pattern, then that's fine, as long as all
  // the parts match.
  Minimatch.prototype.matchOne = function (file, pattern, partial) {
    var options = this.options
  
    this.debug('matchOne',
      { 'this': this, file: file, pattern: pattern })
  
    this.debug('matchOne', file.length, pattern.length)
  
    for (var fi = 0,
        pi = 0,
        fl = file.length,
        pl = pattern.length
        ; (fi < fl) && (pi < pl)
        ; fi++, pi++) {
      this.debug('matchOne loop')
      var p = pattern[pi]
      var f = file[fi]
  
      this.debug(pattern, p, f)
  
      // should be impossible.
      // some invalid regexp stuff in the set.
      if (p === false) return false
  
      if (p === GLOBSTAR) {
        this.debug('GLOBSTAR', [pattern, p, f])
  
        // "**"
        // a/**/b/**/c would match the following:
        // a/b/x/y/z/c
        // a/x/y/z/b/c
        // a/b/x/b/x/c
        // a/b/c
        // To do this, take the rest of the pattern after
        // the **, and see if it would match the file remainder.
        // If so, return success.
        // If not, the ** "swallows" a segment, and try again.
        // This is recursively awful.
        //
        // a/**/b/**/c matching a/b/x/y/z/c
        // - a matches a
        // - doublestar
        //   - matchOne(b/x/y/z/c, b/**/c)
        //     - b matches b
        //     - doublestar
        //       - matchOne(x/y/z/c, c) -> no
        //       - matchOne(y/z/c, c) -> no
        //       - matchOne(z/c, c) -> no
        //       - matchOne(c, c) yes, hit
        var fr = fi
        var pr = pi + 1
        if (pr === pl) {
          this.debug('** at the end')
          // a ** at the end will just swallow the rest.
          // We have found a match.
          // however, it will not swallow /.x, unless
          // options.dot is set.
          // . and .. are *never* matched by **, for explosively
          // exponential reasons.
          for (; fi < fl; fi++) {
            if (file[fi] === '.' || file[fi] === '..' ||
              (!options.dot && file[fi].charAt(0) === '.')) return false
          }
          return true
        }
  
        // ok, let's see if we can swallow whatever we can.
        while (fr < fl) {
          var swallowee = file[fr]
  
          this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
  
          // XXX remove this slice.  Just pass the start index.
          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
            this.debug('globstar found match!', fr, fl, swallowee)
            // found a match.
            return true
          } else {
            // can't swallow "." or ".." ever.
            // can only swallow ".foo" when explicitly asked.
            if (swallowee === '.' || swallowee === '..' ||
              (!options.dot && swallowee.charAt(0) === '.')) {
              this.debug('dot detected!', file, fr, pattern, pr)
              break
            }
  
            // ** swallows a segment, and continue.
            this.debug('globstar swallow a segment, and continue')
            fr++
          }
        }
  
        // no match was found.
        // However, in partial mode, we can't say this is necessarily over.
        // If there's more *pattern* left, then
        if (partial) {
          // ran out of file
          this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
          if (fr === fl) return true
        }
        return false
      }
  
      // something other than **
      // non-magic patterns just have to match exactly
      // patterns with magic have been turned into regexps.
      var hit
      if (typeof p === 'string') {
        if (options.nocase) {
          hit = f.toLowerCase() === p.toLowerCase()
        } else {
          hit = f === p
        }
        this.debug('string match', p, f, hit)
      } else {
        hit = f.match(p)
        this.debug('pattern match', p, f, hit)
      }
  
      if (!hit) return false
    }
  
    // Note: ending in / means that we'll get a final ""
    // at the end of the pattern.  This can only match a
    // corresponding "" at the end of the file.
    // If the file ends in /, then it can only match a
    // a pattern that ends in /, unless the pattern just
    // doesn't have any more for it. But, a/b/ should *not*
    // match "a/b/*", even though "" matches against the
    // [^/]*? pattern, except in partial mode, where it might
    // simply not be reached yet.
    // However, a/b/ should still satisfy a/*
  
    // now either we fell off the end of the pattern, or we're done.
    if (fi === fl && pi === pl) {
      // ran out of pattern and filename at the same time.
      // an exact hit!
      return true
    } else if (fi === fl) {
      // ran out of file, but still had pattern left.
      // this is ok if we're doing the match as part of
      // a glob fs traversal.
      return partial
    } else if (pi === pl) {
      // ran out of pattern, still have file left.
      // this is only acceptable if we're on the very last
      // empty segment of a file with a trailing slash.
      // a/* should match a/b/
      var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
      return emptyFileEnd
    }
  
    // should be unreachable.
    throw new Error('wtf?')
  }
  
  // replace stuff like \* with *
  function globUnescape (s) {
    return s.replace(/\\(.)/g, '$1')
  }
  
  function regExpEscape (s) {
    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
  }
  
  
  /***/ }),
  
  /***/ 647:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
  var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const sleep_promise_1 = __importDefault(__webpack_require__(877));
  const ms_1 = __importDefault(__webpack_require__(86));
  const utils_1 = __webpack_require__(512);
  const ready_state_1 = __webpack_require__(560);
  /* eslint-disable */
  function checkDeploymentStatus(deployment, token, version, teamId) {
      return __asyncGenerator(this, arguments, function* checkDeploymentStatus_1() {
          let deploymentState = deployment;
          let allBuildsCompleted = false;
          const buildsState = {};
          let apiDeployments = version === 2 ? utils_1.API_DEPLOYMENTS : utils_1.API_DEPLOYMENTS_LEGACY;
          // If the deployment is ready, we don't want any of this to run
          if (ready_state_1.isDone(deploymentState)) {
              return yield __await(void 0);
          }
          // Build polling
          while (true) {
              if (!allBuildsCompleted) {
                  const buildsData = yield __await(utils_1.fetch(`${apiDeployments}/${deployment.id}/builds${teamId ? `?teamId=${teamId}` : ''}`, token));
                  const data = yield __await(buildsData.json());
                  const { builds = [] } = data;
                  for (const build of builds) {
                      const prevState = buildsState[build.id];
                      if (!prevState || prevState.readyState !== build.readyState) {
                          yield yield __await({ type: 'build-state-changed', payload: build });
                      }
                      if (build.readyState.includes('ERROR')) {
                          return yield __await(yield yield __await({ type: 'error', payload: build }));
                      }
                      buildsState[build.id] = build;
                  }
                  const readyBuilds = builds.filter((b) => ready_state_1.isDone(b));
                  if (readyBuilds.length === builds.length) {
                      allBuildsCompleted = true;
                      yield yield __await({ type: 'all-builds-completed', payload: readyBuilds });
                  }
              }
              else {
                  // Deployment polling
                  const deploymentData = yield __await(utils_1.fetch(`${apiDeployments}/${deployment.id}${teamId ? `?teamId=${teamId}` : ''}`, token));
                  const deploymentUpdate = yield __await(deploymentData.json());
                  if (ready_state_1.isReady(deploymentUpdate)) {
                      return yield __await(yield yield __await({ type: 'ready', payload: deploymentUpdate }));
                  }
                  if (ready_state_1.isFailed(deploymentUpdate)) {
                      return yield __await(yield yield __await({ type: 'error', payload: deploymentUpdate }));
                  }
              }
              yield __await(sleep_promise_1.default(ms_1.default('1.5s')));
          }
      });
  }
  exports.default = checkDeploymentStatus;
  
  
  /***/ }),
  
  /***/ 653:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.generateQueryString = (options) => {
      if (options.force && options.teamId) {
          return `?teamId=${options.teamId}&forceNew=1`;
      }
      else if (options.teamId) {
          return `?teamId=${options.teamId}`;
      }
      else if (options.force) {
          return `?forceNew=1`;
      }
      return '';
  };
  
  
  /***/ }),
  
  /***/ 672:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  /*eslint no-var:0, prefer-arrow-callback: 0, object-shorthand: 0 */
  
  
  
  var Punycode = __webpack_require__(805);
  
  
  var internals = {};
  
  
  //
  // Read rules from file.
  //
  internals.rules = __webpack_require__(875).map(function (rule) {
  
    return {
      rule: rule,
      suffix: rule.replace(/^(\*\.|\!)/, ''),
      punySuffix: -1,
      wildcard: rule.charAt(0) === '*',
      exception: rule.charAt(0) === '!'
    };
  });
  
  
  //
  // Check is given string ends with `suffix`.
  //
  internals.endsWith = function (str, suffix) {
  
    return str.indexOf(suffix, str.length - suffix.length) !== -1;
  };
  
  
  //
  // Find rule for a given domain.
  //
  internals.findRule = function (domain) {
  
    var punyDomain = Punycode.toASCII(domain);
    return internals.rules.reduce(function (memo, rule) {
  
      if (rule.punySuffix === -1){
        rule.punySuffix = Punycode.toASCII(rule.suffix);
      }
      if (!internals.endsWith(punyDomain, '.' + rule.punySuffix) && punyDomain !== rule.punySuffix) {
        return memo;
      }
      // This has been commented out as it never seems to run. This is because
      // sub tlds always appear after their parents and we never find a shorter
      // match.
      //if (memo) {
      //  var memoSuffix = Punycode.toASCII(memo.suffix);
      //  if (memoSuffix.length >= punySuffix.length) {
      //    return memo;
      //  }
      //}
      return rule;
    }, null);
  };
  
  
  //
  // Error codes and messages.
  //
  exports.errorCodes = {
    DOMAIN_TOO_SHORT: 'Domain name too short.',
    DOMAIN_TOO_LONG: 'Domain name too long. It should be no more than 255 chars.',
    LABEL_STARTS_WITH_DASH: 'Domain name label can not start with a dash.',
    LABEL_ENDS_WITH_DASH: 'Domain name label can not end with a dash.',
    LABEL_TOO_LONG: 'Domain name label should be at most 63 chars long.',
    LABEL_TOO_SHORT: 'Domain name label should be at least 1 character long.',
    LABEL_INVALID_CHARS: 'Domain name label can only contain alphanumeric characters or dashes.'
  };
  
  
  //
  // Validate domain name and throw if not valid.
  //
  // From wikipedia:
  //
  // Hostnames are composed of series of labels concatenated with dots, as are all
  // domain names. Each label must be between 1 and 63 characters long, and the
  // entire hostname (including the delimiting dots) has a maximum of 255 chars.
  //
  // Allowed chars:
  //
  // * `a-z`
  // * `0-9`
  // * `-` but not as a starting or ending character
  // * `.` as a separator for the textual portions of a domain name
  //
  // * http://en.wikipedia.org/wiki/Domain_name
  // * http://en.wikipedia.org/wiki/Hostname
  //
  internals.validate = function (input) {
  
    // Before we can validate we need to take care of IDNs with unicode chars.
    var ascii = Punycode.toASCII(input);
  
    if (ascii.length < 1) {
      return 'DOMAIN_TOO_SHORT';
    }
    if (ascii.length > 255) {
      return 'DOMAIN_TOO_LONG';
    }
  
    // Check each part's length and allowed chars.
    var labels = ascii.split('.');
    var label;
  
    for (var i = 0; i < labels.length; ++i) {
      label = labels[i];
      if (!label.length) {
        return 'LABEL_TOO_SHORT';
      }
      if (label.length > 63) {
        return 'LABEL_TOO_LONG';
      }
      if (label.charAt(0) === '-') {
        return 'LABEL_STARTS_WITH_DASH';
      }
      if (label.charAt(label.length - 1) === '-') {
        return 'LABEL_ENDS_WITH_DASH';
      }
      if (!/^[a-z0-9\-]+$/.test(label)) {
        return 'LABEL_INVALID_CHARS';
      }
    }
  };
  
  
  //
  // Public API
  //
  
  
  //
  // Parse domain.
  //
  exports.parse = function (input) {
  
    if (typeof input !== 'string') {
      throw new TypeError('Domain name must be a string.');
    }
  
    // Force domain to lowercase.
    var domain = input.slice(0).toLowerCase();
  
    // Handle FQDN.
    // TODO: Simply remove trailing dot?
    if (domain.charAt(domain.length - 1) === '.') {
      domain = domain.slice(0, domain.length - 1);
    }
  
    // Validate and sanitise input.
    var error = internals.validate(domain);
    if (error) {
      return {
        input: input,
        error: {
          message: exports.errorCodes[error],
          code: error
        }
      };
    }
  
    var parsed = {
      input: input,
      tld: null,
      sld: null,
      domain: null,
      subdomain: null,
      listed: false
    };
  
    var domainParts = domain.split('.');
  
    // Non-Internet TLD
    if (domainParts[domainParts.length - 1] === 'local') {
      return parsed;
    }
  
    var handlePunycode = function () {
  
      if (!/xn--/.test(domain)) {
        return parsed;
      }
      if (parsed.domain) {
        parsed.domain = Punycode.toASCII(parsed.domain);
      }
      if (parsed.subdomain) {
        parsed.subdomain = Punycode.toASCII(parsed.subdomain);
      }
      return parsed;
    };
  
    var rule = internals.findRule(domain);
  
    // Unlisted tld.
    if (!rule) {
      if (domainParts.length < 2) {
        return parsed;
      }
      parsed.tld = domainParts.pop();
      parsed.sld = domainParts.pop();
      parsed.domain = [parsed.sld, parsed.tld].join('.');
      if (domainParts.length) {
        parsed.subdomain = domainParts.pop();
      }
      return handlePunycode();
    }
  
    // At this point we know the public suffix is listed.
    parsed.listed = true;
  
    var tldParts = rule.suffix.split('.');
    var privateParts = domainParts.slice(0, domainParts.length - tldParts.length);
  
    if (rule.exception) {
      privateParts.push(tldParts.shift());
    }
  
    parsed.tld = tldParts.join('.');
  
    if (!privateParts.length) {
      return handlePunycode();
    }
  
    if (rule.wildcard) {
      tldParts.unshift(privateParts.pop());
      parsed.tld = tldParts.join('.');
    }
  
    if (!privateParts.length) {
      return handlePunycode();
    }
  
    parsed.sld = privateParts.pop();
    parsed.domain = [parsed.sld,  parsed.tld].join('.');
  
    if (privateParts.length) {
      parsed.subdomain = privateParts.join('.');
    }
  
    return handlePunycode();
  };
  
  
  //
  // Get domain.
  //
  exports.get = function (domain) {
  
    if (!domain) {
      return null;
    }
    return exports.parse(domain).domain || null;
  };
  
  
  //
  // Check whether domain belongs to a known public suffix.
  //
  exports.isValid = function (domain) {
  
    var parsed = exports.parse(domain);
    return Boolean(parsed.domain && parsed.listed);
  };
  
  
  /***/ }),
  
  /***/ 673:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const body_1 = __webpack_require__(452);
  const headers_1 = __webpack_require__(191);
  const defaultInit = {
      allowForbiddenHeaders: false,
      cache: "default",
      credentials: "omit",
      method: "GET",
      mode: "same-origin",
      redirect: "manual",
      referrer: "client",
  };
  class Request extends body_1.Body {
      constructor(input, init) {
          super();
          const { url: overwriteUrl } = init || {};
          // TODO: Consider throwing a TypeError if the URL has credentials
          this._url =
              input instanceof Request
                  ? (overwriteUrl || input._url)
                  : (overwriteUrl || input);
          if (input instanceof Request) {
              if (input.hasBody())
                  // Move body to this request
                  this.setBody(input);
              const newInit = Object.assign({}, input, init);
              init = newInit;
              // TODO: Follow MDN:
              //       If this object exists on another origin to the
              //       constructor call, the Request.referrer is stripped out.
              //       If this object has a Request.mode of navigate, the mode
              //       value is converted to same-origin.
          }
          this._init = Object.assign({}, defaultInit, init);
          const allowForbiddenHeaders = this._init.allowForbiddenHeaders;
          const headers = new headers_1.GuardedHeaders(allowForbiddenHeaders
              ? "none"
              : this._init.mode === "no-cors"
                  ? "request-no-cors"
                  : "request", this._init.headers);
          if (this._init.body && this._init.json)
              throw new Error("Cannot specify both 'body' and 'json'");
          if (!this.hasBody() && this._init.body) {
              if (headers.has("content-type"))
                  this.setBody(this._init.body, headers.get("content-type"));
              else
                  this.setBody(this._init.body);
          }
          else if (!this.hasBody() && this._init.json) {
              this.setBody(new body_1.JsonBody(this._init.json));
          }
          Object.defineProperties(this, {
              allowForbiddenHeaders: {
                  enumerable: true,
                  value: allowForbiddenHeaders,
              },
              cache: {
                  enumerable: true,
                  value: this._init.cache,
              },
              credentials: {
                  enumerable: true,
                  value: this._init.credentials,
              },
              headers: {
                  enumerable: true,
                  value: headers,
              },
              integrity: {
                  enumerable: true,
                  value: this._init.integrity,
              },
              method: {
                  enumerable: true,
                  value: this._init.method,
              },
              mode: {
                  enumerable: true,
                  value: this._init.mode,
              },
              redirect: {
                  enumerable: true,
                  value: this._init.redirect,
              },
              referrer: {
                  enumerable: true,
                  value: this._init.referrer,
              },
              referrerPolicy: {
                  enumerable: true,
                  value: this._init.referrerPolicy,
              },
              url: {
                  enumerable: true,
                  value: this._url,
              },
          });
      }
      clone(newUrl) {
          return new Request(this, { url: newUrl });
      }
  }
  exports.Request = Request;
  //# sourceMappingURL=request.js.map
  
  /***/ }),
  
  /***/ 675:
  /***/ (function(module) {
  
  module.exports = require("http2");
  
  /***/ }),
  
  /***/ 688:
  /***/ (function(module) {
  
  module.exports = require("stream");
  
  /***/ }),
  
  /***/ 702:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  // TODO: enable this once graceful-fs supports bigint option.
  // const fs = require('graceful-fs')
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  const mkdirpSync = __webpack_require__(562).mkdirsSync
  const utimesSync = __webpack_require__(167).utimesMillisSync
  const stat = __webpack_require__(150)
  
  function copySync (src, dest, opts) {
    if (typeof opts === 'function') {
      opts = {filter: opts}
    }
  
    opts = opts || {}
    opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
    opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
  
    // Warn about using preserveTimestamps on 32-bit node
    if (opts.preserveTimestamps && process.arch === 'ia32') {
      console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
      see https://github.com/jprichardson/node-fs-extra/issues/269`)
    }
  
    const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy')
    stat.checkParentPathsSync(src, srcStat, dest, 'copy')
    return handleFilterAndCopy(destStat, src, dest, opts)
  }
  
  function handleFilterAndCopy (destStat, src, dest, opts) {
    if (opts.filter && !opts.filter(src, dest)) return
    const destParent = path.dirname(dest)
    if (!fs.existsSync(destParent)) mkdirpSync(destParent)
    return startCopy(destStat, src, dest, opts)
  }
  
  function startCopy (destStat, src, dest, opts) {
    if (opts.filter && !opts.filter(src, dest)) return
    return getStats(destStat, src, dest, opts)
  }
  
  function getStats (destStat, src, dest, opts) {
    const statSync = opts.dereference ? fs.statSync : fs.lstatSync
    const srcStat = statSync(src)
  
    if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts)
    else if (srcStat.isFile() ||
             srcStat.isCharacterDevice() ||
             srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts)
    else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts)
  }
  
  function onFile (srcStat, destStat, src, dest, opts) {
    if (!destStat) return copyFile(srcStat, src, dest, opts)
    return mayCopyFile(srcStat, src, dest, opts)
  }
  
  function mayCopyFile (srcStat, src, dest, opts) {
    if (opts.overwrite) {
      fs.unlinkSync(dest)
      return copyFile(srcStat, src, dest, opts)
    } else if (opts.errorOnExist) {
      throw new Error(`'${dest}' already exists`)
    }
  }
  
  function copyFile (srcStat, src, dest, opts) {
    if (typeof fs.copyFileSync === 'function') {
      fs.copyFileSync(src, dest)
      fs.chmodSync(dest, srcStat.mode)
      if (opts.preserveTimestamps) {
        return utimesSync(dest, srcStat.atime, srcStat.mtime)
      }
      return
    }
    return copyFileFallback(srcStat, src, dest, opts)
  }
  
  function copyFileFallback (srcStat, src, dest, opts) {
    const BUF_LENGTH = 64 * 1024
    const _buff = __webpack_require__(571)(BUF_LENGTH)
  
    const fdr = fs.openSync(src, 'r')
    const fdw = fs.openSync(dest, 'w', srcStat.mode)
    let pos = 0
  
    while (pos < srcStat.size) {
      const bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
      fs.writeSync(fdw, _buff, 0, bytesRead)
      pos += bytesRead
    }
  
    if (opts.preserveTimestamps) fs.futimesSync(fdw, srcStat.atime, srcStat.mtime)
  
    fs.closeSync(fdr)
    fs.closeSync(fdw)
  }
  
  function onDir (srcStat, destStat, src, dest, opts) {
    if (!destStat) return mkDirAndCopy(srcStat, src, dest, opts)
    if (destStat && !destStat.isDirectory()) {
      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
    }
    return copyDir(src, dest, opts)
  }
  
  function mkDirAndCopy (srcStat, src, dest, opts) {
    fs.mkdirSync(dest)
    copyDir(src, dest, opts)
    return fs.chmodSync(dest, srcStat.mode)
  }
  
  function copyDir (src, dest, opts) {
    fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts))
  }
  
  function copyDirItem (item, src, dest, opts) {
    const srcItem = path.join(src, item)
    const destItem = path.join(dest, item)
    const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy')
    return startCopy(destStat, srcItem, destItem, opts)
  }
  
  function onLink (destStat, src, dest, opts) {
    let resolvedSrc = fs.readlinkSync(src)
    if (opts.dereference) {
      resolvedSrc = path.resolve(process.cwd(), resolvedSrc)
    }
  
    if (!destStat) {
      return fs.symlinkSync(resolvedSrc, dest)
    } else {
      let resolvedDest
      try {
        resolvedDest = fs.readlinkSync(dest)
      } catch (err) {
        // dest exists and is a regular file or directory,
        // Windows may throw UNKNOWN error. If dest already exists,
        // fs throws error anyway, so no need to guard against it here.
        if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest)
        throw err
      }
      if (opts.dereference) {
        resolvedDest = path.resolve(process.cwd(), resolvedDest)
      }
      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)
      }
  
      // prevent copy if src is a subdir of dest since unlinking
      // dest in this case would result in removing src contents
      // and therefore a broken symlink would be created.
      if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)
      }
      return copyLink(resolvedSrc, dest)
    }
  }
  
  function copyLink (resolvedSrc, dest) {
    fs.unlinkSync(dest)
    return fs.symlinkSync(resolvedSrc, dest)
  }
  
  module.exports = copySync
  
  
  /***/ }),
  
  /***/ 714:
  /***/ (function(module) {
  
  if (typeof Object.create === 'function') {
    // implementation from standard node.js 'util' module
    module.exports = function inherits(ctor, superCtor) {
      ctor.super_ = superCtor
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
          value: ctor,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
    };
  } else {
    // old school shim for old browsers
    module.exports = function inherits(ctor, superCtor) {
      ctor.super_ = superCtor
      var TempCtor = function () {}
      TempCtor.prototype = superCtor.prototype
      ctor.prototype = new TempCtor()
      ctor.prototype.constructor = ctor
    }
  }
  
  
  /***/ }),
  
  /***/ 715:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var Buffer = __webpack_require__(942).Buffer
  
  module.exports = function (buf) {
  	// If the buffer is backed by a Uint8Array, a faster version will work
  	if (buf instanceof Uint8Array) {
  		// If the buffer isn't a subarray, return the underlying ArrayBuffer
  		if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
  			return buf.buffer
  		} else if (typeof buf.buffer.slice === 'function') {
  			// Otherwise we need to get a proper copy
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
  		}
  	}
  
  	if (Buffer.isBuffer(buf)) {
  		// This is the slow version that will work with any Buffer
  		// implementation (even in old browsers)
  		var arrayCopy = new Uint8Array(buf.length)
  		var len = buf.length
  		for (var i = 0; i < len; i++) {
  			arrayCopy[i] = buf[i]
  		}
  		return arrayCopy.buffer
  	} else {
  		throw new Error('Argument must be a Buffer')
  	}
  }
  
  
  /***/ }),
  
  /***/ 734:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const u = __webpack_require__(344).fromPromise
  const fs = __webpack_require__(827)
  
  function pathExists (path) {
    return fs.access(path).then(() => true).catch(() => false)
  }
  
  module.exports = {
    pathExists: u(pathExists),
    pathExistsSync: fs.existsSync
  }
  
  
  /***/ }),
  
  /***/ 744:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Ported from https://github.com/mafintosh/end-of-stream with
  // permission from the author, Mathias Buus (@mafintosh).
  
  
  var ERR_STREAM_PREMATURE_CLOSE = __webpack_require__(854).codes.ERR_STREAM_PREMATURE_CLOSE;
  
  function once(callback) {
    var called = false;
    return function () {
      if (called) return;
      called = true;
  
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      callback.apply(this, args);
    };
  }
  
  function noop() {}
  
  function isRequest(stream) {
    return stream.setHeader && typeof stream.abort === 'function';
  }
  
  function eos(stream, opts, callback) {
    if (typeof opts === 'function') return eos(stream, null, opts);
    if (!opts) opts = {};
    callback = once(callback || noop);
    var readable = opts.readable || opts.readable !== false && stream.readable;
    var writable = opts.writable || opts.writable !== false && stream.writable;
  
    var onlegacyfinish = function onlegacyfinish() {
      if (!stream.writable) onfinish();
    };
  
    var writableEnded = stream._writableState && stream._writableState.finished;
  
    var onfinish = function onfinish() {
      writable = false;
      writableEnded = true;
      if (!readable) callback.call(stream);
    };
  
    var readableEnded = stream._readableState && stream._readableState.endEmitted;
  
    var onend = function onend() {
      readable = false;
      readableEnded = true;
      if (!writable) callback.call(stream);
    };
  
    var onerror = function onerror(err) {
      callback.call(stream, err);
    };
  
    var onclose = function onclose() {
      var err;
  
      if (readable && !readableEnded) {
        if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
        return callback.call(stream, err);
      }
  
      if (writable && !writableEnded) {
        if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
        return callback.call(stream, err);
      }
    };
  
    var onrequest = function onrequest() {
      stream.req.on('finish', onfinish);
    };
  
    if (isRequest(stream)) {
      stream.on('complete', onfinish);
      stream.on('abort', onclose);
      if (stream.req) onrequest();else stream.on('request', onrequest);
    } else if (writable && !stream._writableState) {
      // legacy streams
      stream.on('end', onlegacyfinish);
      stream.on('close', onlegacyfinish);
    }
  
    stream.on('end', onend);
    stream.on('finish', onfinish);
    if (opts.error !== false) stream.on('error', onerror);
    stream.on('close', onclose);
    return function () {
      stream.removeListener('complete', onfinish);
      stream.removeListener('abort', onclose);
      stream.removeListener('request', onrequest);
      if (stream.req) stream.req.removeListener('finish', onfinish);
      stream.removeListener('end', onlegacyfinish);
      stream.removeListener('close', onlegacyfinish);
      stream.removeListener('finish', onfinish);
      stream.removeListener('end', onend);
      stream.removeListener('error', onerror);
      stream.removeListener('close', onclose);
    };
  }
  
  module.exports = eos;
  
  /***/ }),
  
  /***/ 756:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  var _Object$setPrototypeO;
  
  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
  
  var finished = __webpack_require__(744);
  
  var kLastResolve = Symbol('lastResolve');
  var kLastReject = Symbol('lastReject');
  var kError = Symbol('error');
  var kEnded = Symbol('ended');
  var kLastPromise = Symbol('lastPromise');
  var kHandlePromise = Symbol('handlePromise');
  var kStream = Symbol('stream');
  
  function createIterResult(value, done) {
    return {
      value: value,
      done: done
    };
  }
  
  function readAndResolve(iter) {
    var resolve = iter[kLastResolve];
  
    if (resolve !== null) {
      var data = iter[kStream].read(); // we defer if data is null
      // we can be expecting either 'end' or
      // 'error'
  
      if (data !== null) {
        iter[kLastPromise] = null;
        iter[kLastResolve] = null;
        iter[kLastReject] = null;
        resolve(createIterResult(data, false));
      }
    }
  }
  
  function onReadable(iter) {
    // we wait for the next tick, because it might
    // emit an error with process.nextTick
    process.nextTick(readAndResolve, iter);
  }
  
  function wrapForNext(lastPromise, iter) {
    return function (resolve, reject) {
      lastPromise.then(function () {
        if (iter[kEnded]) {
          resolve(createIterResult(undefined, true));
          return;
        }
  
        iter[kHandlePromise](resolve, reject);
      }, reject);
    };
  }
  
  var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
  var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
    get stream() {
      return this[kStream];
    },
  
    next: function next() {
      var _this = this;
  
      // if we have detected an error in the meanwhile
      // reject straight away
      var error = this[kError];
  
      if (error !== null) {
        return Promise.reject(error);
      }
  
      if (this[kEnded]) {
        return Promise.resolve(createIterResult(undefined, true));
      }
  
      if (this[kStream].destroyed) {
        // We need to defer via nextTick because if .destroy(err) is
        // called, the error will be emitted via nextTick, and
        // we cannot guarantee that there is no error lingering around
        // waiting to be emitted.
        return new Promise(function (resolve, reject) {
          process.nextTick(function () {
            if (_this[kError]) {
              reject(_this[kError]);
            } else {
              resolve(createIterResult(undefined, true));
            }
          });
        });
      } // if we have multiple next() calls
      // we will wait for the previous Promise to finish
      // this logic is optimized to support for await loops,
      // where next() is only called once at a time
  
  
      var lastPromise = this[kLastPromise];
      var promise;
  
      if (lastPromise) {
        promise = new Promise(wrapForNext(lastPromise, this));
      } else {
        // fast path needed to support multiple this.push()
        // without triggering the next() queue
        var data = this[kStream].read();
  
        if (data !== null) {
          return Promise.resolve(createIterResult(data, false));
        }
  
        promise = new Promise(this[kHandlePromise]);
      }
  
      this[kLastPromise] = promise;
      return promise;
    }
  }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
    return this;
  }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
    var _this2 = this;
  
    // destroy(err, cb) is a private API
    // we can guarantee we have that here, because we control the
    // Readable class this is attached to
    return new Promise(function (resolve, reject) {
      _this2[kStream].destroy(null, function (err) {
        if (err) {
          reject(err);
          return;
        }
  
        resolve(createIterResult(undefined, true));
      });
    });
  }), _Object$setPrototypeO), AsyncIteratorPrototype);
  
  var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
    var _Object$create;
  
    var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
      value: stream,
      writable: true
    }), _defineProperty(_Object$create, kLastResolve, {
      value: null,
      writable: true
    }), _defineProperty(_Object$create, kLastReject, {
      value: null,
      writable: true
    }), _defineProperty(_Object$create, kError, {
      value: null,
      writable: true
    }), _defineProperty(_Object$create, kEnded, {
      value: stream._readableState.endEmitted,
      writable: true
    }), _defineProperty(_Object$create, kHandlePromise, {
      value: function value(resolve, reject) {
        var data = iterator[kStream].read();
  
        if (data) {
          iterator[kLastPromise] = null;
          iterator[kLastResolve] = null;
          iterator[kLastReject] = null;
          resolve(createIterResult(data, false));
        } else {
          iterator[kLastResolve] = resolve;
          iterator[kLastReject] = reject;
        }
      },
      writable: true
    }), _Object$create));
    iterator[kLastPromise] = null;
    finished(stream, function (err) {
      if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
        var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
        // returned by next() and store the error
  
        if (reject !== null) {
          iterator[kLastPromise] = null;
          iterator[kLastResolve] = null;
          iterator[kLastReject] = null;
          reject(err);
        }
  
        iterator[kError] = err;
        return;
      }
  
      var resolve = iterator[kLastResolve];
  
      if (resolve !== null) {
        iterator[kLastPromise] = null;
        iterator[kLastResolve] = null;
        iterator[kLastReject] = null;
        resolve(createIterResult(undefined, true));
      }
  
      iterator[kEnded] = true;
    });
    stream.on('readable', onReadable.bind(null, iterator));
    return iterator;
  };
  
  module.exports = createReadableStreamAsyncIterator;
  
  /***/ }),
  
  /***/ 760:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const url_1 = __webpack_require__(986);
  const zlib_1 = __webpack_require__(267);
  function arrayify(value) {
      if (value != null && Array.isArray(value))
          return value;
      return value == null
          ? []
          : Array.isArray(value)
              ? [...value]
              : [value];
  }
  exports.arrayify = arrayify;
  function parseLocation(location, origin) {
      if ("string" !== typeof location)
          return null;
      const url = new url_1.URL(location, origin);
      return url.href;
  }
  exports.parseLocation = parseLocation;
  exports.isRedirectStatus = {
      300: true,
      301: true,
      302: true,
      303: true,
      305: true,
      307: true,
      308: true,
  };
  function makeOkError(err) {
      err.metaData = err.metaData || {};
      err.metaData.ok = true;
      return err;
  }
  exports.makeOkError = makeOkError;
  function parseInput(url) {
      const explicitProtocol = (url.startsWith("http2://") || url.startsWith("http1://"))
          ? url.substr(0, 5)
          : null;
      url = url.replace(/^http[12]:\/\//, "http://");
      const { origin, hostname, port, protocol } = new url_1.URL(url);
      return {
          hostname,
          origin,
          port: port || (protocol === "https:" ? "443" : "80"),
          protocol: explicitProtocol || protocol.replace(":", ""),
          url,
      };
  }
  exports.parseInput = parseInput;
  exports.identity = (t) => t;
  function uniq(arr, pred) {
      if (!pred)
          return Array.from(new Set(arr));
      const known = new Set();
      return arr.filter(value => {
          const u = pred(value);
          const first = !known.has(u);
          known.add(u);
          return first;
      });
  }
  exports.uniq = uniq;
  function hasBuiltinBrotli() {
      return typeof zlib_1.createBrotliCompress === "function";
  }
  exports.hasBuiltinBrotli = hasBuiltinBrotli;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 798:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(813)
  const path = __webpack_require__(589)
  const invalidWin32Path = __webpack_require__(376).invalidWin32Path
  
  const o777 = parseInt('0777', 8)
  
  function mkdirsSync (p, opts, made) {
    if (!opts || typeof opts !== 'object') {
      opts = { mode: opts }
    }
  
    let mode = opts.mode
    const xfs = opts.fs || fs
  
    if (process.platform === 'win32' && invalidWin32Path(p)) {
      const errInval = new Error(p + ' contains invalid WIN32 path characters.')
      errInval.code = 'EINVAL'
      throw errInval
    }
  
    if (mode === undefined) {
      mode = o777 & (~process.umask())
    }
    if (!made) made = null
  
    p = path.resolve(p)
  
    try {
      xfs.mkdirSync(p, mode)
      made = made || p
    } catch (err0) {
      if (err0.code === 'ENOENT') {
        if (path.dirname(p) === p) throw err0
        made = mkdirsSync(path.dirname(p), opts, made)
        mkdirsSync(p, opts, made)
      } else {
        // In the case of any other error, just see if there's a dir there
        // already. If so, then hooray!  If not, then something is borked.
        let stat
        try {
          stat = xfs.statSync(p)
        } catch (err1) {
          throw err0
        }
        if (!stat.isDirectory()) throw err0
      }
    }
  
    return made
  }
  
  module.exports = mkdirsSync
  
  
  /***/ }),
  
  /***/ 802:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const file = __webpack_require__(594)
  const link = __webpack_require__(98)
  const symlink = __webpack_require__(563)
  
  module.exports = {
    // file
    createFile: file.createFile,
    createFileSync: file.createFileSync,
    ensureFile: file.createFile,
    ensureFileSync: file.createFileSync,
    // link
    createLink: link.createLink,
    createLinkSync: link.createLinkSync,
    ensureLink: link.createLink,
    ensureLinkSync: link.createLinkSync,
    // symlink
    createSymlink: symlink.createSymlink,
    createSymlinkSync: symlink.createSymlinkSync,
    ensureSymlink: symlink.createSymlink,
    ensureSymlinkSync: symlink.createSymlinkSync
  }
  
  
  /***/ }),
  
  /***/ 805:
  /***/ (function(module) {
  
  module.exports = require("punycode");
  
  /***/ }),
  
  /***/ 806:
  /***/ (function(module) {
  
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 809:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  
  var Store = __webpack_require__(471).Store;
  var permuteDomain = __webpack_require__(231).permuteDomain;
  var pathMatch = __webpack_require__(143).pathMatch;
  var util = __webpack_require__(64);
  
  function MemoryCookieStore() {
    Store.call(this);
    this.idx = {};
  }
  util.inherits(MemoryCookieStore, Store);
  exports.MemoryCookieStore = MemoryCookieStore;
  MemoryCookieStore.prototype.idx = null;
  
  // Since it's just a struct in RAM, this Store is synchronous
  MemoryCookieStore.prototype.synchronous = true;
  
  // force a default depth:
  MemoryCookieStore.prototype.inspect = function() {
    return "{ idx: "+util.inspect(this.idx, false, 2)+' }';
  };
  
  // Use the new custom inspection symbol to add the custom inspect function if
  // available.
  if (util.inspect.custom) {
    MemoryCookieStore.prototype[util.inspect.custom] = MemoryCookieStore.prototype.inspect;
  }
  
  MemoryCookieStore.prototype.findCookie = function(domain, path, key, cb) {
    if (!this.idx[domain]) {
      return cb(null,undefined);
    }
    if (!this.idx[domain][path]) {
      return cb(null,undefined);
    }
    return cb(null,this.idx[domain][path][key]||null);
  };
  
  MemoryCookieStore.prototype.findCookies = function(domain, path, cb) {
    var results = [];
    if (!domain) {
      return cb(null,[]);
    }
  
    var pathMatcher;
    if (!path) {
      // null means "all paths"
      pathMatcher = function matchAll(domainIndex) {
        for (var curPath in domainIndex) {
          var pathIndex = domainIndex[curPath];
          for (var key in pathIndex) {
            results.push(pathIndex[key]);
          }
        }
      };
  
    } else {
      pathMatcher = function matchRFC(domainIndex) {
         //NOTE: we should use path-match algorithm from S5.1.4 here
         //(see : https://github.com/ChromiumWebApps/chromium/blob/b3d3b4da8bb94c1b2e061600df106d590fda3620/net/cookies/canonical_cookie.cc#L299)
         Object.keys(domainIndex).forEach(function (cookiePath) {
           if (pathMatch(path, cookiePath)) {
             var pathIndex = domainIndex[cookiePath];
  
             for (var key in pathIndex) {
               results.push(pathIndex[key]);
             }
           }
         });
       };
    }
  
    var domains = permuteDomain(domain) || [domain];
    var idx = this.idx;
    domains.forEach(function(curDomain) {
      var domainIndex = idx[curDomain];
      if (!domainIndex) {
        return;
      }
      pathMatcher(domainIndex);
    });
  
    cb(null,results);
  };
  
  MemoryCookieStore.prototype.putCookie = function(cookie, cb) {
    if (!this.idx[cookie.domain]) {
      this.idx[cookie.domain] = {};
    }
    if (!this.idx[cookie.domain][cookie.path]) {
      this.idx[cookie.domain][cookie.path] = {};
    }
    this.idx[cookie.domain][cookie.path][cookie.key] = cookie;
    cb(null);
  };
  
  MemoryCookieStore.prototype.updateCookie = function(oldCookie, newCookie, cb) {
    // updateCookie() may avoid updating cookies that are identical.  For example,
    // lastAccessed may not be important to some stores and an equality
    // comparison could exclude that field.
    this.putCookie(newCookie,cb);
  };
  
  MemoryCookieStore.prototype.removeCookie = function(domain, path, key, cb) {
    if (this.idx[domain] && this.idx[domain][path] && this.idx[domain][path][key]) {
      delete this.idx[domain][path][key];
    }
    cb(null);
  };
  
  MemoryCookieStore.prototype.removeCookies = function(domain, path, cb) {
    if (this.idx[domain]) {
      if (path) {
        delete this.idx[domain][path];
      } else {
        delete this.idx[domain];
      }
    }
    return cb(null);
  };
  
  MemoryCookieStore.prototype.removeAllCookies = function(cb) {
    this.idx = {};
    return cb(null);
  }
  
  MemoryCookieStore.prototype.getAllCookies = function(cb) {
    var cookies = [];
    var idx = this.idx;
  
    var domains = Object.keys(idx);
    domains.forEach(function(domain) {
      var paths = Object.keys(idx[domain]);
      paths.forEach(function(path) {
        var keys = Object.keys(idx[domain][path]);
        keys.forEach(function(key) {
          if (key !== null) {
            cookies.push(idx[domain][path][key]);
          }
        });
      });
    });
  
    // Sort by creationIndex so deserializing retains the creation order.
    // When implementing your own store, this SHOULD retain the order too
    cookies.sort(function(a,b) {
      return (a.creationIndex||0) - (b.creationIndex||0);
    });
  
    cb(null, cookies);
  };
  
  
  /***/ }),
  
  /***/ 812:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const u = __webpack_require__(344).fromCallback
  const rimraf = __webpack_require__(113)
  
  module.exports = {
    remove: u(rimraf),
    removeSync: rimraf.sync
  }
  
  
  /***/ }),
  
  /***/ 813:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var fs = __webpack_require__(66)
  var polyfills = __webpack_require__(832)
  var legacy = __webpack_require__(597)
  var clone = __webpack_require__(840)
  
  var queue = []
  
  var util = __webpack_require__(64)
  
  function noop () {}
  
  var debug = noop
  if (util.debuglog)
    debug = util.debuglog('gfs4')
  else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
    debug = function() {
      var m = util.format.apply(util, arguments)
      m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
      console.error(m)
    }
  
  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
    process.on('exit', function() {
      debug(queue)
      __webpack_require__(393).equal(queue.length, 0)
    })
  }
  
  module.exports = patch(clone(fs))
  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
      module.exports = patch(fs)
      fs.__patched = true;
  }
  
  // Always patch fs.close/closeSync, because we want to
  // retry() whenever a close happens *anywhere* in the program.
  // This is essential when multiple graceful-fs instances are
  // in play at the same time.
  module.exports.close = (function (fs$close) { return function (fd, cb) {
    return fs$close.call(fs, fd, function (err) {
      if (!err)
        retry()
  
      if (typeof cb === 'function')
        cb.apply(this, arguments)
    })
  }})(fs.close)
  
  module.exports.closeSync = (function (fs$closeSync) { return function (fd) {
    // Note that graceful-fs also retries when fs.closeSync() fails.
    // Looks like a bug to me, although it's probably a harmless one.
    var rval = fs$closeSync.apply(fs, arguments)
    retry()
    return rval
  }})(fs.closeSync)
  
  // Only patch fs once, otherwise we'll run into a memory leak if
  // graceful-fs is loaded multiple times, such as in test environments that
  // reset the loaded modules between tests.
  // We look for the string `graceful-fs` from the comment above. This
  // way we are not adding any extra properties and it will detect if older
  // versions of graceful-fs are installed.
  if (!/\bgraceful-fs\b/.test(fs.closeSync.toString())) {
    fs.closeSync = module.exports.closeSync;
    fs.close = module.exports.close;
  }
  
  function patch (fs) {
    // Everything that references the open() function needs to be in here
    polyfills(fs)
    fs.gracefulify = patch
    fs.FileReadStream = ReadStream;  // Legacy name.
    fs.FileWriteStream = WriteStream;  // Legacy name.
    fs.createReadStream = createReadStream
    fs.createWriteStream = createWriteStream
    var fs$readFile = fs.readFile
    fs.readFile = readFile
    function readFile (path, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$readFile(path, options, cb)
  
      function go$readFile (path, options, cb) {
        return fs$readFile(path, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$readFile, [path, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$writeFile = fs.writeFile
    fs.writeFile = writeFile
    function writeFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$writeFile(path, data, options, cb)
  
      function go$writeFile (path, data, options, cb) {
        return fs$writeFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$writeFile, [path, data, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$appendFile = fs.appendFile
    if (fs$appendFile)
      fs.appendFile = appendFile
    function appendFile (path, data, options, cb) {
      if (typeof options === 'function')
        cb = options, options = null
  
      return go$appendFile(path, data, options, cb)
  
      function go$appendFile (path, data, options, cb) {
        return fs$appendFile(path, data, options, function (err) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$appendFile, [path, data, options, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    var fs$readdir = fs.readdir
    fs.readdir = readdir
    function readdir (path, options, cb) {
      var args = [path]
      if (typeof options !== 'function') {
        args.push(options)
      } else {
        cb = options
      }
      args.push(go$readdir$cb)
  
      return go$readdir(args)
  
      function go$readdir$cb (err, files) {
        if (files && files.sort)
          files.sort()
  
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
          enqueue([go$readdir, [args]])
  
        else {
          if (typeof cb === 'function')
            cb.apply(this, arguments)
          retry()
        }
      }
    }
  
    function go$readdir (args) {
      return fs$readdir.apply(fs, args)
    }
  
    if (process.version.substr(0, 4) === 'v0.8') {
      var legStreams = legacy(fs)
      ReadStream = legStreams.ReadStream
      WriteStream = legStreams.WriteStream
    }
  
    var fs$ReadStream = fs.ReadStream
    if (fs$ReadStream) {
      ReadStream.prototype = Object.create(fs$ReadStream.prototype)
      ReadStream.prototype.open = ReadStream$open
    }
  
    var fs$WriteStream = fs.WriteStream
    if (fs$WriteStream) {
      WriteStream.prototype = Object.create(fs$WriteStream.prototype)
      WriteStream.prototype.open = WriteStream$open
    }
  
    fs.ReadStream = ReadStream
    fs.WriteStream = WriteStream
  
    function ReadStream (path, options) {
      if (this instanceof ReadStream)
        return fs$ReadStream.apply(this, arguments), this
      else
        return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
    }
  
    function ReadStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          if (that.autoClose)
            that.destroy()
  
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
          that.read()
        }
      })
    }
  
    function WriteStream (path, options) {
      if (this instanceof WriteStream)
        return fs$WriteStream.apply(this, arguments), this
      else
        return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
    }
  
    function WriteStream$open () {
      var that = this
      open(that.path, that.flags, that.mode, function (err, fd) {
        if (err) {
          that.destroy()
          that.emit('error', err)
        } else {
          that.fd = fd
          that.emit('open', fd)
        }
      })
    }
  
    function createReadStream (path, options) {
      return new ReadStream(path, options)
    }
  
    function createWriteStream (path, options) {
      return new WriteStream(path, options)
    }
  
    var fs$open = fs.open
    fs.open = open
    function open (path, flags, mode, cb) {
      if (typeof mode === 'function')
        cb = mode, mode = null
  
      return go$open(path, flags, mode, cb)
  
      function go$open (path, flags, mode, cb) {
        return fs$open(path, flags, mode, function (err, fd) {
          if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
            enqueue([go$open, [path, flags, mode, cb]])
          else {
            if (typeof cb === 'function')
              cb.apply(this, arguments)
            retry()
          }
        })
      }
    }
  
    return fs
  }
  
  function enqueue (elem) {
    debug('ENQUEUE', elem[0].name, elem[1])
    queue.push(elem)
  }
  
  function retry () {
    var elem = queue.shift()
    if (elem) {
      debug('RETRY', elem[0].name, elem[1])
      elem[0].apply(null, elem[1])
    }
  }
  
  
  /***/ }),
  
  /***/ 818:
  /***/ (function(module) {
  
  module.exports = {"name":"now-client","version":"5.0.0","main":"lib/index.js","license":"MIT","author":"Max Rovensky <max@zeit.co>","scripts":{"build":"ncc build ./src/index.ts -o ./lib --source-map","prepare":"npm run build","test":"jest --verbose --forceExit","lint":"eslint --fix --ext .ts ./src","lint-staged":"git diff --diff-filter=ACMRT --cached --name-only '*.ts' | xargs eslint --fix"},"devDependencies":{"@types/async-retry":"1.4.1","@types/fs-extra":"7.0.0","@types/jest":"24.0.16","@types/ms":"0.7.30","@types/node":"12.0.4","@types/node-fetch":"2.3.4","@types/recursive-readdir":"2.2.0","@typescript-eslint/eslint-plugin":"1.9.0","@typescript-eslint/parser":"1.9.0","@zeit/git-hooks":"0.1.4","@zeit/ncc":"0.18.5","eslint":"5.16.0","jest":"24.8.0","ts-jest":"24.0.2","typescript":"3.5.1"},"eslintConfig":{"parser":"@typescript-eslint/parser","plugins":["@typescript-eslint"],"extends":["eslint:recommended","plugin:@typescript-eslint/recommended"],"env":{"es6":true,"node":true,"jest":true},"rules":{"func-names":["error","as-needed"],"no-shadow":"error","no-extra-semi":0,"react/prop-types":0,"react/react-in-jsx-scope":0,"react/no-unescaped-entities":0,"react/jsx-no-target-blank":0,"react/no-string-refs":0,"semi":["error","never"],"@typescript-eslint/indent":["error",2],"@typescript-eslint/no-explicit-any":"off","@typescript-eslint/explicit-member-accessibility":"off"}},"git":{"pre-commit":"lint-staged"},"jest":{"preset":"ts-jest","testEnvironment":"node","verbose":false,"setupFilesAfterEnv":["<rootDir>/tests/setup/index.ts"]},"dependencies":{"@zeit/fetch":"5.1.0","async-retry":"1.2.3","async-sema":"3.0.0","fetch-h2":"2.2.0","fs-extra":"8.0.1","ms":"2.1.2","node-fetch":"2.6.0","now-client":"4.1.2","querystring":"^0.2.0","recursive-readdir":"2.2.2","sleep-promise":"8.0.1"}};
  
  /***/ }),
  
  /***/ 826:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http_1 = __webpack_require__(421);
  const https_1 = __webpack_require__(230);
  const net_1 = __webpack_require__(193);
  const url_1 = __webpack_require__(986);
  const already_1 = __webpack_require__(534);
  const core_1 = __webpack_require__(570);
  const utils_1 = __webpack_require__(760);
  class OriginPool {
      constructor(keepAlive, keepAliveMsecs, maxSockets, maxFreeSockets, timeout) {
          this.usedSockets = new Set();
          this.unusedSockets = new Set();
          this.waiting = [];
          this.keepAlive = keepAlive;
          this.keepAliveMsecs = keepAliveMsecs;
          this.maxSockets = maxSockets;
          this.maxFreeSockets = maxFreeSockets;
          this.connOpts = timeout == null ? {} : { timeout };
      }
      connect(options) {
          const request = options.protocol === "https:"
              ? https_1.request
              : http_1.request;
          const opts = { ...options };
          if (opts.rejectUnauthorized == null || options.protocol === "https")
              delete opts.rejectUnauthorized;
          const req = request({ ...this.connOpts, ...opts });
          return req;
      }
      addUsed(socket) {
          if (this.keepAlive)
              socket.setKeepAlive(true, this.keepAliveMsecs);
          socket.once("close", () => {
              this.usedSockets.delete(socket);
              this.unusedSockets.delete(socket);
          });
          this.usedSockets.add(socket);
          return this.makeCleaner(socket);
      }
      getFreeSocket() {
          const socketAndCleanup = this.getFirstUnused();
          if (socketAndCleanup)
              return { ...socketAndCleanup, shouldCreateNew: false };
          const shouldCreateNew = this.maxSockets >= this.usedSockets.size;
          return { shouldCreateNew };
      }
      waitForSocket() {
          const deferred = already_1.defer();
          this.waiting.push(deferred);
          // Trigger due to potential race-condition
          this.pumpWaiting();
          return deferred.promise;
      }
      async disconnectAll() {
          await Promise.all([...this.usedSockets, ...this.unusedSockets]
              .map(socket => socket.destroyed ? void 0 : this.disconnectSocket(socket)));
          const waiting = this.waiting;
          this.waiting.length = 0;
          waiting.forEach(waiter => 
          // TODO: Better error class + message
          waiter.reject(new Error("Disconnected")));
      }
      getFirstUnused() {
          for (const socket of this.unusedSockets.values()) {
              // We obviously have a socket
              this.moveToUsed(socket);
              return { socket, cleanup: this.makeCleaner(socket) };
          }
          return null;
      }
      tryReuse(socket) {
          if (this.waiting.length === 0)
              return false;
          const waiting = this.waiting.shift();
          waiting.resolve({ socket, cleanup: this.makeCleaner(socket) });
          return true;
      }
      pumpWaiting() {
          while (this.waiting.length > 0 && this.unusedSockets.size > 0) {
              const socketAndCleanup = this.getFirstUnused();
              const waiting = this.waiting.shift();
              waiting.resolve(socketAndCleanup);
          }
      }
      async disconnectSocket(socket) {
          socket.destroy();
      }
      makeCleaner(socket) {
          let hasCleaned = false;
          return () => {
              if (hasCleaned)
                  return;
              hasCleaned = true;
              if (!socket.destroyed)
                  this.moveToUnused(socket);
          };
      }
      async moveToUnused(socket) {
          if (this.tryReuse(socket))
              return;
          this.usedSockets.delete(socket);
          if (this.maxFreeSockets < this.unusedSockets.size + 1) {
              await this.disconnectSocket(socket);
              return;
          }
          this.unusedSockets.add(socket);
          socket.unref();
      }
      moveToUsed(socket) {
          this.unusedSockets.delete(socket);
          this.usedSockets.add(socket);
          socket.ref();
          return socket;
      }
  }
  class ContextPool {
      constructor(options) {
          this.pools = new Map();
          this.keepAlive = core_1.parsePerOrigin(options.keepAlive, true);
          this.keepAliveMsecs = core_1.parsePerOrigin(options.keepAliveMsecs, 1000);
          this.maxSockets = core_1.parsePerOrigin(options.maxSockets, 256);
          this.maxFreeSockets = core_1.parsePerOrigin(options.maxFreeSockets, Infinity);
          this.timeout = core_1.parsePerOrigin(options.timeout, void 0);
      }
      hasOrigin(origin) {
          return this.pools.has(origin);
      }
      getOriginPool(origin) {
          const pool = this.pools.get(origin);
          if (!pool) {
              const keepAlive = core_1.getByOrigin(this.keepAlive, origin);
              const keepAliveMsecs = core_1.getByOrigin(this.keepAliveMsecs, origin);
              const maxSockets = core_1.getByOrigin(this.maxSockets, origin);
              const maxFreeSockets = core_1.getByOrigin(this.maxFreeSockets, origin);
              const timeout = core_1.getByOrigin(this.timeout, origin);
              const newPool = new OriginPool(keepAlive, keepAliveMsecs, maxSockets, maxFreeSockets, timeout);
              this.pools.set(origin, newPool);
              return newPool;
          }
          return pool;
      }
      async disconnect(origin) {
          const pool = this.pools.get(origin);
          if (pool)
              await pool.disconnectAll();
      }
      async disconnectAll() {
          const pools = [...this.pools.values()];
          await Promise.all(pools.map(pool => pool.disconnectAll()));
      }
  }
  class H1Context {
      constructor(options) {
          this.contextPool = new ContextPool(options);
      }
      getFreeSocketForOrigin(origin) {
          return this.contextPool.hasOrigin(origin)
              ? this.contextPool.getOriginPool(origin).getFreeSocket()
              : { shouldCreateNew: true };
      }
      addUsedSocket(origin, socket) {
          return this.contextPool.getOriginPool(origin).addUsed(socket);
      }
      waitForSocket(origin) {
          return this.contextPool.getOriginPool(origin).waitForSocket();
      }
      connect(url, extraOptions, request) {
          const { origin, protocol, hostname, password, pathname, search, username, } = url;
          const path = pathname + search;
          const port = parseInt(utils_1.parseInput(url.href).port, 10);
          const method = request.method;
          const auth = (username || password)
              ? { auth: `${username}:${password}` }
              : {};
          const options = {
              ...extraOptions,
              agent: false,
              hostname,
              method,
              path,
              port,
              protocol,
              ...auth,
          };
          if (!options.headers)
              options.headers = {};
          options.headers.connection = this.contextPool.keepAlive
              ? "keep-alive"
              : "close";
          return this.contextPool.getOriginPool(origin).connect(options);
      }
      async makeNewConnection(url) {
          return new Promise((resolve, reject) => {
              const { hostname, port } = utils_1.parseInput(url);
              const socket = net_1.createConnection(parseInt(port, 10), hostname, () => {
                  resolve(socket);
              });
              socket.once("error", reject);
              return socket;
          });
      }
      disconnect(url) {
          const { origin } = new url_1.URL(url);
          this.contextPool.disconnect(origin);
      }
      disconnectAll() {
          this.contextPool.disconnectAll();
      }
  }
  exports.H1Context = H1Context;
  //# sourceMappingURL=context-http1.js.map
  
  /***/ }),
  
  /***/ 827:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  // This is adapted from https://github.com/normalize/mz
  // Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors
  const u = __webpack_require__(344).fromCallback
  const fs = __webpack_require__(813)
  
  const api = [
    'access',
    'appendFile',
    'chmod',
    'chown',
    'close',
    'copyFile',
    'fchmod',
    'fchown',
    'fdatasync',
    'fstat',
    'fsync',
    'ftruncate',
    'futimes',
    'lchown',
    'lchmod',
    'link',
    'lstat',
    'mkdir',
    'mkdtemp',
    'open',
    'readFile',
    'readdir',
    'readlink',
    'realpath',
    'rename',
    'rmdir',
    'stat',
    'symlink',
    'truncate',
    'unlink',
    'utimes',
    'writeFile'
  ].filter(key => {
    // Some commands are not available on some systems. Ex:
    // fs.copyFile was added in Node.js v8.5.0
    // fs.mkdtemp was added in Node.js v5.10.0
    // fs.lchown is not available on at least some Linux
    return typeof fs[key] === 'function'
  })
  
  // Export all keys:
  Object.keys(fs).forEach(key => {
    if (key === 'promises') {
      // fs.promises is a getter property that triggers ExperimentalWarning
      // Don't re-export it here, the getter is defined in "lib/index.js"
      return
    }
    exports[key] = fs[key]
  })
  
  // Universalify async methods:
  api.forEach(method => {
    exports[method] = u(fs[method])
  })
  
  // We differ from mz/fs in that we still ship the old, broken, fs.exists()
  // since we are a drop-in replacement for the native module
  exports.exists = function (filename, callback) {
    if (typeof callback === 'function') {
      return fs.exists(filename, callback)
    }
    return new Promise(resolve => {
      return fs.exists(filename, resolve)
    })
  }
  
  // fs.read() & fs.write need special treatment due to multiple callback args
  
  exports.read = function (fd, buffer, offset, length, position, callback) {
    if (typeof callback === 'function') {
      return fs.read(fd, buffer, offset, length, position, callback)
    }
    return new Promise((resolve, reject) => {
      fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => {
        if (err) return reject(err)
        resolve({ bytesRead, buffer })
      })
    })
  }
  
  // Function signature can be
  // fs.write(fd, buffer[, offset[, length[, position]]], callback)
  // OR
  // fs.write(fd, string[, position[, encoding]], callback)
  // We need to handle both cases, so we use ...args
  exports.write = function (fd, buffer, ...args) {
    if (typeof args[args.length - 1] === 'function') {
      return fs.write(fd, buffer, ...args)
    }
  
    return new Promise((resolve, reject) => {
      fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => {
        if (err) return reject(err)
        resolve({ bytesWritten, buffer })
      })
    })
  }
  
  
  /***/ }),
  
  /***/ 832:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var constants = __webpack_require__(938)
  
  var origCwd = process.cwd
  var cwd = null
  
  var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
  
  process.cwd = function() {
    if (!cwd)
      cwd = origCwd.call(process)
    return cwd
  }
  try {
    process.cwd()
  } catch (er) {}
  
  var chdir = process.chdir
  process.chdir = function(d) {
    cwd = null
    chdir.call(process, d)
  }
  
  module.exports = patch
  
  function patch (fs) {
    // (re-)implement some things that are known busted or missing.
  
    // lchmod, broken prior to 0.6.2
    // back-port the fix here.
    if (constants.hasOwnProperty('O_SYMLINK') &&
        process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
      patchLchmod(fs)
    }
  
    // lutimes implementation, or no-op
    if (!fs.lutimes) {
      patchLutimes(fs)
    }
  
    // https://github.com/isaacs/node-graceful-fs/issues/4
    // Chown should not fail on einval or eperm if non-root.
    // It should not fail on enosys ever, as this just indicates
    // that a fs doesn't support the intended operation.
  
    fs.chown = chownFix(fs.chown)
    fs.fchown = chownFix(fs.fchown)
    fs.lchown = chownFix(fs.lchown)
  
    fs.chmod = chmodFix(fs.chmod)
    fs.fchmod = chmodFix(fs.fchmod)
    fs.lchmod = chmodFix(fs.lchmod)
  
    fs.chownSync = chownFixSync(fs.chownSync)
    fs.fchownSync = chownFixSync(fs.fchownSync)
    fs.lchownSync = chownFixSync(fs.lchownSync)
  
    fs.chmodSync = chmodFixSync(fs.chmodSync)
    fs.fchmodSync = chmodFixSync(fs.fchmodSync)
    fs.lchmodSync = chmodFixSync(fs.lchmodSync)
  
    fs.stat = statFix(fs.stat)
    fs.fstat = statFix(fs.fstat)
    fs.lstat = statFix(fs.lstat)
  
    fs.statSync = statFixSync(fs.statSync)
    fs.fstatSync = statFixSync(fs.fstatSync)
    fs.lstatSync = statFixSync(fs.lstatSync)
  
    // if lchmod/lchown do not exist, then make them no-ops
    if (!fs.lchmod) {
      fs.lchmod = function (path, mode, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchmodSync = function () {}
    }
    if (!fs.lchown) {
      fs.lchown = function (path, uid, gid, cb) {
        if (cb) process.nextTick(cb)
      }
      fs.lchownSync = function () {}
    }
  
    // on Windows, A/V software can lock the directory, causing this
    // to fail with an EACCES or EPERM if the directory contains newly
    // created files.  Try again on failure, for up to 60 seconds.
  
    // Set the timeout this long because some Windows Anti-Virus, such as Parity
    // bit9, may lock files for up to a minute, causing npm package install
    // failures. Also, take care to yield the scheduler. Windows scheduling gives
    // CPU to a busy looping process, which can cause the program causing the lock
    // contention to be starved of CPU by node, so the contention doesn't resolve.
    if (platform === "win32") {
      fs.rename = (function (fs$rename) { return function (from, to, cb) {
        var start = Date.now()
        var backoff = 0;
        fs$rename(from, to, function CB (er) {
          if (er
              && (er.code === "EACCES" || er.code === "EPERM")
              && Date.now() - start < 60000) {
            setTimeout(function() {
              fs.stat(to, function (stater, st) {
                if (stater && stater.code === "ENOENT")
                  fs$rename(from, to, CB);
                else
                  cb(er)
              })
            }, backoff)
            if (backoff < 100)
              backoff += 10;
            return;
          }
          if (cb) cb(er)
        })
      }})(fs.rename)
    }
  
    // if read() returns EAGAIN, then just try it again.
    fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
      var callback
      if (callback_ && typeof callback_ === 'function') {
        var eagCounter = 0
        callback = function (er, _, __) {
          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter ++
            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
          }
          callback_.apply(this, arguments)
        }
      }
      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
    }})(fs.read)
  
    fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
      var eagCounter = 0
      while (true) {
        try {
          return fs$readSync.call(fs, fd, buffer, offset, length, position)
        } catch (er) {
          if (er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter ++
            continue
          }
          throw er
        }
      }
    }})(fs.readSync)
  
    function patchLchmod (fs) {
      fs.lchmod = function (path, mode, callback) {
        fs.open( path
               , constants.O_WRONLY | constants.O_SYMLINK
               , mode
               , function (err, fd) {
          if (err) {
            if (callback) callback(err)
            return
          }
          // prefer to return the chmod error, if one occurs,
          // but still try to close, and report closing errors if they occur.
          fs.fchmod(fd, mode, function (err) {
            fs.close(fd, function(err2) {
              if (callback) callback(err || err2)
            })
          })
        })
      }
  
      fs.lchmodSync = function (path, mode) {
        var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
  
        // prefer to return the chmod error, if one occurs,
        // but still try to close, and report closing errors if they occur.
        var threw = true
        var ret
        try {
          ret = fs.fchmodSync(fd, mode)
          threw = false
        } finally {
          if (threw) {
            try {
              fs.closeSync(fd)
            } catch (er) {}
          } else {
            fs.closeSync(fd)
          }
        }
        return ret
      }
    }
  
    function patchLutimes (fs) {
      if (constants.hasOwnProperty("O_SYMLINK")) {
        fs.lutimes = function (path, at, mt, cb) {
          fs.open(path, constants.O_SYMLINK, function (er, fd) {
            if (er) {
              if (cb) cb(er)
              return
            }
            fs.futimes(fd, at, mt, function (er) {
              fs.close(fd, function (er2) {
                if (cb) cb(er || er2)
              })
            })
          })
        }
  
        fs.lutimesSync = function (path, at, mt) {
          var fd = fs.openSync(path, constants.O_SYMLINK)
          var ret
          var threw = true
          try {
            ret = fs.futimesSync(fd, at, mt)
            threw = false
          } finally {
            if (threw) {
              try {
                fs.closeSync(fd)
              } catch (er) {}
            } else {
              fs.closeSync(fd)
            }
          }
          return ret
        }
  
      } else {
        fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
        fs.lutimesSync = function () {}
      }
    }
  
    function chmodFix (orig) {
      if (!orig) return orig
      return function (target, mode, cb) {
        return orig.call(fs, target, mode, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chmodFixSync (orig) {
      if (!orig) return orig
      return function (target, mode) {
        try {
          return orig.call(fs, target, mode)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
  
    function chownFix (orig) {
      if (!orig) return orig
      return function (target, uid, gid, cb) {
        return orig.call(fs, target, uid, gid, function (er) {
          if (chownErOk(er)) er = null
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function chownFixSync (orig) {
      if (!orig) return orig
      return function (target, uid, gid) {
        try {
          return orig.call(fs, target, uid, gid)
        } catch (er) {
          if (!chownErOk(er)) throw er
        }
      }
    }
  
  
    function statFix (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target, cb) {
        return orig.call(fs, target, function (er, stats) {
          if (!stats) return cb.apply(this, arguments)
          if (stats.uid < 0) stats.uid += 0x100000000
          if (stats.gid < 0) stats.gid += 0x100000000
          if (cb) cb.apply(this, arguments)
        })
      }
    }
  
    function statFixSync (orig) {
      if (!orig) return orig
      // Older versions of Node erroneously returned signed integers for
      // uid + gid.
      return function (target) {
        var stats = orig.call(fs, target)
        if (stats.uid < 0) stats.uid += 0x100000000
        if (stats.gid < 0) stats.gid += 0x100000000
        return stats;
      }
    }
  
    // ENOSYS means that the fs doesn't support the op. Just ignore
    // that, because it doesn't matter.
    //
    // if there's no getuid, or if getuid() is something other
    // than 0, and the error is EINVAL or EPERM, then just ignore
    // it.
    //
    // This specific case is a silent failure in cp, install, tar,
    // and most other unix tools that manage permissions.
    //
    // When running as root, or if other types of errors are
    // encountered, then it's strict.
    function chownErOk (er) {
      if (!er)
        return true
  
      if (er.code === "ENOSYS")
        return true
  
      var nonroot = !process.getuid || process.getuid() !== 0
      if (nonroot) {
        if (er.code === "EINVAL" || er.code === "EPERM")
          return true
      }
  
      return false
    }
  }
  
  
  /***/ }),
  
  /***/ 837:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const tough_cookie_1 = __webpack_require__(105);
  class CookieJar {
      constructor(jar = new tough_cookie_1.CookieJar()) {
          this._jar = jar;
      }
      reset(jar = new tough_cookie_1.CookieJar()) {
          this._jar = jar;
      }
      setCookie(cookie, url) {
          return new Promise((resolve, reject) => {
              this._jar.setCookie(cookie, url, (err, cookie) => {
                  if (err)
                      return reject(err);
                  resolve(cookie);
              });
          });
      }
      setCookies(cookies, url) {
          return Promise.all(cookies.map(cookie => this.setCookie(cookie, url)));
      }
      getCookies(url) {
          return new Promise((resolve, reject) => {
              this._jar.getCookies(url, (err, cookies) => {
                  if (err)
                      return reject(err);
                  resolve(cookies);
              });
          });
      }
  }
  exports.CookieJar = CookieJar;
  //# sourceMappingURL=cookie-jar.js.map
  
  /***/ }),
  
  /***/ 840:
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = clone
  
  function clone (obj) {
    if (obj === null || typeof obj !== 'object')
      return obj
  
    if (obj instanceof Object)
      var copy = { __proto__: obj.__proto__ }
    else
      var copy = Object.create(null)
  
    Object.getOwnPropertyNames(obj).forEach(function (key) {
      Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
    })
  
    return copy
  }
  
  
  /***/ }),
  
  /***/ 845:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
  var __asyncValues = (this && this.__asyncValues) || function (o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  };
  var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const fs_1 = __webpack_require__(66);
  const async_retry_1 = __importDefault(__webpack_require__(380));
  const utils_1 = __webpack_require__(512);
  const _1 = __webpack_require__(174);
  const deploy_1 = __importDefault(__webpack_require__(323));
  function upload(files, options) {
      return __asyncGenerator(this, arguments, function* upload_1() {
          var e_1, _a, e_2, _b;
          const { token, teamId } = options;
          if (!files && !token && !teamId) {
              return yield __await(void 0);
          }
          let missingFiles = [];
          try {
              for (var _c = __asyncValues(deploy_1.default(files, options)), _d; _d = yield __await(_c.next()), !_d.done;) {
                  const event = _d.value;
                  if (event.type === 'error') {
                      if (event.payload.code === 'missing_files') {
                          missingFiles = event.payload.missing;
                      }
                      else {
                          return yield __await(yield yield __await(event));
                      }
                  }
                  else {
                      // If the deployment has succeeded here, don't continue
                      if (event.type === 'ready') {
                          return yield __await(yield yield __await(event));
                      }
                      yield yield __await(event);
                  }
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_d && !_d.done && (_a = _c.return)) yield __await(_a.call(_c));
              }
              finally { if (e_1) throw e_1.error; }
          }
          const shas = missingFiles;
          const uploadList = {};
          shas.map((sha) => {
              uploadList[sha] = async_retry_1.default(async (bail) => {
                  const file = files.get(sha);
                  if (!file) {
                      return bail(new Error(`File ${sha} is undefined`));
                  }
                  const fPath = file.names[0];
                  const stream = fs_1.createReadStream(fPath);
                  const { data } = file;
                  const fstreamPush = stream.push;
                  let uploadedSoFar = 0;
                  // let lastEvent = 0
                  stream.push = (chunk) => {
                      // If we're about to push the last chunk, then don't do it here
                      // But instead, we'll "hang" the progress bar and do it on 200
                      if (chunk && uploadedSoFar + chunk.length < data.length) {
                          uploadedSoFar += chunk.length;
                          // semaphore.release()
                      }
                      return fstreamPush.call(stream, chunk);
                  };
                  // while (uploadedSoFar !== file.data.length) {
                  //   await semaphore.acquire()
                  //   lastEvent = uploadedSoFar;
                  //   yield uploadedSoFar;
                  // }
                  let err;
                  let result;
                  try {
                      const res = await utils_1.fetch(utils_1.API_FILES, token, {
                          method: 'POST',
                          headers: {
                              'Content-Type': 'application/octet-stream',
                              'x-now-digest': sha,
                              'x-now-length': data.length,
                          },
                          body: stream,
                          teamId
                      });
                      if (res.status === 200) {
                          result = {
                              type: 'file-uploaded',
                              payload: { sha, file }
                          };
                      }
                      else if (res.status > 200 && res.status < 500) {
                          // If something is wrong with our request, we don't retry
                          const { error } = await res.json();
                          err = new _1.DeploymentError(error);
                      }
                      else {
                          // If something is wrong with the server, we retry
                          const { error } = await res.json();
                          throw new _1.DeploymentError(error);
                      }
                  }
                  catch (e) {
                      err = new Error(e);
                  }
                  finally {
                      stream.close();
                      stream.destroy();
                  }
                  if (err) {
                      return bail(err);
                  }
                  return result;
              }, {
                  retries: 6,
                  randomize: true
              });
          });
          while (Object.keys(uploadList).length > 0) {
              try {
                  const event = yield __await(Promise.race(Object.keys(uploadList).map((key) => uploadList[key])));
                  delete uploadList[event.payload.sha];
                  yield yield __await(event);
              }
              catch (e) {
                  return yield __await(yield yield __await({ type: 'error', payload: e }));
              }
          }
          yield yield __await({ type: 'all-files-uploaded', payload: files });
          try {
              try {
                  for (var _e = __asyncValues(deploy_1.default(files, options)), _f; _f = yield __await(_e.next()), !_f.done;) {
                      const event = _f.value;
                      if (event.type === 'ready') {
                          return yield __await(yield yield __await(event));
                      }
                      yield yield __await(event);
                  }
              }
              catch (e_2_1) { e_2 = { error: e_2_1 }; }
              finally {
                  try {
                      if (_f && !_f.done && (_b = _e.return)) yield __await(_b.call(_e));
                  }
                  finally { if (e_2) throw e_2.error; }
              }
          }
          catch (e) {
              yield yield __await({ type: 'error', payload: e });
          }
      });
  }
  exports.default = upload;
  
  
  /***/ }),
  
  /***/ 849:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  // TODO: enable this once graceful-fs supports bigint option.
  // const fs = require('graceful-fs')
  const fs = __webpack_require__(66)
  const path = __webpack_require__(589)
  const copy = __webpack_require__(381).copy
  const remove = __webpack_require__(812).remove
  const mkdirp = __webpack_require__(562).mkdirp
  const pathExists = __webpack_require__(734).pathExists
  const stat = __webpack_require__(150)
  
  function move (src, dest, opts, cb) {
    if (typeof opts === 'function') {
      cb = opts
      opts = {}
    }
  
    const overwrite = opts.overwrite || opts.clobber || false
  
    stat.checkPaths(src, dest, 'move', (err, stats) => {
      if (err) return cb(err)
      const { srcStat } = stats
      stat.checkParentPaths(src, srcStat, dest, 'move', err => {
        if (err) return cb(err)
        mkdirp(path.dirname(dest), err => {
          if (err) return cb(err)
          return doRename(src, dest, overwrite, cb)
        })
      })
    })
  }
  
  function doRename (src, dest, overwrite, cb) {
    if (overwrite) {
      return remove(dest, err => {
        if (err) return cb(err)
        return rename(src, dest, overwrite, cb)
      })
    }
    pathExists(dest, (err, destExists) => {
      if (err) return cb(err)
      if (destExists) return cb(new Error('dest already exists.'))
      return rename(src, dest, overwrite, cb)
    })
  }
  
  function rename (src, dest, overwrite, cb) {
    fs.rename(src, dest, err => {
      if (!err) return cb()
      if (err.code !== 'EXDEV') return cb(err)
      return moveAcrossDevice(src, dest, overwrite, cb)
    })
  }
  
  function moveAcrossDevice (src, dest, overwrite, cb) {
    const opts = {
      overwrite,
      errorOnExist: true
    }
    copy(src, dest, opts, err => {
      if (err) return cb(err)
      return remove(src, cb)
    })
  }
  
  module.exports = move
  
  
  /***/ }),
  
  /***/ 854:
  /***/ (function(module) {
  
  "use strict";
  
  
  const codes = {};
  
  function createErrorType(code, message, Base) {
    if (!Base) {
      Base = Error
    }
  
    function getMessage (arg1, arg2, arg3) {
      if (typeof message === 'string') {
        return message
      } else {
        return message(arg1, arg2, arg3)
      }
    }
  
    class NodeError extends Base {
      constructor (arg1, arg2, arg3) {
        super(getMessage(arg1, arg2, arg3));
      }
    }
  
    NodeError.prototype.name = Base.name;
    NodeError.prototype.code = code;
  
    codes[code] = NodeError;
  }
  
  // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
  function oneOf(expected, thing) {
    if (Array.isArray(expected)) {
      const len = expected.length;
      expected = expected.map((i) => String(i));
      if (len > 2) {
        return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
               expected[len - 1];
      } else if (len === 2) {
        return `one of ${thing} ${expected[0]} or ${expected[1]}`;
      } else {
        return `of ${thing} ${expected[0]}`;
      }
    } else {
      return `of ${thing} ${String(expected)}`;
    }
  }
  
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
  function startsWith(str, search, pos) {
  	return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
  }
  
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
  function endsWith(str, search, this_len) {
  	if (this_len === undefined || this_len > str.length) {
  		this_len = str.length;
  	}
  	return str.substring(this_len - search.length, this_len) === search;
  }
  
  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
  function includes(str, search, start) {
    if (typeof start !== 'number') {
      start = 0;
    }
  
    if (start + search.length > str.length) {
      return false;
    } else {
      return str.indexOf(search, start) !== -1;
    }
  }
  
  createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
    return 'The value "' + value + '" is invalid for option "' + name + '"'
  }, TypeError);
  createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
    // determiner: 'must be' or 'must not be'
    let determiner;
    if (typeof expected === 'string' && startsWith(expected, 'not ')) {
      determiner = 'must not be';
      expected = expected.replace(/^not /, '');
    } else {
      determiner = 'must be';
    }
  
    let msg;
    if (endsWith(name, ' argument')) {
      // For cases like 'first argument'
      msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
    } else {
      const type = includes(name, '.') ? 'property' : 'argument';
      msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
    }
  
    msg += `. Received type ${typeof actual}`;
    return msg;
  }, TypeError);
  createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
  createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
    return 'The ' + name + ' method is not implemented'
  });
  createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
  createErrorType('ERR_STREAM_DESTROYED', function (name) {
    return 'Cannot call ' + name + ' after a stream was destroyed';
  });
  createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
  createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
  createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
  createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
  createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
    return 'Unknown encoding: ' + arg
  }, TypeError);
  createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
  
  module.exports.codes = codes;
  
  
  /***/ }),
  
  /***/ 861:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  // Ported from https://github.com/mafintosh/pump with
  // permission from the author, Mathias Buus (@mafintosh).
  
  
  var eos;
  
  function once(callback) {
    var called = false;
    return function () {
      if (called) return;
      called = true;
      callback.apply(void 0, arguments);
    };
  }
  
  var _require$codes = __webpack_require__(854).codes,
      ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
      ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
  
  function noop(err) {
    // Rethrow the error if it exists to avoid swallowing it
    if (err) throw err;
  }
  
  function isRequest(stream) {
    return stream.setHeader && typeof stream.abort === 'function';
  }
  
  function destroyer(stream, reading, writing, callback) {
    callback = once(callback);
    var closed = false;
    stream.on('close', function () {
      closed = true;
    });
    if (eos === undefined) eos = __webpack_require__(744);
    eos(stream, {
      readable: reading,
      writable: writing
    }, function (err) {
      if (err) return callback(err);
      closed = true;
      callback();
    });
    var destroyed = false;
    return function (err) {
      if (closed) return;
      if (destroyed) return;
      destroyed = true; // request.destroy just do .end - .abort is what we want
  
      if (isRequest(stream)) return stream.abort();
      if (typeof stream.destroy === 'function') return stream.destroy();
      callback(err || new ERR_STREAM_DESTROYED('pipe'));
    };
  }
  
  function call(fn) {
    fn();
  }
  
  function pipe(from, to) {
    return from.pipe(to);
  }
  
  function popCallback(streams) {
    if (!streams.length) return noop;
    if (typeof streams[streams.length - 1] !== 'function') return noop;
    return streams.pop();
  }
  
  function pipeline() {
    for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
      streams[_key] = arguments[_key];
    }
  
    var callback = popCallback(streams);
    if (Array.isArray(streams[0])) streams = streams[0];
  
    if (streams.length < 2) {
      throw new ERR_MISSING_ARGS('streams');
    }
  
    var error;
    var destroys = streams.map(function (stream, i) {
      var reading = i < streams.length - 1;
      var writing = i > 0;
      return destroyer(stream, reading, writing, function (err) {
        if (!error) error = err;
        if (err) destroys.forEach(call);
        if (reading) return;
        destroys.forEach(call);
        callback(error);
      });
    });
    return streams.reduce(pipe);
  }
  
  module.exports = pipeline;
  
  /***/ }),
  
  /***/ 874:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var Transform = __webpack_require__(592).Transform
    , inherits  = __webpack_require__(64).inherits
  
  function DestroyableTransform(opts) {
    Transform.call(this, opts)
    this._destroyed = false
  }
  
  inherits(DestroyableTransform, Transform)
  
  DestroyableTransform.prototype.destroy = function(err) {
    if (this._destroyed) return
    this._destroyed = true
    
    var self = this
    process.nextTick(function() {
      if (err)
        self.emit('error', err)
      self.emit('close')
    })
  }
  
  // a noop _transform function
  function noop (chunk, enc, callback) {
    callback(null, chunk)
  }
  
  
  // create a new export function, used by both the main export and
  // the .ctor export, contains common logic for dealing with arguments
  function through2 (construct) {
    return function (options, transform, flush) {
      if (typeof options == 'function') {
        flush     = transform
        transform = options
        options   = {}
      }
  
      if (typeof transform != 'function')
        transform = noop
  
      if (typeof flush != 'function')
        flush = null
  
      return construct(options, transform, flush)
    }
  }
  
  
  // main export, just make me a transform stream!
  module.exports = through2(function (options, transform, flush) {
    var t2 = new DestroyableTransform(options)
  
    t2._transform = transform
  
    if (flush)
      t2._flush = flush
  
    return t2
  })
  
  
  // make me a reusable prototype that I can `new`, or implicitly `new`
  // with a constructor call
  module.exports.ctor = through2(function (options, transform, flush) {
    function Through2 (override) {
      if (!(this instanceof Through2))
        return new Through2(override)
  
      this.options = Object.assign({}, options, override)
  
      DestroyableTransform.call(this, this.options)
    }
  
    inherits(Through2, DestroyableTransform)
  
    Through2.prototype._transform = transform
  
    if (flush)
      Through2.prototype._flush = flush
  
    return Through2
  })
  
  
  module.exports.obj = through2(function (options, transform, flush) {
    var t2 = new DestroyableTransform(Object.assign({ objectMode: true, highWaterMark: 16 }, options))
  
    t2._transform = transform
  
    if (flush)
      t2._flush = flush
  
    return t2
  })
  
  
  /***/ }),
  
  /***/ 875:
  /***/ (function(module) {
  
  module.exports = ["ac","com.ac","edu.ac","gov.ac","net.ac","mil.ac","org.ac","ad","nom.ad","ae","co.ae","net.ae","org.ae","sch.ae","ac.ae","gov.ae","mil.ae","aero","accident-investigation.aero","accident-prevention.aero","aerobatic.aero","aeroclub.aero","aerodrome.aero","agents.aero","aircraft.aero","airline.aero","airport.aero","air-surveillance.aero","airtraffic.aero","air-traffic-control.aero","ambulance.aero","amusement.aero","association.aero","author.aero","ballooning.aero","broker.aero","caa.aero","cargo.aero","catering.aero","certification.aero","championship.aero","charter.aero","civilaviation.aero","club.aero","conference.aero","consultant.aero","consulting.aero","control.aero","council.aero","crew.aero","design.aero","dgca.aero","educator.aero","emergency.aero","engine.aero","engineer.aero","entertainment.aero","equipment.aero","exchange.aero","express.aero","federation.aero","flight.aero","freight.aero","fuel.aero","gliding.aero","government.aero","groundhandling.aero","group.aero","hanggliding.aero","homebuilt.aero","insurance.aero","journal.aero","journalist.aero","leasing.aero","logistics.aero","magazine.aero","maintenance.aero","media.aero","microlight.aero","modelling.aero","navigation.aero","parachuting.aero","paragliding.aero","passenger-association.aero","pilot.aero","press.aero","production.aero","recreation.aero","repbody.aero","res.aero","research.aero","rotorcraft.aero","safety.aero","scientist.aero","services.aero","show.aero","skydiving.aero","software.aero","student.aero","trader.aero","trading.aero","trainer.aero","union.aero","workinggroup.aero","works.aero","af","gov.af","com.af","org.af","net.af","edu.af","ag","com.ag","org.ag","net.ag","co.ag","nom.ag","ai","off.ai","com.ai","net.ai","org.ai","al","com.al","edu.al","gov.al","mil.al","net.al","org.al","am","co.am","com.am","commune.am","net.am","org.am","ao","ed.ao","gv.ao","og.ao","co.ao","pb.ao","it.ao","aq","ar","com.ar","edu.ar","gob.ar","gov.ar","int.ar","mil.ar","musica.ar","net.ar","org.ar","tur.ar","arpa","e164.arpa","in-addr.arpa","ip6.arpa","iris.arpa","uri.arpa","urn.arpa","as","gov.as","asia","at","ac.at","co.at","gv.at","or.at","au","com.au","net.au","org.au","edu.au","gov.au","asn.au","id.au","info.au","conf.au","oz.au","act.au","nsw.au","nt.au","qld.au","sa.au","tas.au","vic.au","wa.au","act.edu.au","nsw.edu.au","nt.edu.au","qld.edu.au","sa.edu.au","tas.edu.au","vic.edu.au","wa.edu.au","qld.gov.au","sa.gov.au","tas.gov.au","vic.gov.au","wa.gov.au","aw","com.aw","ax","az","com.az","net.az","int.az","gov.az","org.az","edu.az","info.az","pp.az","mil.az","name.az","pro.az","biz.az","ba","com.ba","edu.ba","gov.ba","mil.ba","net.ba","org.ba","bb","biz.bb","co.bb","com.bb","edu.bb","gov.bb","info.bb","net.bb","org.bb","store.bb","tv.bb","*.bd","be","ac.be","bf","gov.bf","bg","a.bg","b.bg","c.bg","d.bg","e.bg","f.bg","g.bg","h.bg","i.bg","j.bg","k.bg","l.bg","m.bg","n.bg","o.bg","p.bg","q.bg","r.bg","s.bg","t.bg","u.bg","v.bg","w.bg","x.bg","y.bg","z.bg","0.bg","1.bg","2.bg","3.bg","4.bg","5.bg","6.bg","7.bg","8.bg","9.bg","bh","com.bh","edu.bh","net.bh","org.bh","gov.bh","bi","co.bi","com.bi","edu.bi","or.bi","org.bi","biz","bj","asso.bj","barreau.bj","gouv.bj","bm","com.bm","edu.bm","gov.bm","net.bm","org.bm","bn","com.bn","edu.bn","gov.bn","net.bn","org.bn","bo","com.bo","edu.bo","gob.bo","int.bo","org.bo","net.bo","mil.bo","tv.bo","web.bo","academia.bo","agro.bo","arte.bo","blog.bo","bolivia.bo","ciencia.bo","cooperativa.bo","democracia.bo","deporte.bo","ecologia.bo","economia.bo","empresa.bo","indigena.bo","industria.bo","info.bo","medicina.bo","movimiento.bo","musica.bo","natural.bo","nombre.bo","noticias.bo","patria.bo","politica.bo","profesional.bo","plurinacional.bo","pueblo.bo","revista.bo","salud.bo","tecnologia.bo","tksat.bo","transporte.bo","wiki.bo","br","9guacu.br","abc.br","adm.br","adv.br","agr.br","aju.br","am.br","anani.br","aparecida.br","arq.br","art.br","ato.br","b.br","barueri.br","belem.br","bhz.br","bio.br","blog.br","bmd.br","boavista.br","bsb.br","campinagrande.br","campinas.br","caxias.br","cim.br","cng.br","cnt.br","com.br","contagem.br","coop.br","cri.br","cuiaba.br","curitiba.br","def.br","ecn.br","eco.br","edu.br","emp.br","eng.br","esp.br","etc.br","eti.br","far.br","feira.br","flog.br","floripa.br","fm.br","fnd.br","fortal.br","fot.br","foz.br","fst.br","g12.br","ggf.br","goiania.br","gov.br","ac.gov.br","al.gov.br","am.gov.br","ap.gov.br","ba.gov.br","ce.gov.br","df.gov.br","es.gov.br","go.gov.br","ma.gov.br","mg.gov.br","ms.gov.br","mt.gov.br","pa.gov.br","pb.gov.br","pe.gov.br","pi.gov.br","pr.gov.br","rj.gov.br","rn.gov.br","ro.gov.br","rr.gov.br","rs.gov.br","sc.gov.br","se.gov.br","sp.gov.br","to.gov.br","gru.br","imb.br","ind.br","inf.br","jab.br","jampa.br","jdf.br","joinville.br","jor.br","jus.br","leg.br","lel.br","londrina.br","macapa.br","maceio.br","manaus.br","maringa.br","mat.br","med.br","mil.br","morena.br","mp.br","mus.br","natal.br","net.br","niteroi.br","*.nom.br","not.br","ntr.br","odo.br","ong.br","org.br","osasco.br","palmas.br","poa.br","ppg.br","pro.br","psc.br","psi.br","pvh.br","qsl.br","radio.br","rec.br","recife.br","ribeirao.br","rio.br","riobranco.br","riopreto.br","salvador.br","sampa.br","santamaria.br","santoandre.br","saobernardo.br","saogonca.br","sjc.br","slg.br","slz.br","sorocaba.br","srv.br","taxi.br","tc.br","teo.br","the.br","tmp.br","trd.br","tur.br","tv.br","udi.br","vet.br","vix.br","vlog.br","wiki.br","zlg.br","bs","com.bs","net.bs","org.bs","edu.bs","gov.bs","bt","com.bt","edu.bt","gov.bt","net.bt","org.bt","bv","bw","co.bw","org.bw","by","gov.by","mil.by","com.by","of.by","bz","com.bz","net.bz","org.bz","edu.bz","gov.bz","ca","ab.ca","bc.ca","mb.ca","nb.ca","nf.ca","nl.ca","ns.ca","nt.ca","nu.ca","on.ca","pe.ca","qc.ca","sk.ca","yk.ca","gc.ca","cat","cc","cd","gov.cd","cf","cg","ch","ci","org.ci","or.ci","com.ci","co.ci","edu.ci","ed.ci","ac.ci","net.ci","go.ci","asso.ci","aéroport.ci","int.ci","presse.ci","md.ci","gouv.ci","*.ck","!www.ck","cl","gov.cl","gob.cl","co.cl","mil.cl","cm","co.cm","com.cm","gov.cm","net.cm","cn","ac.cn","com.cn","edu.cn","gov.cn","net.cn","org.cn","mil.cn","公司.cn","网络.cn","網絡.cn","ah.cn","bj.cn","cq.cn","fj.cn","gd.cn","gs.cn","gz.cn","gx.cn","ha.cn","hb.cn","he.cn","hi.cn","hl.cn","hn.cn","jl.cn","js.cn","jx.cn","ln.cn","nm.cn","nx.cn","qh.cn","sc.cn","sd.cn","sh.cn","sn.cn","sx.cn","tj.cn","xj.cn","xz.cn","yn.cn","zj.cn","hk.cn","mo.cn","tw.cn","co","arts.co","com.co","edu.co","firm.co","gov.co","info.co","int.co","mil.co","net.co","nom.co","org.co","rec.co","web.co","com","coop","cr","ac.cr","co.cr","ed.cr","fi.cr","go.cr","or.cr","sa.cr","cu","com.cu","edu.cu","org.cu","net.cu","gov.cu","inf.cu","cv","cw","com.cw","edu.cw","net.cw","org.cw","cx","gov.cx","cy","ac.cy","biz.cy","com.cy","ekloges.cy","gov.cy","ltd.cy","name.cy","net.cy","org.cy","parliament.cy","press.cy","pro.cy","tm.cy","cz","de","dj","dk","dm","com.dm","net.dm","org.dm","edu.dm","gov.dm","do","art.do","com.do","edu.do","gob.do","gov.do","mil.do","net.do","org.do","sld.do","web.do","dz","com.dz","org.dz","net.dz","gov.dz","edu.dz","asso.dz","pol.dz","art.dz","ec","com.ec","info.ec","net.ec","fin.ec","k12.ec","med.ec","pro.ec","org.ec","edu.ec","gov.ec","gob.ec","mil.ec","edu","ee","edu.ee","gov.ee","riik.ee","lib.ee","med.ee","com.ee","pri.ee","aip.ee","org.ee","fie.ee","eg","com.eg","edu.eg","eun.eg","gov.eg","mil.eg","name.eg","net.eg","org.eg","sci.eg","*.er","es","com.es","nom.es","org.es","gob.es","edu.es","et","com.et","gov.et","org.et","edu.et","biz.et","name.et","info.et","net.et","eu","fi","aland.fi","*.fj","*.fk","fm","fo","fr","asso.fr","com.fr","gouv.fr","nom.fr","prd.fr","tm.fr","aeroport.fr","avocat.fr","avoues.fr","cci.fr","chambagri.fr","chirurgiens-dentistes.fr","experts-comptables.fr","geometre-expert.fr","greta.fr","huissier-justice.fr","medecin.fr","notaires.fr","pharmacien.fr","port.fr","veterinaire.fr","ga","gb","gd","ge","com.ge","edu.ge","gov.ge","org.ge","mil.ge","net.ge","pvt.ge","gf","gg","co.gg","net.gg","org.gg","gh","com.gh","edu.gh","gov.gh","org.gh","mil.gh","gi","com.gi","ltd.gi","gov.gi","mod.gi","edu.gi","org.gi","gl","co.gl","com.gl","edu.gl","net.gl","org.gl","gm","gn","ac.gn","com.gn","edu.gn","gov.gn","org.gn","net.gn","gov","gp","com.gp","net.gp","mobi.gp","edu.gp","org.gp","asso.gp","gq","gr","com.gr","edu.gr","net.gr","org.gr","gov.gr","gs","gt","com.gt","edu.gt","gob.gt","ind.gt","mil.gt","net.gt","org.gt","gu","com.gu","edu.gu","gov.gu","guam.gu","info.gu","net.gu","org.gu","web.gu","gw","gy","co.gy","com.gy","edu.gy","gov.gy","net.gy","org.gy","hk","com.hk","edu.hk","gov.hk","idv.hk","net.hk","org.hk","公司.hk","教育.hk","敎育.hk","政府.hk","個人.hk","个人.hk","箇人.hk","網络.hk","网络.hk","组織.hk","網絡.hk","网絡.hk","组织.hk","組織.hk","組织.hk","hm","hn","com.hn","edu.hn","org.hn","net.hn","mil.hn","gob.hn","hr","iz.hr","from.hr","name.hr","com.hr","ht","com.ht","shop.ht","firm.ht","info.ht","adult.ht","net.ht","pro.ht","org.ht","med.ht","art.ht","coop.ht","pol.ht","asso.ht","edu.ht","rel.ht","gouv.ht","perso.ht","hu","co.hu","info.hu","org.hu","priv.hu","sport.hu","tm.hu","2000.hu","agrar.hu","bolt.hu","casino.hu","city.hu","erotica.hu","erotika.hu","film.hu","forum.hu","games.hu","hotel.hu","ingatlan.hu","jogasz.hu","konyvelo.hu","lakas.hu","media.hu","news.hu","reklam.hu","sex.hu","shop.hu","suli.hu","szex.hu","tozsde.hu","utazas.hu","video.hu","id","ac.id","biz.id","co.id","desa.id","go.id","mil.id","my.id","net.id","or.id","ponpes.id","sch.id","web.id","ie","gov.ie","il","ac.il","co.il","gov.il","idf.il","k12.il","muni.il","net.il","org.il","im","ac.im","co.im","com.im","ltd.co.im","net.im","org.im","plc.co.im","tt.im","tv.im","in","co.in","firm.in","net.in","org.in","gen.in","ind.in","nic.in","ac.in","edu.in","res.in","gov.in","mil.in","info","int","eu.int","io","com.io","iq","gov.iq","edu.iq","mil.iq","com.iq","org.iq","net.iq","ir","ac.ir","co.ir","gov.ir","id.ir","net.ir","org.ir","sch.ir","ایران.ir","ايران.ir","is","net.is","com.is","edu.is","gov.is","org.is","int.is","it","gov.it","edu.it","abr.it","abruzzo.it","aosta-valley.it","aostavalley.it","bas.it","basilicata.it","cal.it","calabria.it","cam.it","campania.it","emilia-romagna.it","emiliaromagna.it","emr.it","friuli-v-giulia.it","friuli-ve-giulia.it","friuli-vegiulia.it","friuli-venezia-giulia.it","friuli-veneziagiulia.it","friuli-vgiulia.it","friuliv-giulia.it","friulive-giulia.it","friulivegiulia.it","friulivenezia-giulia.it","friuliveneziagiulia.it","friulivgiulia.it","fvg.it","laz.it","lazio.it","lig.it","liguria.it","lom.it","lombardia.it","lombardy.it","lucania.it","mar.it","marche.it","mol.it","molise.it","piedmont.it","piemonte.it","pmn.it","pug.it","puglia.it","sar.it","sardegna.it","sardinia.it","sic.it","sicilia.it","sicily.it","taa.it","tos.it","toscana.it","trentin-sud-tirol.it","trentin-süd-tirol.it","trentin-sudtirol.it","trentin-südtirol.it","trentin-sued-tirol.it","trentin-suedtirol.it","trentino-a-adige.it","trentino-aadige.it","trentino-alto-adige.it","trentino-altoadige.it","trentino-s-tirol.it","trentino-stirol.it","trentino-sud-tirol.it","trentino-süd-tirol.it","trentino-sudtirol.it","trentino-südtirol.it","trentino-sued-tirol.it","trentino-suedtirol.it","trentino.it","trentinoa-adige.it","trentinoaadige.it","trentinoalto-adige.it","trentinoaltoadige.it","trentinos-tirol.it","trentinostirol.it","trentinosud-tirol.it","trentinosüd-tirol.it","trentinosudtirol.it","trentinosüdtirol.it","trentinosued-tirol.it","trentinosuedtirol.it","trentinsud-tirol.it","trentinsüd-tirol.it","trentinsudtirol.it","trentinsüdtirol.it","trentinsued-tirol.it","trentinsuedtirol.it","tuscany.it","umb.it","umbria.it","val-d-aosta.it","val-daosta.it","vald-aosta.it","valdaosta.it","valle-aosta.it","valle-d-aosta.it","valle-daosta.it","valleaosta.it","valled-aosta.it","valledaosta.it","vallee-aoste.it","vallée-aoste.it","vallee-d-aoste.it","vallée-d-aoste.it","valleeaoste.it","valléeaoste.it","valleedaoste.it","valléedaoste.it","vao.it","vda.it","ven.it","veneto.it","ag.it","agrigento.it","al.it","alessandria.it","alto-adige.it","altoadige.it","an.it","ancona.it","andria-barletta-trani.it","andria-trani-barletta.it","andriabarlettatrani.it","andriatranibarletta.it","ao.it","aosta.it","aoste.it","ap.it","aq.it","aquila.it","ar.it","arezzo.it","ascoli-piceno.it","ascolipiceno.it","asti.it","at.it","av.it","avellino.it","ba.it","balsan-sudtirol.it","balsan-südtirol.it","balsan-suedtirol.it","balsan.it","bari.it","barletta-trani-andria.it","barlettatraniandria.it","belluno.it","benevento.it","bergamo.it","bg.it","bi.it","biella.it","bl.it","bn.it","bo.it","bologna.it","bolzano-altoadige.it","bolzano.it","bozen-sudtirol.it","bozen-südtirol.it","bozen-suedtirol.it","bozen.it","br.it","brescia.it","brindisi.it","bs.it","bt.it","bulsan-sudtirol.it","bulsan-südtirol.it","bulsan-suedtirol.it","bulsan.it","bz.it","ca.it","cagliari.it","caltanissetta.it","campidano-medio.it","campidanomedio.it","campobasso.it","carbonia-iglesias.it","carboniaiglesias.it","carrara-massa.it","carraramassa.it","caserta.it","catania.it","catanzaro.it","cb.it","ce.it","cesena-forli.it","cesena-forlì.it","cesenaforli.it","cesenaforlì.it","ch.it","chieti.it","ci.it","cl.it","cn.it","co.it","como.it","cosenza.it","cr.it","cremona.it","crotone.it","cs.it","ct.it","cuneo.it","cz.it","dell-ogliastra.it","dellogliastra.it","en.it","enna.it","fc.it","fe.it","fermo.it","ferrara.it","fg.it","fi.it","firenze.it","florence.it","fm.it","foggia.it","forli-cesena.it","forlì-cesena.it","forlicesena.it","forlìcesena.it","fr.it","frosinone.it","ge.it","genoa.it","genova.it","go.it","gorizia.it","gr.it","grosseto.it","iglesias-carbonia.it","iglesiascarbonia.it","im.it","imperia.it","is.it","isernia.it","kr.it","la-spezia.it","laquila.it","laspezia.it","latina.it","lc.it","le.it","lecce.it","lecco.it","li.it","livorno.it","lo.it","lodi.it","lt.it","lu.it","lucca.it","macerata.it","mantova.it","massa-carrara.it","massacarrara.it","matera.it","mb.it","mc.it","me.it","medio-campidano.it","mediocampidano.it","messina.it","mi.it","milan.it","milano.it","mn.it","mo.it","modena.it","monza-brianza.it","monza-e-della-brianza.it","monza.it","monzabrianza.it","monzaebrianza.it","monzaedellabrianza.it","ms.it","mt.it","na.it","naples.it","napoli.it","no.it","novara.it","nu.it","nuoro.it","og.it","ogliastra.it","olbia-tempio.it","olbiatempio.it","or.it","oristano.it","ot.it","pa.it","padova.it","padua.it","palermo.it","parma.it","pavia.it","pc.it","pd.it","pe.it","perugia.it","pesaro-urbino.it","pesarourbino.it","pescara.it","pg.it","pi.it","piacenza.it","pisa.it","pistoia.it","pn.it","po.it","pordenone.it","potenza.it","pr.it","prato.it","pt.it","pu.it","pv.it","pz.it","ra.it","ragusa.it","ravenna.it","rc.it","re.it","reggio-calabria.it","reggio-emilia.it","reggiocalabria.it","reggioemilia.it","rg.it","ri.it","rieti.it","rimini.it","rm.it","rn.it","ro.it","roma.it","rome.it","rovigo.it","sa.it","salerno.it","sassari.it","savona.it","si.it","siena.it","siracusa.it","so.it","sondrio.it","sp.it","sr.it","ss.it","suedtirol.it","südtirol.it","sv.it","ta.it","taranto.it","te.it","tempio-olbia.it","tempioolbia.it","teramo.it","terni.it","tn.it","to.it","torino.it","tp.it","tr.it","trani-andria-barletta.it","trani-barletta-andria.it","traniandriabarletta.it","tranibarlettaandria.it","trapani.it","trento.it","treviso.it","trieste.it","ts.it","turin.it","tv.it","ud.it","udine.it","urbino-pesaro.it","urbinopesaro.it","va.it","varese.it","vb.it","vc.it","ve.it","venezia.it","venice.it","verbania.it","vercelli.it","verona.it","vi.it","vibo-valentia.it","vibovalentia.it","vicenza.it","viterbo.it","vr.it","vs.it","vt.it","vv.it","je","co.je","net.je","org.je","*.jm","jo","com.jo","org.jo","net.jo","edu.jo","sch.jo","gov.jo","mil.jo","name.jo","jobs","jp","ac.jp","ad.jp","co.jp","ed.jp","go.jp","gr.jp","lg.jp","ne.jp","or.jp","aichi.jp","akita.jp","aomori.jp","chiba.jp","ehime.jp","fukui.jp","fukuoka.jp","fukushima.jp","gifu.jp","gunma.jp","hiroshima.jp","hokkaido.jp","hyogo.jp","ibaraki.jp","ishikawa.jp","iwate.jp","kagawa.jp","kagoshima.jp","kanagawa.jp","kochi.jp","kumamoto.jp","kyoto.jp","mie.jp","miyagi.jp","miyazaki.jp","nagano.jp","nagasaki.jp","nara.jp","niigata.jp","oita.jp","okayama.jp","okinawa.jp","osaka.jp","saga.jp","saitama.jp","shiga.jp","shimane.jp","shizuoka.jp","tochigi.jp","tokushima.jp","tokyo.jp","tottori.jp","toyama.jp","wakayama.jp","yamagata.jp","yamaguchi.jp","yamanashi.jp","栃木.jp","愛知.jp","愛媛.jp","兵庫.jp","熊本.jp","茨城.jp","北海道.jp","千葉.jp","和歌山.jp","長崎.jp","長野.jp","新潟.jp","青森.jp","静岡.jp","東京.jp","石川.jp","埼玉.jp","三重.jp","京都.jp","佐賀.jp","大分.jp","大阪.jp","奈良.jp","宮城.jp","宮崎.jp","富山.jp","山口.jp","山形.jp","山梨.jp","岩手.jp","岐阜.jp","岡山.jp","島根.jp","広島.jp","徳島.jp","沖縄.jp","滋賀.jp","神奈川.jp","福井.jp","福岡.jp","福島.jp","秋田.jp","群馬.jp","香川.jp","高知.jp","鳥取.jp","鹿児島.jp","*.kawasaki.jp","*.kitakyushu.jp","*.kobe.jp","*.nagoya.jp","*.sapporo.jp","*.sendai.jp","*.yokohama.jp","!city.kawasaki.jp","!city.kitakyushu.jp","!city.kobe.jp","!city.nagoya.jp","!city.sapporo.jp","!city.sendai.jp","!city.yokohama.jp","aisai.aichi.jp","ama.aichi.jp","anjo.aichi.jp","asuke.aichi.jp","chiryu.aichi.jp","chita.aichi.jp","fuso.aichi.jp","gamagori.aichi.jp","handa.aichi.jp","hazu.aichi.jp","hekinan.aichi.jp","higashiura.aichi.jp","ichinomiya.aichi.jp","inazawa.aichi.jp","inuyama.aichi.jp","isshiki.aichi.jp","iwakura.aichi.jp","kanie.aichi.jp","kariya.aichi.jp","kasugai.aichi.jp","kira.aichi.jp","kiyosu.aichi.jp","komaki.aichi.jp","konan.aichi.jp","kota.aichi.jp","mihama.aichi.jp","miyoshi.aichi.jp","nishio.aichi.jp","nisshin.aichi.jp","obu.aichi.jp","oguchi.aichi.jp","oharu.aichi.jp","okazaki.aichi.jp","owariasahi.aichi.jp","seto.aichi.jp","shikatsu.aichi.jp","shinshiro.aichi.jp","shitara.aichi.jp","tahara.aichi.jp","takahama.aichi.jp","tobishima.aichi.jp","toei.aichi.jp","togo.aichi.jp","tokai.aichi.jp","tokoname.aichi.jp","toyoake.aichi.jp","toyohashi.aichi.jp","toyokawa.aichi.jp","toyone.aichi.jp","toyota.aichi.jp","tsushima.aichi.jp","yatomi.aichi.jp","akita.akita.jp","daisen.akita.jp","fujisato.akita.jp","gojome.akita.jp","hachirogata.akita.jp","happou.akita.jp","higashinaruse.akita.jp","honjo.akita.jp","honjyo.akita.jp","ikawa.akita.jp","kamikoani.akita.jp","kamioka.akita.jp","katagami.akita.jp","kazuno.akita.jp","kitaakita.akita.jp","kosaka.akita.jp","kyowa.akita.jp","misato.akita.jp","mitane.akita.jp","moriyoshi.akita.jp","nikaho.akita.jp","noshiro.akita.jp","odate.akita.jp","oga.akita.jp","ogata.akita.jp","semboku.akita.jp","yokote.akita.jp","yurihonjo.akita.jp","aomori.aomori.jp","gonohe.aomori.jp","hachinohe.aomori.jp","hashikami.aomori.jp","hiranai.aomori.jp","hirosaki.aomori.jp","itayanagi.aomori.jp","kuroishi.aomori.jp","misawa.aomori.jp","mutsu.aomori.jp","nakadomari.aomori.jp","noheji.aomori.jp","oirase.aomori.jp","owani.aomori.jp","rokunohe.aomori.jp","sannohe.aomori.jp","shichinohe.aomori.jp","shingo.aomori.jp","takko.aomori.jp","towada.aomori.jp","tsugaru.aomori.jp","tsuruta.aomori.jp","abiko.chiba.jp","asahi.chiba.jp","chonan.chiba.jp","chosei.chiba.jp","choshi.chiba.jp","chuo.chiba.jp","funabashi.chiba.jp","futtsu.chiba.jp","hanamigawa.chiba.jp","ichihara.chiba.jp","ichikawa.chiba.jp","ichinomiya.chiba.jp","inzai.chiba.jp","isumi.chiba.jp","kamagaya.chiba.jp","kamogawa.chiba.jp","kashiwa.chiba.jp","katori.chiba.jp","katsuura.chiba.jp","kimitsu.chiba.jp","kisarazu.chiba.jp","kozaki.chiba.jp","kujukuri.chiba.jp","kyonan.chiba.jp","matsudo.chiba.jp","midori.chiba.jp","mihama.chiba.jp","minamiboso.chiba.jp","mobara.chiba.jp","mutsuzawa.chiba.jp","nagara.chiba.jp","nagareyama.chiba.jp","narashino.chiba.jp","narita.chiba.jp","noda.chiba.jp","oamishirasato.chiba.jp","omigawa.chiba.jp","onjuku.chiba.jp","otaki.chiba.jp","sakae.chiba.jp","sakura.chiba.jp","shimofusa.chiba.jp","shirako.chiba.jp","shiroi.chiba.jp","shisui.chiba.jp","sodegaura.chiba.jp","sosa.chiba.jp","tako.chiba.jp","tateyama.chiba.jp","togane.chiba.jp","tohnosho.chiba.jp","tomisato.chiba.jp","urayasu.chiba.jp","yachimata.chiba.jp","yachiyo.chiba.jp","yokaichiba.chiba.jp","yokoshibahikari.chiba.jp","yotsukaido.chiba.jp","ainan.ehime.jp","honai.ehime.jp","ikata.ehime.jp","imabari.ehime.jp","iyo.ehime.jp","kamijima.ehime.jp","kihoku.ehime.jp","kumakogen.ehime.jp","masaki.ehime.jp","matsuno.ehime.jp","matsuyama.ehime.jp","namikata.ehime.jp","niihama.ehime.jp","ozu.ehime.jp","saijo.ehime.jp","seiyo.ehime.jp","shikokuchuo.ehime.jp","tobe.ehime.jp","toon.ehime.jp","uchiko.ehime.jp","uwajima.ehime.jp","yawatahama.ehime.jp","echizen.fukui.jp","eiheiji.fukui.jp","fukui.fukui.jp","ikeda.fukui.jp","katsuyama.fukui.jp","mihama.fukui.jp","minamiechizen.fukui.jp","obama.fukui.jp","ohi.fukui.jp","ono.fukui.jp","sabae.fukui.jp","sakai.fukui.jp","takahama.fukui.jp","tsuruga.fukui.jp","wakasa.fukui.jp","ashiya.fukuoka.jp","buzen.fukuoka.jp","chikugo.fukuoka.jp","chikuho.fukuoka.jp","chikujo.fukuoka.jp","chikushino.fukuoka.jp","chikuzen.fukuoka.jp","chuo.fukuoka.jp","dazaifu.fukuoka.jp","fukuchi.fukuoka.jp","hakata.fukuoka.jp","higashi.fukuoka.jp","hirokawa.fukuoka.jp","hisayama.fukuoka.jp","iizuka.fukuoka.jp","inatsuki.fukuoka.jp","kaho.fukuoka.jp","kasuga.fukuoka.jp","kasuya.fukuoka.jp","kawara.fukuoka.jp","keisen.fukuoka.jp","koga.fukuoka.jp","kurate.fukuoka.jp","kurogi.fukuoka.jp","kurume.fukuoka.jp","minami.fukuoka.jp","miyako.fukuoka.jp","miyama.fukuoka.jp","miyawaka.fukuoka.jp","mizumaki.fukuoka.jp","munakata.fukuoka.jp","nakagawa.fukuoka.jp","nakama.fukuoka.jp","nishi.fukuoka.jp","nogata.fukuoka.jp","ogori.fukuoka.jp","okagaki.fukuoka.jp","okawa.fukuoka.jp","oki.fukuoka.jp","omuta.fukuoka.jp","onga.fukuoka.jp","onojo.fukuoka.jp","oto.fukuoka.jp","saigawa.fukuoka.jp","sasaguri.fukuoka.jp","shingu.fukuoka.jp","shinyoshitomi.fukuoka.jp","shonai.fukuoka.jp","soeda.fukuoka.jp","sue.fukuoka.jp","tachiarai.fukuoka.jp","tagawa.fukuoka.jp","takata.fukuoka.jp","toho.fukuoka.jp","toyotsu.fukuoka.jp","tsuiki.fukuoka.jp","ukiha.fukuoka.jp","umi.fukuoka.jp","usui.fukuoka.jp","yamada.fukuoka.jp","yame.fukuoka.jp","yanagawa.fukuoka.jp","yukuhashi.fukuoka.jp","aizubange.fukushima.jp","aizumisato.fukushima.jp","aizuwakamatsu.fukushima.jp","asakawa.fukushima.jp","bandai.fukushima.jp","date.fukushima.jp","fukushima.fukushima.jp","furudono.fukushima.jp","futaba.fukushima.jp","hanawa.fukushima.jp","higashi.fukushima.jp","hirata.fukushima.jp","hirono.fukushima.jp","iitate.fukushima.jp","inawashiro.fukushima.jp","ishikawa.fukushima.jp","iwaki.fukushima.jp","izumizaki.fukushima.jp","kagamiishi.fukushima.jp","kaneyama.fukushima.jp","kawamata.fukushima.jp","kitakata.fukushima.jp","kitashiobara.fukushima.jp","koori.fukushima.jp","koriyama.fukushima.jp","kunimi.fukushima.jp","miharu.fukushima.jp","mishima.fukushima.jp","namie.fukushima.jp","nango.fukushima.jp","nishiaizu.fukushima.jp","nishigo.fukushima.jp","okuma.fukushima.jp","omotego.fukushima.jp","ono.fukushima.jp","otama.fukushima.jp","samegawa.fukushima.jp","shimogo.fukushima.jp","shirakawa.fukushima.jp","showa.fukushima.jp","soma.fukushima.jp","sukagawa.fukushima.jp","taishin.fukushima.jp","tamakawa.fukushima.jp","tanagura.fukushima.jp","tenei.fukushima.jp","yabuki.fukushima.jp","yamato.fukushima.jp","yamatsuri.fukushima.jp","yanaizu.fukushima.jp","yugawa.fukushima.jp","anpachi.gifu.jp","ena.gifu.jp","gifu.gifu.jp","ginan.gifu.jp","godo.gifu.jp","gujo.gifu.jp","hashima.gifu.jp","hichiso.gifu.jp","hida.gifu.jp","higashishirakawa.gifu.jp","ibigawa.gifu.jp","ikeda.gifu.jp","kakamigahara.gifu.jp","kani.gifu.jp","kasahara.gifu.jp","kasamatsu.gifu.jp","kawaue.gifu.jp","kitagata.gifu.jp","mino.gifu.jp","minokamo.gifu.jp","mitake.gifu.jp","mizunami.gifu.jp","motosu.gifu.jp","nakatsugawa.gifu.jp","ogaki.gifu.jp","sakahogi.gifu.jp","seki.gifu.jp","sekigahara.gifu.jp","shirakawa.gifu.jp","tajimi.gifu.jp","takayama.gifu.jp","tarui.gifu.jp","toki.gifu.jp","tomika.gifu.jp","wanouchi.gifu.jp","yamagata.gifu.jp","yaotsu.gifu.jp","yoro.gifu.jp","annaka.gunma.jp","chiyoda.gunma.jp","fujioka.gunma.jp","higashiagatsuma.gunma.jp","isesaki.gunma.jp","itakura.gunma.jp","kanna.gunma.jp","kanra.gunma.jp","katashina.gunma.jp","kawaba.gunma.jp","kiryu.gunma.jp","kusatsu.gunma.jp","maebashi.gunma.jp","meiwa.gunma.jp","midori.gunma.jp","minakami.gunma.jp","naganohara.gunma.jp","nakanojo.gunma.jp","nanmoku.gunma.jp","numata.gunma.jp","oizumi.gunma.jp","ora.gunma.jp","ota.gunma.jp","shibukawa.gunma.jp","shimonita.gunma.jp","shinto.gunma.jp","showa.gunma.jp","takasaki.gunma.jp","takayama.gunma.jp","tamamura.gunma.jp","tatebayashi.gunma.jp","tomioka.gunma.jp","tsukiyono.gunma.jp","tsumagoi.gunma.jp","ueno.gunma.jp","yoshioka.gunma.jp","asaminami.hiroshima.jp","daiwa.hiroshima.jp","etajima.hiroshima.jp","fuchu.hiroshima.jp","fukuyama.hiroshima.jp","hatsukaichi.hiroshima.jp","higashihiroshima.hiroshima.jp","hongo.hiroshima.jp","jinsekikogen.hiroshima.jp","kaita.hiroshima.jp","kui.hiroshima.jp","kumano.hiroshima.jp","kure.hiroshima.jp","mihara.hiroshima.jp","miyoshi.hiroshima.jp","naka.hiroshima.jp","onomichi.hiroshima.jp","osakikamijima.hiroshima.jp","otake.hiroshima.jp","saka.hiroshima.jp","sera.hiroshima.jp","seranishi.hiroshima.jp","shinichi.hiroshima.jp","shobara.hiroshima.jp","takehara.hiroshima.jp","abashiri.hokkaido.jp","abira.hokkaido.jp","aibetsu.hokkaido.jp","akabira.hokkaido.jp","akkeshi.hokkaido.jp","asahikawa.hokkaido.jp","ashibetsu.hokkaido.jp","ashoro.hokkaido.jp","assabu.hokkaido.jp","atsuma.hokkaido.jp","bibai.hokkaido.jp","biei.hokkaido.jp","bifuka.hokkaido.jp","bihoro.hokkaido.jp","biratori.hokkaido.jp","chippubetsu.hokkaido.jp","chitose.hokkaido.jp","date.hokkaido.jp","ebetsu.hokkaido.jp","embetsu.hokkaido.jp","eniwa.hokkaido.jp","erimo.hokkaido.jp","esan.hokkaido.jp","esashi.hokkaido.jp","fukagawa.hokkaido.jp","fukushima.hokkaido.jp","furano.hokkaido.jp","furubira.hokkaido.jp","haboro.hokkaido.jp","hakodate.hokkaido.jp","hamatonbetsu.hokkaido.jp","hidaka.hokkaido.jp","higashikagura.hokkaido.jp","higashikawa.hokkaido.jp","hiroo.hokkaido.jp","hokuryu.hokkaido.jp","hokuto.hokkaido.jp","honbetsu.hokkaido.jp","horokanai.hokkaido.jp","horonobe.hokkaido.jp","ikeda.hokkaido.jp","imakane.hokkaido.jp","ishikari.hokkaido.jp","iwamizawa.hokkaido.jp","iwanai.hokkaido.jp","kamifurano.hokkaido.jp","kamikawa.hokkaido.jp","kamishihoro.hokkaido.jp","kamisunagawa.hokkaido.jp","kamoenai.hokkaido.jp","kayabe.hokkaido.jp","kembuchi.hokkaido.jp","kikonai.hokkaido.jp","kimobetsu.hokkaido.jp","kitahiroshima.hokkaido.jp","kitami.hokkaido.jp","kiyosato.hokkaido.jp","koshimizu.hokkaido.jp","kunneppu.hokkaido.jp","kuriyama.hokkaido.jp","kuromatsunai.hokkaido.jp","kushiro.hokkaido.jp","kutchan.hokkaido.jp","kyowa.hokkaido.jp","mashike.hokkaido.jp","matsumae.hokkaido.jp","mikasa.hokkaido.jp","minamifurano.hokkaido.jp","mombetsu.hokkaido.jp","moseushi.hokkaido.jp","mukawa.hokkaido.jp","muroran.hokkaido.jp","naie.hokkaido.jp","nakagawa.hokkaido.jp","nakasatsunai.hokkaido.jp","nakatombetsu.hokkaido.jp","nanae.hokkaido.jp","nanporo.hokkaido.jp","nayoro.hokkaido.jp","nemuro.hokkaido.jp","niikappu.hokkaido.jp","niki.hokkaido.jp","nishiokoppe.hokkaido.jp","noboribetsu.hokkaido.jp","numata.hokkaido.jp","obihiro.hokkaido.jp","obira.hokkaido.jp","oketo.hokkaido.jp","okoppe.hokkaido.jp","otaru.hokkaido.jp","otobe.hokkaido.jp","otofuke.hokkaido.jp","otoineppu.hokkaido.jp","oumu.hokkaido.jp","ozora.hokkaido.jp","pippu.hokkaido.jp","rankoshi.hokkaido.jp","rebun.hokkaido.jp","rikubetsu.hokkaido.jp","rishiri.hokkaido.jp","rishirifuji.hokkaido.jp","saroma.hokkaido.jp","sarufutsu.hokkaido.jp","shakotan.hokkaido.jp","shari.hokkaido.jp","shibecha.hokkaido.jp","shibetsu.hokkaido.jp","shikabe.hokkaido.jp","shikaoi.hokkaido.jp","shimamaki.hokkaido.jp","shimizu.hokkaido.jp","shimokawa.hokkaido.jp","shinshinotsu.hokkaido.jp","shintoku.hokkaido.jp","shiranuka.hokkaido.jp","shiraoi.hokkaido.jp","shiriuchi.hokkaido.jp","sobetsu.hokkaido.jp","sunagawa.hokkaido.jp","taiki.hokkaido.jp","takasu.hokkaido.jp","takikawa.hokkaido.jp","takinoue.hokkaido.jp","teshikaga.hokkaido.jp","tobetsu.hokkaido.jp","tohma.hokkaido.jp","tomakomai.hokkaido.jp","tomari.hokkaido.jp","toya.hokkaido.jp","toyako.hokkaido.jp","toyotomi.hokkaido.jp","toyoura.hokkaido.jp","tsubetsu.hokkaido.jp","tsukigata.hokkaido.jp","urakawa.hokkaido.jp","urausu.hokkaido.jp","uryu.hokkaido.jp","utashinai.hokkaido.jp","wakkanai.hokkaido.jp","wassamu.hokkaido.jp","yakumo.hokkaido.jp","yoichi.hokkaido.jp","aioi.hyogo.jp","akashi.hyogo.jp","ako.hyogo.jp","amagasaki.hyogo.jp","aogaki.hyogo.jp","asago.hyogo.jp","ashiya.hyogo.jp","awaji.hyogo.jp","fukusaki.hyogo.jp","goshiki.hyogo.jp","harima.hyogo.jp","himeji.hyogo.jp","ichikawa.hyogo.jp","inagawa.hyogo.jp","itami.hyogo.jp","kakogawa.hyogo.jp","kamigori.hyogo.jp","kamikawa.hyogo.jp","kasai.hyogo.jp","kasuga.hyogo.jp","kawanishi.hyogo.jp","miki.hyogo.jp","minamiawaji.hyogo.jp","nishinomiya.hyogo.jp","nishiwaki.hyogo.jp","ono.hyogo.jp","sanda.hyogo.jp","sannan.hyogo.jp","sasayama.hyogo.jp","sayo.hyogo.jp","shingu.hyogo.jp","shinonsen.hyogo.jp","shiso.hyogo.jp","sumoto.hyogo.jp","taishi.hyogo.jp","taka.hyogo.jp","takarazuka.hyogo.jp","takasago.hyogo.jp","takino.hyogo.jp","tamba.hyogo.jp","tatsuno.hyogo.jp","toyooka.hyogo.jp","yabu.hyogo.jp","yashiro.hyogo.jp","yoka.hyogo.jp","yokawa.hyogo.jp","ami.ibaraki.jp","asahi.ibaraki.jp","bando.ibaraki.jp","chikusei.ibaraki.jp","daigo.ibaraki.jp","fujishiro.ibaraki.jp","hitachi.ibaraki.jp","hitachinaka.ibaraki.jp","hitachiomiya.ibaraki.jp","hitachiota.ibaraki.jp","ibaraki.ibaraki.jp","ina.ibaraki.jp","inashiki.ibaraki.jp","itako.ibaraki.jp","iwama.ibaraki.jp","joso.ibaraki.jp","kamisu.ibaraki.jp","kasama.ibaraki.jp","kashima.ibaraki.jp","kasumigaura.ibaraki.jp","koga.ibaraki.jp","miho.ibaraki.jp","mito.ibaraki.jp","moriya.ibaraki.jp","naka.ibaraki.jp","namegata.ibaraki.jp","oarai.ibaraki.jp","ogawa.ibaraki.jp","omitama.ibaraki.jp","ryugasaki.ibaraki.jp","sakai.ibaraki.jp","sakuragawa.ibaraki.jp","shimodate.ibaraki.jp","shimotsuma.ibaraki.jp","shirosato.ibaraki.jp","sowa.ibaraki.jp","suifu.ibaraki.jp","takahagi.ibaraki.jp","tamatsukuri.ibaraki.jp","tokai.ibaraki.jp","tomobe.ibaraki.jp","tone.ibaraki.jp","toride.ibaraki.jp","tsuchiura.ibaraki.jp","tsukuba.ibaraki.jp","uchihara.ibaraki.jp","ushiku.ibaraki.jp","yachiyo.ibaraki.jp","yamagata.ibaraki.jp","yawara.ibaraki.jp","yuki.ibaraki.jp","anamizu.ishikawa.jp","hakui.ishikawa.jp","hakusan.ishikawa.jp","kaga.ishikawa.jp","kahoku.ishikawa.jp","kanazawa.ishikawa.jp","kawakita.ishikawa.jp","komatsu.ishikawa.jp","nakanoto.ishikawa.jp","nanao.ishikawa.jp","nomi.ishikawa.jp","nonoichi.ishikawa.jp","noto.ishikawa.jp","shika.ishikawa.jp","suzu.ishikawa.jp","tsubata.ishikawa.jp","tsurugi.ishikawa.jp","uchinada.ishikawa.jp","wajima.ishikawa.jp","fudai.iwate.jp","fujisawa.iwate.jp","hanamaki.iwate.jp","hiraizumi.iwate.jp","hirono.iwate.jp","ichinohe.iwate.jp","ichinoseki.iwate.jp","iwaizumi.iwate.jp","iwate.iwate.jp","joboji.iwate.jp","kamaishi.iwate.jp","kanegasaki.iwate.jp","karumai.iwate.jp","kawai.iwate.jp","kitakami.iwate.jp","kuji.iwate.jp","kunohe.iwate.jp","kuzumaki.iwate.jp","miyako.iwate.jp","mizusawa.iwate.jp","morioka.iwate.jp","ninohe.iwate.jp","noda.iwate.jp","ofunato.iwate.jp","oshu.iwate.jp","otsuchi.iwate.jp","rikuzentakata.iwate.jp","shiwa.iwate.jp","shizukuishi.iwate.jp","sumita.iwate.jp","tanohata.iwate.jp","tono.iwate.jp","yahaba.iwate.jp","yamada.iwate.jp","ayagawa.kagawa.jp","higashikagawa.kagawa.jp","kanonji.kagawa.jp","kotohira.kagawa.jp","manno.kagawa.jp","marugame.kagawa.jp","mitoyo.kagawa.jp","naoshima.kagawa.jp","sanuki.kagawa.jp","tadotsu.kagawa.jp","takamatsu.kagawa.jp","tonosho.kagawa.jp","uchinomi.kagawa.jp","utazu.kagawa.jp","zentsuji.kagawa.jp","akune.kagoshima.jp","amami.kagoshima.jp","hioki.kagoshima.jp","isa.kagoshima.jp","isen.kagoshima.jp","izumi.kagoshima.jp","kagoshima.kagoshima.jp","kanoya.kagoshima.jp","kawanabe.kagoshima.jp","kinko.kagoshima.jp","kouyama.kagoshima.jp","makurazaki.kagoshima.jp","matsumoto.kagoshima.jp","minamitane.kagoshima.jp","nakatane.kagoshima.jp","nishinoomote.kagoshima.jp","satsumasendai.kagoshima.jp","soo.kagoshima.jp","tarumizu.kagoshima.jp","yusui.kagoshima.jp","aikawa.kanagawa.jp","atsugi.kanagawa.jp","ayase.kanagawa.jp","chigasaki.kanagawa.jp","ebina.kanagawa.jp","fujisawa.kanagawa.jp","hadano.kanagawa.jp","hakone.kanagawa.jp","hiratsuka.kanagawa.jp","isehara.kanagawa.jp","kaisei.kanagawa.jp","kamakura.kanagawa.jp","kiyokawa.kanagawa.jp","matsuda.kanagawa.jp","minamiashigara.kanagawa.jp","miura.kanagawa.jp","nakai.kanagawa.jp","ninomiya.kanagawa.jp","odawara.kanagawa.jp","oi.kanagawa.jp","oiso.kanagawa.jp","sagamihara.kanagawa.jp","samukawa.kanagawa.jp","tsukui.kanagawa.jp","yamakita.kanagawa.jp","yamato.kanagawa.jp","yokosuka.kanagawa.jp","yugawara.kanagawa.jp","zama.kanagawa.jp","zushi.kanagawa.jp","aki.kochi.jp","geisei.kochi.jp","hidaka.kochi.jp","higashitsuno.kochi.jp","ino.kochi.jp","kagami.kochi.jp","kami.kochi.jp","kitagawa.kochi.jp","kochi.kochi.jp","mihara.kochi.jp","motoyama.kochi.jp","muroto.kochi.jp","nahari.kochi.jp","nakamura.kochi.jp","nankoku.kochi.jp","nishitosa.kochi.jp","niyodogawa.kochi.jp","ochi.kochi.jp","okawa.kochi.jp","otoyo.kochi.jp","otsuki.kochi.jp","sakawa.kochi.jp","sukumo.kochi.jp","susaki.kochi.jp","tosa.kochi.jp","tosashimizu.kochi.jp","toyo.kochi.jp","tsuno.kochi.jp","umaji.kochi.jp","yasuda.kochi.jp","yusuhara.kochi.jp","amakusa.kumamoto.jp","arao.kumamoto.jp","aso.kumamoto.jp","choyo.kumamoto.jp","gyokuto.kumamoto.jp","kamiamakusa.kumamoto.jp","kikuchi.kumamoto.jp","kumamoto.kumamoto.jp","mashiki.kumamoto.jp","mifune.kumamoto.jp","minamata.kumamoto.jp","minamioguni.kumamoto.jp","nagasu.kumamoto.jp","nishihara.kumamoto.jp","oguni.kumamoto.jp","ozu.kumamoto.jp","sumoto.kumamoto.jp","takamori.kumamoto.jp","uki.kumamoto.jp","uto.kumamoto.jp","yamaga.kumamoto.jp","yamato.kumamoto.jp","yatsushiro.kumamoto.jp","ayabe.kyoto.jp","fukuchiyama.kyoto.jp","higashiyama.kyoto.jp","ide.kyoto.jp","ine.kyoto.jp","joyo.kyoto.jp","kameoka.kyoto.jp","kamo.kyoto.jp","kita.kyoto.jp","kizu.kyoto.jp","kumiyama.kyoto.jp","kyotamba.kyoto.jp","kyotanabe.kyoto.jp","kyotango.kyoto.jp","maizuru.kyoto.jp","minami.kyoto.jp","minamiyamashiro.kyoto.jp","miyazu.kyoto.jp","muko.kyoto.jp","nagaokakyo.kyoto.jp","nakagyo.kyoto.jp","nantan.kyoto.jp","oyamazaki.kyoto.jp","sakyo.kyoto.jp","seika.kyoto.jp","tanabe.kyoto.jp","uji.kyoto.jp","ujitawara.kyoto.jp","wazuka.kyoto.jp","yamashina.kyoto.jp","yawata.kyoto.jp","asahi.mie.jp","inabe.mie.jp","ise.mie.jp","kameyama.mie.jp","kawagoe.mie.jp","kiho.mie.jp","kisosaki.mie.jp","kiwa.mie.jp","komono.mie.jp","kumano.mie.jp","kuwana.mie.jp","matsusaka.mie.jp","meiwa.mie.jp","mihama.mie.jp","minamiise.mie.jp","misugi.mie.jp","miyama.mie.jp","nabari.mie.jp","shima.mie.jp","suzuka.mie.jp","tado.mie.jp","taiki.mie.jp","taki.mie.jp","tamaki.mie.jp","toba.mie.jp","tsu.mie.jp","udono.mie.jp","ureshino.mie.jp","watarai.mie.jp","yokkaichi.mie.jp","furukawa.miyagi.jp","higashimatsushima.miyagi.jp","ishinomaki.miyagi.jp","iwanuma.miyagi.jp","kakuda.miyagi.jp","kami.miyagi.jp","kawasaki.miyagi.jp","marumori.miyagi.jp","matsushima.miyagi.jp","minamisanriku.miyagi.jp","misato.miyagi.jp","murata.miyagi.jp","natori.miyagi.jp","ogawara.miyagi.jp","ohira.miyagi.jp","onagawa.miyagi.jp","osaki.miyagi.jp","rifu.miyagi.jp","semine.miyagi.jp","shibata.miyagi.jp","shichikashuku.miyagi.jp","shikama.miyagi.jp","shiogama.miyagi.jp","shiroishi.miyagi.jp","tagajo.miyagi.jp","taiwa.miyagi.jp","tome.miyagi.jp","tomiya.miyagi.jp","wakuya.miyagi.jp","watari.miyagi.jp","yamamoto.miyagi.jp","zao.miyagi.jp","aya.miyazaki.jp","ebino.miyazaki.jp","gokase.miyazaki.jp","hyuga.miyazaki.jp","kadogawa.miyazaki.jp","kawaminami.miyazaki.jp","kijo.miyazaki.jp","kitagawa.miyazaki.jp","kitakata.miyazaki.jp","kitaura.miyazaki.jp","kobayashi.miyazaki.jp","kunitomi.miyazaki.jp","kushima.miyazaki.jp","mimata.miyazaki.jp","miyakonojo.miyazaki.jp","miyazaki.miyazaki.jp","morotsuka.miyazaki.jp","nichinan.miyazaki.jp","nishimera.miyazaki.jp","nobeoka.miyazaki.jp","saito.miyazaki.jp","shiiba.miyazaki.jp","shintomi.miyazaki.jp","takaharu.miyazaki.jp","takanabe.miyazaki.jp","takazaki.miyazaki.jp","tsuno.miyazaki.jp","achi.nagano.jp","agematsu.nagano.jp","anan.nagano.jp","aoki.nagano.jp","asahi.nagano.jp","azumino.nagano.jp","chikuhoku.nagano.jp","chikuma.nagano.jp","chino.nagano.jp","fujimi.nagano.jp","hakuba.nagano.jp","hara.nagano.jp","hiraya.nagano.jp","iida.nagano.jp","iijima.nagano.jp","iiyama.nagano.jp","iizuna.nagano.jp","ikeda.nagano.jp","ikusaka.nagano.jp","ina.nagano.jp","karuizawa.nagano.jp","kawakami.nagano.jp","kiso.nagano.jp","kisofukushima.nagano.jp","kitaaiki.nagano.jp","komagane.nagano.jp","komoro.nagano.jp","matsukawa.nagano.jp","matsumoto.nagano.jp","miasa.nagano.jp","minamiaiki.nagano.jp","minamimaki.nagano.jp","minamiminowa.nagano.jp","minowa.nagano.jp","miyada.nagano.jp","miyota.nagano.jp","mochizuki.nagano.jp","nagano.nagano.jp","nagawa.nagano.jp","nagiso.nagano.jp","nakagawa.nagano.jp","nakano.nagano.jp","nozawaonsen.nagano.jp","obuse.nagano.jp","ogawa.nagano.jp","okaya.nagano.jp","omachi.nagano.jp","omi.nagano.jp","ookuwa.nagano.jp","ooshika.nagano.jp","otaki.nagano.jp","otari.nagano.jp","sakae.nagano.jp","sakaki.nagano.jp","saku.nagano.jp","sakuho.nagano.jp","shimosuwa.nagano.jp","shinanomachi.nagano.jp","shiojiri.nagano.jp","suwa.nagano.jp","suzaka.nagano.jp","takagi.nagano.jp","takamori.nagano.jp","takayama.nagano.jp","tateshina.nagano.jp","tatsuno.nagano.jp","togakushi.nagano.jp","togura.nagano.jp","tomi.nagano.jp","ueda.nagano.jp","wada.nagano.jp","yamagata.nagano.jp","yamanouchi.nagano.jp","yasaka.nagano.jp","yasuoka.nagano.jp","chijiwa.nagasaki.jp","futsu.nagasaki.jp","goto.nagasaki.jp","hasami.nagasaki.jp","hirado.nagasaki.jp","iki.nagasaki.jp","isahaya.nagasaki.jp","kawatana.nagasaki.jp","kuchinotsu.nagasaki.jp","matsuura.nagasaki.jp","nagasaki.nagasaki.jp","obama.nagasaki.jp","omura.nagasaki.jp","oseto.nagasaki.jp","saikai.nagasaki.jp","sasebo.nagasaki.jp","seihi.nagasaki.jp","shimabara.nagasaki.jp","shinkamigoto.nagasaki.jp","togitsu.nagasaki.jp","tsushima.nagasaki.jp","unzen.nagasaki.jp","ando.nara.jp","gose.nara.jp","heguri.nara.jp","higashiyoshino.nara.jp","ikaruga.nara.jp","ikoma.nara.jp","kamikitayama.nara.jp","kanmaki.nara.jp","kashiba.nara.jp","kashihara.nara.jp","katsuragi.nara.jp","kawai.nara.jp","kawakami.nara.jp","kawanishi.nara.jp","koryo.nara.jp","kurotaki.nara.jp","mitsue.nara.jp","miyake.nara.jp","nara.nara.jp","nosegawa.nara.jp","oji.nara.jp","ouda.nara.jp","oyodo.nara.jp","sakurai.nara.jp","sango.nara.jp","shimoichi.nara.jp","shimokitayama.nara.jp","shinjo.nara.jp","soni.nara.jp","takatori.nara.jp","tawaramoto.nara.jp","tenkawa.nara.jp","tenri.nara.jp","uda.nara.jp","yamatokoriyama.nara.jp","yamatotakada.nara.jp","yamazoe.nara.jp","yoshino.nara.jp","aga.niigata.jp","agano.niigata.jp","gosen.niigata.jp","itoigawa.niigata.jp","izumozaki.niigata.jp","joetsu.niigata.jp","kamo.niigata.jp","kariwa.niigata.jp","kashiwazaki.niigata.jp","minamiuonuma.niigata.jp","mitsuke.niigata.jp","muika.niigata.jp","murakami.niigata.jp","myoko.niigata.jp","nagaoka.niigata.jp","niigata.niigata.jp","ojiya.niigata.jp","omi.niigata.jp","sado.niigata.jp","sanjo.niigata.jp","seiro.niigata.jp","seirou.niigata.jp","sekikawa.niigata.jp","shibata.niigata.jp","tagami.niigata.jp","tainai.niigata.jp","tochio.niigata.jp","tokamachi.niigata.jp","tsubame.niigata.jp","tsunan.niigata.jp","uonuma.niigata.jp","yahiko.niigata.jp","yoita.niigata.jp","yuzawa.niigata.jp","beppu.oita.jp","bungoono.oita.jp","bungotakada.oita.jp","hasama.oita.jp","hiji.oita.jp","himeshima.oita.jp","hita.oita.jp","kamitsue.oita.jp","kokonoe.oita.jp","kuju.oita.jp","kunisaki.oita.jp","kusu.oita.jp","oita.oita.jp","saiki.oita.jp","taketa.oita.jp","tsukumi.oita.jp","usa.oita.jp","usuki.oita.jp","yufu.oita.jp","akaiwa.okayama.jp","asakuchi.okayama.jp","bizen.okayama.jp","hayashima.okayama.jp","ibara.okayama.jp","kagamino.okayama.jp","kasaoka.okayama.jp","kibichuo.okayama.jp","kumenan.okayama.jp","kurashiki.okayama.jp","maniwa.okayama.jp","misaki.okayama.jp","nagi.okayama.jp","niimi.okayama.jp","nishiawakura.okayama.jp","okayama.okayama.jp","satosho.okayama.jp","setouchi.okayama.jp","shinjo.okayama.jp","shoo.okayama.jp","soja.okayama.jp","takahashi.okayama.jp","tamano.okayama.jp","tsuyama.okayama.jp","wake.okayama.jp","yakage.okayama.jp","aguni.okinawa.jp","ginowan.okinawa.jp","ginoza.okinawa.jp","gushikami.okinawa.jp","haebaru.okinawa.jp","higashi.okinawa.jp","hirara.okinawa.jp","iheya.okinawa.jp","ishigaki.okinawa.jp","ishikawa.okinawa.jp","itoman.okinawa.jp","izena.okinawa.jp","kadena.okinawa.jp","kin.okinawa.jp","kitadaito.okinawa.jp","kitanakagusuku.okinawa.jp","kumejima.okinawa.jp","kunigami.okinawa.jp","minamidaito.okinawa.jp","motobu.okinawa.jp","nago.okinawa.jp","naha.okinawa.jp","nakagusuku.okinawa.jp","nakijin.okinawa.jp","nanjo.okinawa.jp","nishihara.okinawa.jp","ogimi.okinawa.jp","okinawa.okinawa.jp","onna.okinawa.jp","shimoji.okinawa.jp","taketomi.okinawa.jp","tarama.okinawa.jp","tokashiki.okinawa.jp","tomigusuku.okinawa.jp","tonaki.okinawa.jp","urasoe.okinawa.jp","uruma.okinawa.jp","yaese.okinawa.jp","yomitan.okinawa.jp","yonabaru.okinawa.jp","yonaguni.okinawa.jp","zamami.okinawa.jp","abeno.osaka.jp","chihayaakasaka.osaka.jp","chuo.osaka.jp","daito.osaka.jp","fujiidera.osaka.jp","habikino.osaka.jp","hannan.osaka.jp","higashiosaka.osaka.jp","higashisumiyoshi.osaka.jp","higashiyodogawa.osaka.jp","hirakata.osaka.jp","ibaraki.osaka.jp","ikeda.osaka.jp","izumi.osaka.jp","izumiotsu.osaka.jp","izumisano.osaka.jp","kadoma.osaka.jp","kaizuka.osaka.jp","kanan.osaka.jp","kashiwara.osaka.jp","katano.osaka.jp","kawachinagano.osaka.jp","kishiwada.osaka.jp","kita.osaka.jp","kumatori.osaka.jp","matsubara.osaka.jp","minato.osaka.jp","minoh.osaka.jp","misaki.osaka.jp","moriguchi.osaka.jp","neyagawa.osaka.jp","nishi.osaka.jp","nose.osaka.jp","osakasayama.osaka.jp","sakai.osaka.jp","sayama.osaka.jp","sennan.osaka.jp","settsu.osaka.jp","shijonawate.osaka.jp","shimamoto.osaka.jp","suita.osaka.jp","tadaoka.osaka.jp","taishi.osaka.jp","tajiri.osaka.jp","takaishi.osaka.jp","takatsuki.osaka.jp","tondabayashi.osaka.jp","toyonaka.osaka.jp","toyono.osaka.jp","yao.osaka.jp","ariake.saga.jp","arita.saga.jp","fukudomi.saga.jp","genkai.saga.jp","hamatama.saga.jp","hizen.saga.jp","imari.saga.jp","kamimine.saga.jp","kanzaki.saga.jp","karatsu.saga.jp","kashima.saga.jp","kitagata.saga.jp","kitahata.saga.jp","kiyama.saga.jp","kouhoku.saga.jp","kyuragi.saga.jp","nishiarita.saga.jp","ogi.saga.jp","omachi.saga.jp","ouchi.saga.jp","saga.saga.jp","shiroishi.saga.jp","taku.saga.jp","tara.saga.jp","tosu.saga.jp","yoshinogari.saga.jp","arakawa.saitama.jp","asaka.saitama.jp","chichibu.saitama.jp","fujimi.saitama.jp","fujimino.saitama.jp","fukaya.saitama.jp","hanno.saitama.jp","hanyu.saitama.jp","hasuda.saitama.jp","hatogaya.saitama.jp","hatoyama.saitama.jp","hidaka.saitama.jp","higashichichibu.saitama.jp","higashimatsuyama.saitama.jp","honjo.saitama.jp","ina.saitama.jp","iruma.saitama.jp","iwatsuki.saitama.jp","kamiizumi.saitama.jp","kamikawa.saitama.jp","kamisato.saitama.jp","kasukabe.saitama.jp","kawagoe.saitama.jp","kawaguchi.saitama.jp","kawajima.saitama.jp","kazo.saitama.jp","kitamoto.saitama.jp","koshigaya.saitama.jp","kounosu.saitama.jp","kuki.saitama.jp","kumagaya.saitama.jp","matsubushi.saitama.jp","minano.saitama.jp","misato.saitama.jp","miyashiro.saitama.jp","miyoshi.saitama.jp","moroyama.saitama.jp","nagatoro.saitama.jp","namegawa.saitama.jp","niiza.saitama.jp","ogano.saitama.jp","ogawa.saitama.jp","ogose.saitama.jp","okegawa.saitama.jp","omiya.saitama.jp","otaki.saitama.jp","ranzan.saitama.jp","ryokami.saitama.jp","saitama.saitama.jp","sakado.saitama.jp","satte.saitama.jp","sayama.saitama.jp","shiki.saitama.jp","shiraoka.saitama.jp","soka.saitama.jp","sugito.saitama.jp","toda.saitama.jp","tokigawa.saitama.jp","tokorozawa.saitama.jp","tsurugashima.saitama.jp","urawa.saitama.jp","warabi.saitama.jp","yashio.saitama.jp","yokoze.saitama.jp","yono.saitama.jp","yorii.saitama.jp","yoshida.saitama.jp","yoshikawa.saitama.jp","yoshimi.saitama.jp","aisho.shiga.jp","gamo.shiga.jp","higashiomi.shiga.jp","hikone.shiga.jp","koka.shiga.jp","konan.shiga.jp","kosei.shiga.jp","koto.shiga.jp","kusatsu.shiga.jp","maibara.shiga.jp","moriyama.shiga.jp","nagahama.shiga.jp","nishiazai.shiga.jp","notogawa.shiga.jp","omihachiman.shiga.jp","otsu.shiga.jp","ritto.shiga.jp","ryuoh.shiga.jp","takashima.shiga.jp","takatsuki.shiga.jp","torahime.shiga.jp","toyosato.shiga.jp","yasu.shiga.jp","akagi.shimane.jp","ama.shimane.jp","gotsu.shimane.jp","hamada.shimane.jp","higashiizumo.shimane.jp","hikawa.shimane.jp","hikimi.shimane.jp","izumo.shimane.jp","kakinoki.shimane.jp","masuda.shimane.jp","matsue.shimane.jp","misato.shimane.jp","nishinoshima.shimane.jp","ohda.shimane.jp","okinoshima.shimane.jp","okuizumo.shimane.jp","shimane.shimane.jp","tamayu.shimane.jp","tsuwano.shimane.jp","unnan.shimane.jp","yakumo.shimane.jp","yasugi.shimane.jp","yatsuka.shimane.jp","arai.shizuoka.jp","atami.shizuoka.jp","fuji.shizuoka.jp","fujieda.shizuoka.jp","fujikawa.shizuoka.jp","fujinomiya.shizuoka.jp","fukuroi.shizuoka.jp","gotemba.shizuoka.jp","haibara.shizuoka.jp","hamamatsu.shizuoka.jp","higashiizu.shizuoka.jp","ito.shizuoka.jp","iwata.shizuoka.jp","izu.shizuoka.jp","izunokuni.shizuoka.jp","kakegawa.shizuoka.jp","kannami.shizuoka.jp","kawanehon.shizuoka.jp","kawazu.shizuoka.jp","kikugawa.shizuoka.jp","kosai.shizuoka.jp","makinohara.shizuoka.jp","matsuzaki.shizuoka.jp","minamiizu.shizuoka.jp","mishima.shizuoka.jp","morimachi.shizuoka.jp","nishiizu.shizuoka.jp","numazu.shizuoka.jp","omaezaki.shizuoka.jp","shimada.shizuoka.jp","shimizu.shizuoka.jp","shimoda.shizuoka.jp","shizuoka.shizuoka.jp","susono.shizuoka.jp","yaizu.shizuoka.jp","yoshida.shizuoka.jp","ashikaga.tochigi.jp","bato.tochigi.jp","haga.tochigi.jp","ichikai.tochigi.jp","iwafune.tochigi.jp","kaminokawa.tochigi.jp","kanuma.tochigi.jp","karasuyama.tochigi.jp","kuroiso.tochigi.jp","mashiko.tochigi.jp","mibu.tochigi.jp","moka.tochigi.jp","motegi.tochigi.jp","nasu.tochigi.jp","nasushiobara.tochigi.jp","nikko.tochigi.jp","nishikata.tochigi.jp","nogi.tochigi.jp","ohira.tochigi.jp","ohtawara.tochigi.jp","oyama.tochigi.jp","sakura.tochigi.jp","sano.tochigi.jp","shimotsuke.tochigi.jp","shioya.tochigi.jp","takanezawa.tochigi.jp","tochigi.tochigi.jp","tsuga.tochigi.jp","ujiie.tochigi.jp","utsunomiya.tochigi.jp","yaita.tochigi.jp","aizumi.tokushima.jp","anan.tokushima.jp","ichiba.tokushima.jp","itano.tokushima.jp","kainan.tokushima.jp","komatsushima.tokushima.jp","matsushige.tokushima.jp","mima.tokushima.jp","minami.tokushima.jp","miyoshi.tokushima.jp","mugi.tokushima.jp","nakagawa.tokushima.jp","naruto.tokushima.jp","sanagochi.tokushima.jp","shishikui.tokushima.jp","tokushima.tokushima.jp","wajiki.tokushima.jp","adachi.tokyo.jp","akiruno.tokyo.jp","akishima.tokyo.jp","aogashima.tokyo.jp","arakawa.tokyo.jp","bunkyo.tokyo.jp","chiyoda.tokyo.jp","chofu.tokyo.jp","chuo.tokyo.jp","edogawa.tokyo.jp","fuchu.tokyo.jp","fussa.tokyo.jp","hachijo.tokyo.jp","hachioji.tokyo.jp","hamura.tokyo.jp","higashikurume.tokyo.jp","higashimurayama.tokyo.jp","higashiyamato.tokyo.jp","hino.tokyo.jp","hinode.tokyo.jp","hinohara.tokyo.jp","inagi.tokyo.jp","itabashi.tokyo.jp","katsushika.tokyo.jp","kita.tokyo.jp","kiyose.tokyo.jp","kodaira.tokyo.jp","koganei.tokyo.jp","kokubunji.tokyo.jp","komae.tokyo.jp","koto.tokyo.jp","kouzushima.tokyo.jp","kunitachi.tokyo.jp","machida.tokyo.jp","meguro.tokyo.jp","minato.tokyo.jp","mitaka.tokyo.jp","mizuho.tokyo.jp","musashimurayama.tokyo.jp","musashino.tokyo.jp","nakano.tokyo.jp","nerima.tokyo.jp","ogasawara.tokyo.jp","okutama.tokyo.jp","ome.tokyo.jp","oshima.tokyo.jp","ota.tokyo.jp","setagaya.tokyo.jp","shibuya.tokyo.jp","shinagawa.tokyo.jp","shinjuku.tokyo.jp","suginami.tokyo.jp","sumida.tokyo.jp","tachikawa.tokyo.jp","taito.tokyo.jp","tama.tokyo.jp","toshima.tokyo.jp","chizu.tottori.jp","hino.tottori.jp","kawahara.tottori.jp","koge.tottori.jp","kotoura.tottori.jp","misasa.tottori.jp","nanbu.tottori.jp","nichinan.tottori.jp","sakaiminato.tottori.jp","tottori.tottori.jp","wakasa.tottori.jp","yazu.tottori.jp","yonago.tottori.jp","asahi.toyama.jp","fuchu.toyama.jp","fukumitsu.toyama.jp","funahashi.toyama.jp","himi.toyama.jp","imizu.toyama.jp","inami.toyama.jp","johana.toyama.jp","kamiichi.toyama.jp","kurobe.toyama.jp","nakaniikawa.toyama.jp","namerikawa.toyama.jp","nanto.toyama.jp","nyuzen.toyama.jp","oyabe.toyama.jp","taira.toyama.jp","takaoka.toyama.jp","tateyama.toyama.jp","toga.toyama.jp","tonami.toyama.jp","toyama.toyama.jp","unazuki.toyama.jp","uozu.toyama.jp","yamada.toyama.jp","arida.wakayama.jp","aridagawa.wakayama.jp","gobo.wakayama.jp","hashimoto.wakayama.jp","hidaka.wakayama.jp","hirogawa.wakayama.jp","inami.wakayama.jp","iwade.wakayama.jp","kainan.wakayama.jp","kamitonda.wakayama.jp","katsuragi.wakayama.jp","kimino.wakayama.jp","kinokawa.wakayama.jp","kitayama.wakayama.jp","koya.wakayama.jp","koza.wakayama.jp","kozagawa.wakayama.jp","kudoyama.wakayama.jp","kushimoto.wakayama.jp","mihama.wakayama.jp","misato.wakayama.jp","nachikatsuura.wakayama.jp","shingu.wakayama.jp","shirahama.wakayama.jp","taiji.wakayama.jp","tanabe.wakayama.jp","wakayama.wakayama.jp","yuasa.wakayama.jp","yura.wakayama.jp","asahi.yamagata.jp","funagata.yamagata.jp","higashine.yamagata.jp","iide.yamagata.jp","kahoku.yamagata.jp","kaminoyama.yamagata.jp","kaneyama.yamagata.jp","kawanishi.yamagata.jp","mamurogawa.yamagata.jp","mikawa.yamagata.jp","murayama.yamagata.jp","nagai.yamagata.jp","nakayama.yamagata.jp","nanyo.yamagata.jp","nishikawa.yamagata.jp","obanazawa.yamagata.jp","oe.yamagata.jp","oguni.yamagata.jp","ohkura.yamagata.jp","oishida.yamagata.jp","sagae.yamagata.jp","sakata.yamagata.jp","sakegawa.yamagata.jp","shinjo.yamagata.jp","shirataka.yamagata.jp","shonai.yamagata.jp","takahata.yamagata.jp","tendo.yamagata.jp","tozawa.yamagata.jp","tsuruoka.yamagata.jp","yamagata.yamagata.jp","yamanobe.yamagata.jp","yonezawa.yamagata.jp","yuza.yamagata.jp","abu.yamaguchi.jp","hagi.yamaguchi.jp","hikari.yamaguchi.jp","hofu.yamaguchi.jp","iwakuni.yamaguchi.jp","kudamatsu.yamaguchi.jp","mitou.yamaguchi.jp","nagato.yamaguchi.jp","oshima.yamaguchi.jp","shimonoseki.yamaguchi.jp","shunan.yamaguchi.jp","tabuse.yamaguchi.jp","tokuyama.yamaguchi.jp","toyota.yamaguchi.jp","ube.yamaguchi.jp","yuu.yamaguchi.jp","chuo.yamanashi.jp","doshi.yamanashi.jp","fuefuki.yamanashi.jp","fujikawa.yamanashi.jp","fujikawaguchiko.yamanashi.jp","fujiyoshida.yamanashi.jp","hayakawa.yamanashi.jp","hokuto.yamanashi.jp","ichikawamisato.yamanashi.jp","kai.yamanashi.jp","kofu.yamanashi.jp","koshu.yamanashi.jp","kosuge.yamanashi.jp","minami-alps.yamanashi.jp","minobu.yamanashi.jp","nakamichi.yamanashi.jp","nanbu.yamanashi.jp","narusawa.yamanashi.jp","nirasaki.yamanashi.jp","nishikatsura.yamanashi.jp","oshino.yamanashi.jp","otsuki.yamanashi.jp","showa.yamanashi.jp","tabayama.yamanashi.jp","tsuru.yamanashi.jp","uenohara.yamanashi.jp","yamanakako.yamanashi.jp","yamanashi.yamanashi.jp","ke","ac.ke","co.ke","go.ke","info.ke","me.ke","mobi.ke","ne.ke","or.ke","sc.ke","kg","org.kg","net.kg","com.kg","edu.kg","gov.kg","mil.kg","*.kh","ki","edu.ki","biz.ki","net.ki","org.ki","gov.ki","info.ki","com.ki","km","org.km","nom.km","gov.km","prd.km","tm.km","edu.km","mil.km","ass.km","com.km","coop.km","asso.km","presse.km","medecin.km","notaires.km","pharmaciens.km","veterinaire.km","gouv.km","kn","net.kn","org.kn","edu.kn","gov.kn","kp","com.kp","edu.kp","gov.kp","org.kp","rep.kp","tra.kp","kr","ac.kr","co.kr","es.kr","go.kr","hs.kr","kg.kr","mil.kr","ms.kr","ne.kr","or.kr","pe.kr","re.kr","sc.kr","busan.kr","chungbuk.kr","chungnam.kr","daegu.kr","daejeon.kr","gangwon.kr","gwangju.kr","gyeongbuk.kr","gyeonggi.kr","gyeongnam.kr","incheon.kr","jeju.kr","jeonbuk.kr","jeonnam.kr","seoul.kr","ulsan.kr","kw","com.kw","edu.kw","emb.kw","gov.kw","ind.kw","net.kw","org.kw","ky","edu.ky","gov.ky","com.ky","org.ky","net.ky","kz","org.kz","edu.kz","net.kz","gov.kz","mil.kz","com.kz","la","int.la","net.la","info.la","edu.la","gov.la","per.la","com.la","org.la","lb","com.lb","edu.lb","gov.lb","net.lb","org.lb","lc","com.lc","net.lc","co.lc","org.lc","edu.lc","gov.lc","li","lk","gov.lk","sch.lk","net.lk","int.lk","com.lk","org.lk","edu.lk","ngo.lk","soc.lk","web.lk","ltd.lk","assn.lk","grp.lk","hotel.lk","ac.lk","lr","com.lr","edu.lr","gov.lr","org.lr","net.lr","ls","ac.ls","biz.ls","co.ls","edu.ls","gov.ls","info.ls","net.ls","org.ls","sc.ls","lt","gov.lt","lu","lv","com.lv","edu.lv","gov.lv","org.lv","mil.lv","id.lv","net.lv","asn.lv","conf.lv","ly","com.ly","net.ly","gov.ly","plc.ly","edu.ly","sch.ly","med.ly","org.ly","id.ly","ma","co.ma","net.ma","gov.ma","org.ma","ac.ma","press.ma","mc","tm.mc","asso.mc","md","me","co.me","net.me","org.me","edu.me","ac.me","gov.me","its.me","priv.me","mg","org.mg","nom.mg","gov.mg","prd.mg","tm.mg","edu.mg","mil.mg","com.mg","co.mg","mh","mil","mk","com.mk","org.mk","net.mk","edu.mk","gov.mk","inf.mk","name.mk","ml","com.ml","edu.ml","gouv.ml","gov.ml","net.ml","org.ml","presse.ml","*.mm","mn","gov.mn","edu.mn","org.mn","mo","com.mo","net.mo","org.mo","edu.mo","gov.mo","mobi","mp","mq","mr","gov.mr","ms","com.ms","edu.ms","gov.ms","net.ms","org.ms","mt","com.mt","edu.mt","net.mt","org.mt","mu","com.mu","net.mu","org.mu","gov.mu","ac.mu","co.mu","or.mu","museum","academy.museum","agriculture.museum","air.museum","airguard.museum","alabama.museum","alaska.museum","amber.museum","ambulance.museum","american.museum","americana.museum","americanantiques.museum","americanart.museum","amsterdam.museum","and.museum","annefrank.museum","anthro.museum","anthropology.museum","antiques.museum","aquarium.museum","arboretum.museum","archaeological.museum","archaeology.museum","architecture.museum","art.museum","artanddesign.museum","artcenter.museum","artdeco.museum","arteducation.museum","artgallery.museum","arts.museum","artsandcrafts.museum","asmatart.museum","assassination.museum","assisi.museum","association.museum","astronomy.museum","atlanta.museum","austin.museum","australia.museum","automotive.museum","aviation.museum","axis.museum","badajoz.museum","baghdad.museum","bahn.museum","bale.museum","baltimore.museum","barcelona.museum","baseball.museum","basel.museum","baths.museum","bauern.museum","beauxarts.museum","beeldengeluid.museum","bellevue.museum","bergbau.museum","berkeley.museum","berlin.museum","bern.museum","bible.museum","bilbao.museum","bill.museum","birdart.museum","birthplace.museum","bonn.museum","boston.museum","botanical.museum","botanicalgarden.museum","botanicgarden.museum","botany.museum","brandywinevalley.museum","brasil.museum","bristol.museum","british.museum","britishcolumbia.museum","broadcast.museum","brunel.museum","brussel.museum","brussels.museum","bruxelles.museum","building.museum","burghof.museum","bus.museum","bushey.museum","cadaques.museum","california.museum","cambridge.museum","can.museum","canada.museum","capebreton.museum","carrier.museum","cartoonart.museum","casadelamoneda.museum","castle.museum","castres.museum","celtic.museum","center.museum","chattanooga.museum","cheltenham.museum","chesapeakebay.museum","chicago.museum","children.museum","childrens.museum","childrensgarden.museum","chiropractic.museum","chocolate.museum","christiansburg.museum","cincinnati.museum","cinema.museum","circus.museum","civilisation.museum","civilization.museum","civilwar.museum","clinton.museum","clock.museum","coal.museum","coastaldefence.museum","cody.museum","coldwar.museum","collection.museum","colonialwilliamsburg.museum","coloradoplateau.museum","columbia.museum","columbus.museum","communication.museum","communications.museum","community.museum","computer.museum","computerhistory.museum","comunicações.museum","contemporary.museum","contemporaryart.museum","convent.museum","copenhagen.museum","corporation.museum","correios-e-telecomunicações.museum","corvette.museum","costume.museum","countryestate.museum","county.museum","crafts.museum","cranbrook.museum","creation.museum","cultural.museum","culturalcenter.museum","culture.museum","cyber.museum","cymru.museum","dali.museum","dallas.museum","database.museum","ddr.museum","decorativearts.museum","delaware.museum","delmenhorst.museum","denmark.museum","depot.museum","design.museum","detroit.museum","dinosaur.museum","discovery.museum","dolls.museum","donostia.museum","durham.museum","eastafrica.museum","eastcoast.museum","education.museum","educational.museum","egyptian.museum","eisenbahn.museum","elburg.museum","elvendrell.museum","embroidery.museum","encyclopedic.museum","england.museum","entomology.museum","environment.museum","environmentalconservation.museum","epilepsy.museum","essex.museum","estate.museum","ethnology.museum","exeter.museum","exhibition.museum","family.museum","farm.museum","farmequipment.museum","farmers.museum","farmstead.museum","field.museum","figueres.museum","filatelia.museum","film.museum","fineart.museum","finearts.museum","finland.museum","flanders.museum","florida.museum","force.museum","fortmissoula.museum","fortworth.museum","foundation.museum","francaise.museum","frankfurt.museum","franziskaner.museum","freemasonry.museum","freiburg.museum","fribourg.museum","frog.museum","fundacio.museum","furniture.museum","gallery.museum","garden.museum","gateway.museum","geelvinck.museum","gemological.museum","geology.museum","georgia.museum","giessen.museum","glas.museum","glass.museum","gorge.museum","grandrapids.museum","graz.museum","guernsey.museum","halloffame.museum","hamburg.museum","handson.museum","harvestcelebration.museum","hawaii.museum","health.museum","heimatunduhren.museum","hellas.museum","helsinki.museum","hembygdsforbund.museum","heritage.museum","histoire.museum","historical.museum","historicalsociety.museum","historichouses.museum","historisch.museum","historisches.museum","history.museum","historyofscience.museum","horology.museum","house.museum","humanities.museum","illustration.museum","imageandsound.museum","indian.museum","indiana.museum","indianapolis.museum","indianmarket.museum","intelligence.museum","interactive.museum","iraq.museum","iron.museum","isleofman.museum","jamison.museum","jefferson.museum","jerusalem.museum","jewelry.museum","jewish.museum","jewishart.museum","jfk.museum","journalism.museum","judaica.museum","judygarland.museum","juedisches.museum","juif.museum","karate.museum","karikatur.museum","kids.museum","koebenhavn.museum","koeln.museum","kunst.museum","kunstsammlung.museum","kunstunddesign.museum","labor.museum","labour.museum","lajolla.museum","lancashire.museum","landes.museum","lans.museum","läns.museum","larsson.museum","lewismiller.museum","lincoln.museum","linz.museum","living.museum","livinghistory.museum","localhistory.museum","london.museum","losangeles.museum","louvre.museum","loyalist.museum","lucerne.museum","luxembourg.museum","luzern.museum","mad.museum","madrid.museum","mallorca.museum","manchester.museum","mansion.museum","mansions.museum","manx.museum","marburg.museum","maritime.museum","maritimo.museum","maryland.museum","marylhurst.museum","media.museum","medical.museum","medizinhistorisches.museum","meeres.museum","memorial.museum","mesaverde.museum","michigan.museum","midatlantic.museum","military.museum","mill.museum","miners.museum","mining.museum","minnesota.museum","missile.museum","missoula.museum","modern.museum","moma.museum","money.museum","monmouth.museum","monticello.museum","montreal.museum","moscow.museum","motorcycle.museum","muenchen.museum","muenster.museum","mulhouse.museum","muncie.museum","museet.museum","museumcenter.museum","museumvereniging.museum","music.museum","national.museum","nationalfirearms.museum","nationalheritage.museum","nativeamerican.museum","naturalhistory.museum","naturalhistorymuseum.museum","naturalsciences.museum","nature.museum","naturhistorisches.museum","natuurwetenschappen.museum","naumburg.museum","naval.museum","nebraska.museum","neues.museum","newhampshire.museum","newjersey.museum","newmexico.museum","newport.museum","newspaper.museum","newyork.museum","niepce.museum","norfolk.museum","north.museum","nrw.museum","nuernberg.museum","nuremberg.museum","nyc.museum","nyny.museum","oceanographic.museum","oceanographique.museum","omaha.museum","online.museum","ontario.museum","openair.museum","oregon.museum","oregontrail.museum","otago.museum","oxford.museum","pacific.museum","paderborn.museum","palace.museum","paleo.museum","palmsprings.museum","panama.museum","paris.museum","pasadena.museum","pharmacy.museum","philadelphia.museum","philadelphiaarea.museum","philately.museum","phoenix.museum","photography.museum","pilots.museum","pittsburgh.museum","planetarium.museum","plantation.museum","plants.museum","plaza.museum","portal.museum","portland.museum","portlligat.museum","posts-and-telecommunications.museum","preservation.museum","presidio.museum","press.museum","project.museum","public.museum","pubol.museum","quebec.museum","railroad.museum","railway.museum","research.museum","resistance.museum","riodejaneiro.museum","rochester.museum","rockart.museum","roma.museum","russia.museum","saintlouis.museum","salem.museum","salvadordali.museum","salzburg.museum","sandiego.museum","sanfrancisco.museum","santabarbara.museum","santacruz.museum","santafe.museum","saskatchewan.museum","satx.museum","savannahga.museum","schlesisches.museum","schoenbrunn.museum","schokoladen.museum","school.museum","schweiz.museum","science.museum","scienceandhistory.museum","scienceandindustry.museum","sciencecenter.museum","sciencecenters.museum","science-fiction.museum","sciencehistory.museum","sciences.museum","sciencesnaturelles.museum","scotland.museum","seaport.museum","settlement.museum","settlers.museum","shell.museum","sherbrooke.museum","sibenik.museum","silk.museum","ski.museum","skole.museum","society.museum","sologne.museum","soundandvision.museum","southcarolina.museum","southwest.museum","space.museum","spy.museum","square.museum","stadt.museum","stalbans.museum","starnberg.museum","state.museum","stateofdelaware.museum","station.museum","steam.museum","steiermark.museum","stjohn.museum","stockholm.museum","stpetersburg.museum","stuttgart.museum","suisse.museum","surgeonshall.museum","surrey.museum","svizzera.museum","sweden.museum","sydney.museum","tank.museum","tcm.museum","technology.museum","telekommunikation.museum","television.museum","texas.museum","textile.museum","theater.museum","time.museum","timekeeping.museum","topology.museum","torino.museum","touch.museum","town.museum","transport.museum","tree.museum","trolley.museum","trust.museum","trustee.museum","uhren.museum","ulm.museum","undersea.museum","university.museum","usa.museum","usantiques.museum","usarts.museum","uscountryestate.museum","usculture.museum","usdecorativearts.museum","usgarden.museum","ushistory.museum","ushuaia.museum","uslivinghistory.museum","utah.museum","uvic.museum","valley.museum","vantaa.museum","versailles.museum","viking.museum","village.museum","virginia.museum","virtual.museum","virtuel.museum","vlaanderen.museum","volkenkunde.museum","wales.museum","wallonie.museum","war.museum","washingtondc.museum","watchandclock.museum","watch-and-clock.museum","western.museum","westfalen.museum","whaling.museum","wildlife.museum","williamsburg.museum","windmill.museum","workshop.museum","york.museum","yorkshire.museum","yosemite.museum","youth.museum","zoological.museum","zoology.museum","ירושלים.museum","иком.museum","mv","aero.mv","biz.mv","com.mv","coop.mv","edu.mv","gov.mv","info.mv","int.mv","mil.mv","museum.mv","name.mv","net.mv","org.mv","pro.mv","mw","ac.mw","biz.mw","co.mw","com.mw","coop.mw","edu.mw","gov.mw","int.mw","museum.mw","net.mw","org.mw","mx","com.mx","org.mx","gob.mx","edu.mx","net.mx","my","com.my","net.my","org.my","gov.my","edu.my","mil.my","name.my","mz","ac.mz","adv.mz","co.mz","edu.mz","gov.mz","mil.mz","net.mz","org.mz","na","info.na","pro.na","name.na","school.na","or.na","dr.na","us.na","mx.na","ca.na","in.na","cc.na","tv.na","ws.na","mobi.na","co.na","com.na","org.na","name","nc","asso.nc","nom.nc","ne","net","nf","com.nf","net.nf","per.nf","rec.nf","web.nf","arts.nf","firm.nf","info.nf","other.nf","store.nf","ng","com.ng","edu.ng","gov.ng","i.ng","mil.ng","mobi.ng","name.ng","net.ng","org.ng","sch.ng","ni","ac.ni","biz.ni","co.ni","com.ni","edu.ni","gob.ni","in.ni","info.ni","int.ni","mil.ni","net.ni","nom.ni","org.ni","web.ni","nl","no","fhs.no","vgs.no","fylkesbibl.no","folkebibl.no","museum.no","idrett.no","priv.no","mil.no","stat.no","dep.no","kommune.no","herad.no","aa.no","ah.no","bu.no","fm.no","hl.no","hm.no","jan-mayen.no","mr.no","nl.no","nt.no","of.no","ol.no","oslo.no","rl.no","sf.no","st.no","svalbard.no","tm.no","tr.no","va.no","vf.no","gs.aa.no","gs.ah.no","gs.bu.no","gs.fm.no","gs.hl.no","gs.hm.no","gs.jan-mayen.no","gs.mr.no","gs.nl.no","gs.nt.no","gs.of.no","gs.ol.no","gs.oslo.no","gs.rl.no","gs.sf.no","gs.st.no","gs.svalbard.no","gs.tm.no","gs.tr.no","gs.va.no","gs.vf.no","akrehamn.no","åkrehamn.no","algard.no","ålgård.no","arna.no","brumunddal.no","bryne.no","bronnoysund.no","brønnøysund.no","drobak.no","drøbak.no","egersund.no","fetsund.no","floro.no","florø.no","fredrikstad.no","hokksund.no","honefoss.no","hønefoss.no","jessheim.no","jorpeland.no","jørpeland.no","kirkenes.no","kopervik.no","krokstadelva.no","langevag.no","langevåg.no","leirvik.no","mjondalen.no","mjøndalen.no","mo-i-rana.no","mosjoen.no","mosjøen.no","nesoddtangen.no","orkanger.no","osoyro.no","osøyro.no","raholt.no","råholt.no","sandnessjoen.no","sandnessjøen.no","skedsmokorset.no","slattum.no","spjelkavik.no","stathelle.no","stavern.no","stjordalshalsen.no","stjørdalshalsen.no","tananger.no","tranby.no","vossevangen.no","afjord.no","åfjord.no","agdenes.no","al.no","ål.no","alesund.no","ålesund.no","alstahaug.no","alta.no","áltá.no","alaheadju.no","álaheadju.no","alvdal.no","amli.no","åmli.no","amot.no","åmot.no","andebu.no","andoy.no","andøy.no","andasuolo.no","ardal.no","årdal.no","aremark.no","arendal.no","ås.no","aseral.no","åseral.no","asker.no","askim.no","askvoll.no","askoy.no","askøy.no","asnes.no","åsnes.no","audnedaln.no","aukra.no","aure.no","aurland.no","aurskog-holand.no","aurskog-høland.no","austevoll.no","austrheim.no","averoy.no","averøy.no","balestrand.no","ballangen.no","balat.no","bálát.no","balsfjord.no","bahccavuotna.no","báhccavuotna.no","bamble.no","bardu.no","beardu.no","beiarn.no","bajddar.no","bájddar.no","baidar.no","báidár.no","berg.no","bergen.no","berlevag.no","berlevåg.no","bearalvahki.no","bearalváhki.no","bindal.no","birkenes.no","bjarkoy.no","bjarkøy.no","bjerkreim.no","bjugn.no","bodo.no","bodø.no","badaddja.no","bådåddjå.no","budejju.no","bokn.no","bremanger.no","bronnoy.no","brønnøy.no","bygland.no","bykle.no","barum.no","bærum.no","bo.telemark.no","bø.telemark.no","bo.nordland.no","bø.nordland.no","bievat.no","bievát.no","bomlo.no","bømlo.no","batsfjord.no","båtsfjord.no","bahcavuotna.no","báhcavuotna.no","dovre.no","drammen.no","drangedal.no","dyroy.no","dyrøy.no","donna.no","dønna.no","eid.no","eidfjord.no","eidsberg.no","eidskog.no","eidsvoll.no","eigersund.no","elverum.no","enebakk.no","engerdal.no","etne.no","etnedal.no","evenes.no","evenassi.no","evenášši.no","evje-og-hornnes.no","farsund.no","fauske.no","fuossko.no","fuoisku.no","fedje.no","fet.no","finnoy.no","finnøy.no","fitjar.no","fjaler.no","fjell.no","flakstad.no","flatanger.no","flekkefjord.no","flesberg.no","flora.no","fla.no","flå.no","folldal.no","forsand.no","fosnes.no","frei.no","frogn.no","froland.no","frosta.no","frana.no","fræna.no","froya.no","frøya.no","fusa.no","fyresdal.no","forde.no","førde.no","gamvik.no","gangaviika.no","gáŋgaviika.no","gaular.no","gausdal.no","gildeskal.no","gildeskål.no","giske.no","gjemnes.no","gjerdrum.no","gjerstad.no","gjesdal.no","gjovik.no","gjøvik.no","gloppen.no","gol.no","gran.no","grane.no","granvin.no","gratangen.no","grimstad.no","grong.no","kraanghke.no","kråanghke.no","grue.no","gulen.no","hadsel.no","halden.no","halsa.no","hamar.no","hamaroy.no","habmer.no","hábmer.no","hapmir.no","hápmir.no","hammerfest.no","hammarfeasta.no","hámmárfeasta.no","haram.no","hareid.no","harstad.no","hasvik.no","aknoluokta.no","ákŋoluokta.no","hattfjelldal.no","aarborte.no","haugesund.no","hemne.no","hemnes.no","hemsedal.no","heroy.more-og-romsdal.no","herøy.møre-og-romsdal.no","heroy.nordland.no","herøy.nordland.no","hitra.no","hjartdal.no","hjelmeland.no","hobol.no","hobøl.no","hof.no","hol.no","hole.no","holmestrand.no","holtalen.no","holtålen.no","hornindal.no","horten.no","hurdal.no","hurum.no","hvaler.no","hyllestad.no","hagebostad.no","hægebostad.no","hoyanger.no","høyanger.no","hoylandet.no","høylandet.no","ha.no","hå.no","ibestad.no","inderoy.no","inderøy.no","iveland.no","jevnaker.no","jondal.no","jolster.no","jølster.no","karasjok.no","karasjohka.no","kárášjohka.no","karlsoy.no","galsa.no","gálsá.no","karmoy.no","karmøy.no","kautokeino.no","guovdageaidnu.no","klepp.no","klabu.no","klæbu.no","kongsberg.no","kongsvinger.no","kragero.no","kragerø.no","kristiansand.no","kristiansund.no","krodsherad.no","krødsherad.no","kvalsund.no","rahkkeravju.no","ráhkkerávju.no","kvam.no","kvinesdal.no","kvinnherad.no","kviteseid.no","kvitsoy.no","kvitsøy.no","kvafjord.no","kvæfjord.no","giehtavuoatna.no","kvanangen.no","kvænangen.no","navuotna.no","návuotna.no","kafjord.no","kåfjord.no","gaivuotna.no","gáivuotna.no","larvik.no","lavangen.no","lavagis.no","loabat.no","loabát.no","lebesby.no","davvesiida.no","leikanger.no","leirfjord.no","leka.no","leksvik.no","lenvik.no","leangaviika.no","leaŋgaviika.no","lesja.no","levanger.no","lier.no","lierne.no","lillehammer.no","lillesand.no","lindesnes.no","lindas.no","lindås.no","lom.no","loppa.no","lahppi.no","láhppi.no","lund.no","lunner.no","luroy.no","lurøy.no","luster.no","lyngdal.no","lyngen.no","ivgu.no","lardal.no","lerdal.no","lærdal.no","lodingen.no","lødingen.no","lorenskog.no","lørenskog.no","loten.no","løten.no","malvik.no","masoy.no","måsøy.no","muosat.no","muosát.no","mandal.no","marker.no","marnardal.no","masfjorden.no","meland.no","meldal.no","melhus.no","meloy.no","meløy.no","meraker.no","meråker.no","moareke.no","moåreke.no","midsund.no","midtre-gauldal.no","modalen.no","modum.no","molde.no","moskenes.no","moss.no","mosvik.no","malselv.no","målselv.no","malatvuopmi.no","málatvuopmi.no","namdalseid.no","aejrie.no","namsos.no","namsskogan.no","naamesjevuemie.no","nååmesjevuemie.no","laakesvuemie.no","nannestad.no","narvik.no","narviika.no","naustdal.no","nedre-eiker.no","nes.akershus.no","nes.buskerud.no","nesna.no","nesodden.no","nesseby.no","unjarga.no","unjárga.no","nesset.no","nissedal.no","nittedal.no","nord-aurdal.no","nord-fron.no","nord-odal.no","norddal.no","nordkapp.no","davvenjarga.no","davvenjárga.no","nordre-land.no","nordreisa.no","raisa.no","ráisa.no","nore-og-uvdal.no","notodden.no","naroy.no","nærøy.no","notteroy.no","nøtterøy.no","odda.no","oksnes.no","øksnes.no","oppdal.no","oppegard.no","oppegård.no","orkdal.no","orland.no","ørland.no","orskog.no","ørskog.no","orsta.no","ørsta.no","os.hedmark.no","os.hordaland.no","osen.no","osteroy.no","osterøy.no","ostre-toten.no","østre-toten.no","overhalla.no","ovre-eiker.no","øvre-eiker.no","oyer.no","øyer.no","oygarden.no","øygarden.no","oystre-slidre.no","øystre-slidre.no","porsanger.no","porsangu.no","porsáŋgu.no","porsgrunn.no","radoy.no","radøy.no","rakkestad.no","rana.no","ruovat.no","randaberg.no","rauma.no","rendalen.no","rennebu.no","rennesoy.no","rennesøy.no","rindal.no","ringebu.no","ringerike.no","ringsaker.no","rissa.no","risor.no","risør.no","roan.no","rollag.no","rygge.no","ralingen.no","rælingen.no","rodoy.no","rødøy.no","romskog.no","rømskog.no","roros.no","røros.no","rost.no","røst.no","royken.no","røyken.no","royrvik.no","røyrvik.no","rade.no","råde.no","salangen.no","siellak.no","saltdal.no","salat.no","sálát.no","sálat.no","samnanger.no","sande.more-og-romsdal.no","sande.møre-og-romsdal.no","sande.vestfold.no","sandefjord.no","sandnes.no","sandoy.no","sandøy.no","sarpsborg.no","sauda.no","sauherad.no","sel.no","selbu.no","selje.no","seljord.no","sigdal.no","siljan.no","sirdal.no","skaun.no","skedsmo.no","ski.no","skien.no","skiptvet.no","skjervoy.no","skjervøy.no","skierva.no","skiervá.no","skjak.no","skjåk.no","skodje.no","skanland.no","skånland.no","skanit.no","skánit.no","smola.no","smøla.no","snillfjord.no","snasa.no","snåsa.no","snoasa.no","snaase.no","snåase.no","sogndal.no","sokndal.no","sola.no","solund.no","songdalen.no","sortland.no","spydeberg.no","stange.no","stavanger.no","steigen.no","steinkjer.no","stjordal.no","stjørdal.no","stokke.no","stor-elvdal.no","stord.no","stordal.no","storfjord.no","omasvuotna.no","strand.no","stranda.no","stryn.no","sula.no","suldal.no","sund.no","sunndal.no","surnadal.no","sveio.no","svelvik.no","sykkylven.no","sogne.no","søgne.no","somna.no","sømna.no","sondre-land.no","søndre-land.no","sor-aurdal.no","sør-aurdal.no","sor-fron.no","sør-fron.no","sor-odal.no","sør-odal.no","sor-varanger.no","sør-varanger.no","matta-varjjat.no","mátta-várjjat.no","sorfold.no","sørfold.no","sorreisa.no","sørreisa.no","sorum.no","sørum.no","tana.no","deatnu.no","time.no","tingvoll.no","tinn.no","tjeldsund.no","dielddanuorri.no","tjome.no","tjøme.no","tokke.no","tolga.no","torsken.no","tranoy.no","tranøy.no","tromso.no","tromsø.no","tromsa.no","romsa.no","trondheim.no","troandin.no","trysil.no","trana.no","træna.no","trogstad.no","trøgstad.no","tvedestrand.no","tydal.no","tynset.no","tysfjord.no","divtasvuodna.no","divttasvuotna.no","tysnes.no","tysvar.no","tysvær.no","tonsberg.no","tønsberg.no","ullensaker.no","ullensvang.no","ulvik.no","utsira.no","vadso.no","vadsø.no","cahcesuolo.no","čáhcesuolo.no","vaksdal.no","valle.no","vang.no","vanylven.no","vardo.no","vardø.no","varggat.no","várggát.no","vefsn.no","vaapste.no","vega.no","vegarshei.no","vegårshei.no","vennesla.no","verdal.no","verran.no","vestby.no","vestnes.no","vestre-slidre.no","vestre-toten.no","vestvagoy.no","vestvågøy.no","vevelstad.no","vik.no","vikna.no","vindafjord.no","volda.no","voss.no","varoy.no","værøy.no","vagan.no","vågan.no","voagat.no","vagsoy.no","vågsøy.no","vaga.no","vågå.no","valer.ostfold.no","våler.østfold.no","valer.hedmark.no","våler.hedmark.no","*.np","nr","biz.nr","info.nr","gov.nr","edu.nr","org.nr","net.nr","com.nr","nu","nz","ac.nz","co.nz","cri.nz","geek.nz","gen.nz","govt.nz","health.nz","iwi.nz","kiwi.nz","maori.nz","mil.nz","māori.nz","net.nz","org.nz","parliament.nz","school.nz","om","co.om","com.om","edu.om","gov.om","med.om","museum.om","net.om","org.om","pro.om","onion","org","pa","ac.pa","gob.pa","com.pa","org.pa","sld.pa","edu.pa","net.pa","ing.pa","abo.pa","med.pa","nom.pa","pe","edu.pe","gob.pe","nom.pe","mil.pe","org.pe","com.pe","net.pe","pf","com.pf","org.pf","edu.pf","*.pg","ph","com.ph","net.ph","org.ph","gov.ph","edu.ph","ngo.ph","mil.ph","i.ph","pk","com.pk","net.pk","edu.pk","org.pk","fam.pk","biz.pk","web.pk","gov.pk","gob.pk","gok.pk","gon.pk","gop.pk","gos.pk","info.pk","pl","com.pl","net.pl","org.pl","aid.pl","agro.pl","atm.pl","auto.pl","biz.pl","edu.pl","gmina.pl","gsm.pl","info.pl","mail.pl","miasta.pl","media.pl","mil.pl","nieruchomosci.pl","nom.pl","pc.pl","powiat.pl","priv.pl","realestate.pl","rel.pl","sex.pl","shop.pl","sklep.pl","sos.pl","szkola.pl","targi.pl","tm.pl","tourism.pl","travel.pl","turystyka.pl","gov.pl","ap.gov.pl","ic.gov.pl","is.gov.pl","us.gov.pl","kmpsp.gov.pl","kppsp.gov.pl","kwpsp.gov.pl","psp.gov.pl","wskr.gov.pl","kwp.gov.pl","mw.gov.pl","ug.gov.pl","um.gov.pl","umig.gov.pl","ugim.gov.pl","upow.gov.pl","uw.gov.pl","starostwo.gov.pl","pa.gov.pl","po.gov.pl","psse.gov.pl","pup.gov.pl","rzgw.gov.pl","sa.gov.pl","so.gov.pl","sr.gov.pl","wsa.gov.pl","sko.gov.pl","uzs.gov.pl","wiih.gov.pl","winb.gov.pl","pinb.gov.pl","wios.gov.pl","witd.gov.pl","wzmiuw.gov.pl","piw.gov.pl","wiw.gov.pl","griw.gov.pl","wif.gov.pl","oum.gov.pl","sdn.gov.pl","zp.gov.pl","uppo.gov.pl","mup.gov.pl","wuoz.gov.pl","konsulat.gov.pl","oirm.gov.pl","augustow.pl","babia-gora.pl","bedzin.pl","beskidy.pl","bialowieza.pl","bialystok.pl","bielawa.pl","bieszczady.pl","boleslawiec.pl","bydgoszcz.pl","bytom.pl","cieszyn.pl","czeladz.pl","czest.pl","dlugoleka.pl","elblag.pl","elk.pl","glogow.pl","gniezno.pl","gorlice.pl","grajewo.pl","ilawa.pl","jaworzno.pl","jelenia-gora.pl","jgora.pl","kalisz.pl","kazimierz-dolny.pl","karpacz.pl","kartuzy.pl","kaszuby.pl","katowice.pl","kepno.pl","ketrzyn.pl","klodzko.pl","kobierzyce.pl","kolobrzeg.pl","konin.pl","konskowola.pl","kutno.pl","lapy.pl","lebork.pl","legnica.pl","lezajsk.pl","limanowa.pl","lomza.pl","lowicz.pl","lubin.pl","lukow.pl","malbork.pl","malopolska.pl","mazowsze.pl","mazury.pl","mielec.pl","mielno.pl","mragowo.pl","naklo.pl","nowaruda.pl","nysa.pl","olawa.pl","olecko.pl","olkusz.pl","olsztyn.pl","opoczno.pl","opole.pl","ostroda.pl","ostroleka.pl","ostrowiec.pl","ostrowwlkp.pl","pila.pl","pisz.pl","podhale.pl","podlasie.pl","polkowice.pl","pomorze.pl","pomorskie.pl","prochowice.pl","pruszkow.pl","przeworsk.pl","pulawy.pl","radom.pl","rawa-maz.pl","rybnik.pl","rzeszow.pl","sanok.pl","sejny.pl","slask.pl","slupsk.pl","sosnowiec.pl","stalowa-wola.pl","skoczow.pl","starachowice.pl","stargard.pl","suwalki.pl","swidnica.pl","swiebodzin.pl","swinoujscie.pl","szczecin.pl","szczytno.pl","tarnobrzeg.pl","tgory.pl","turek.pl","tychy.pl","ustka.pl","walbrzych.pl","warmia.pl","warszawa.pl","waw.pl","wegrow.pl","wielun.pl","wlocl.pl","wloclawek.pl","wodzislaw.pl","wolomin.pl","wroclaw.pl","zachpomor.pl","zagan.pl","zarow.pl","zgora.pl","zgorzelec.pl","pm","pn","gov.pn","co.pn","org.pn","edu.pn","net.pn","post","pr","com.pr","net.pr","org.pr","gov.pr","edu.pr","isla.pr","pro.pr","biz.pr","info.pr","name.pr","est.pr","prof.pr","ac.pr","pro","aaa.pro","aca.pro","acct.pro","avocat.pro","bar.pro","cpa.pro","eng.pro","jur.pro","law.pro","med.pro","recht.pro","ps","edu.ps","gov.ps","sec.ps","plo.ps","com.ps","org.ps","net.ps","pt","net.pt","gov.pt","org.pt","edu.pt","int.pt","publ.pt","com.pt","nome.pt","pw","co.pw","ne.pw","or.pw","ed.pw","go.pw","belau.pw","py","com.py","coop.py","edu.py","gov.py","mil.py","net.py","org.py","qa","com.qa","edu.qa","gov.qa","mil.qa","name.qa","net.qa","org.qa","sch.qa","re","asso.re","com.re","nom.re","ro","arts.ro","com.ro","firm.ro","info.ro","nom.ro","nt.ro","org.ro","rec.ro","store.ro","tm.ro","www.ro","rs","ac.rs","co.rs","edu.rs","gov.rs","in.rs","org.rs","ru","ac.ru","edu.ru","gov.ru","int.ru","mil.ru","test.ru","rw","ac.rw","co.rw","coop.rw","gov.rw","mil.rw","net.rw","org.rw","sa","com.sa","net.sa","org.sa","gov.sa","med.sa","pub.sa","edu.sa","sch.sa","sb","com.sb","edu.sb","gov.sb","net.sb","org.sb","sc","com.sc","gov.sc","net.sc","org.sc","edu.sc","sd","com.sd","net.sd","org.sd","edu.sd","med.sd","tv.sd","gov.sd","info.sd","se","a.se","ac.se","b.se","bd.se","brand.se","c.se","d.se","e.se","f.se","fh.se","fhsk.se","fhv.se","g.se","h.se","i.se","k.se","komforb.se","kommunalforbund.se","komvux.se","l.se","lanbib.se","m.se","n.se","naturbruksgymn.se","o.se","org.se","p.se","parti.se","pp.se","press.se","r.se","s.se","t.se","tm.se","u.se","w.se","x.se","y.se","z.se","sg","com.sg","net.sg","org.sg","gov.sg","edu.sg","per.sg","sh","com.sh","net.sh","gov.sh","org.sh","mil.sh","si","sj","sk","sl","com.sl","net.sl","edu.sl","gov.sl","org.sl","sm","sn","art.sn","com.sn","edu.sn","gouv.sn","org.sn","perso.sn","univ.sn","so","com.so","net.so","org.so","sr","st","co.st","com.st","consulado.st","edu.st","embaixada.st","gov.st","mil.st","net.st","org.st","principe.st","saotome.st","store.st","su","sv","com.sv","edu.sv","gob.sv","org.sv","red.sv","sx","gov.sx","sy","edu.sy","gov.sy","net.sy","mil.sy","com.sy","org.sy","sz","co.sz","ac.sz","org.sz","tc","td","tel","tf","tg","th","ac.th","co.th","go.th","in.th","mi.th","net.th","or.th","tj","ac.tj","biz.tj","co.tj","com.tj","edu.tj","go.tj","gov.tj","int.tj","mil.tj","name.tj","net.tj","nic.tj","org.tj","test.tj","web.tj","tk","tl","gov.tl","tm","com.tm","co.tm","org.tm","net.tm","nom.tm","gov.tm","mil.tm","edu.tm","tn","com.tn","ens.tn","fin.tn","gov.tn","ind.tn","intl.tn","nat.tn","net.tn","org.tn","info.tn","perso.tn","tourism.tn","edunet.tn","rnrt.tn","rns.tn","rnu.tn","mincom.tn","agrinet.tn","defense.tn","turen.tn","to","com.to","gov.to","net.to","org.to","edu.to","mil.to","tr","av.tr","bbs.tr","bel.tr","biz.tr","com.tr","dr.tr","edu.tr","gen.tr","gov.tr","info.tr","mil.tr","k12.tr","kep.tr","name.tr","net.tr","org.tr","pol.tr","tel.tr","tsk.tr","tv.tr","web.tr","nc.tr","gov.nc.tr","tt","co.tt","com.tt","org.tt","net.tt","biz.tt","info.tt","pro.tt","int.tt","coop.tt","jobs.tt","mobi.tt","travel.tt","museum.tt","aero.tt","name.tt","gov.tt","edu.tt","tv","tw","edu.tw","gov.tw","mil.tw","com.tw","net.tw","org.tw","idv.tw","game.tw","ebiz.tw","club.tw","網路.tw","組織.tw","商業.tw","tz","ac.tz","co.tz","go.tz","hotel.tz","info.tz","me.tz","mil.tz","mobi.tz","ne.tz","or.tz","sc.tz","tv.tz","ua","com.ua","edu.ua","gov.ua","in.ua","net.ua","org.ua","cherkassy.ua","cherkasy.ua","chernigov.ua","chernihiv.ua","chernivtsi.ua","chernovtsy.ua","ck.ua","cn.ua","cr.ua","crimea.ua","cv.ua","dn.ua","dnepropetrovsk.ua","dnipropetrovsk.ua","dominic.ua","donetsk.ua","dp.ua","if.ua","ivano-frankivsk.ua","kh.ua","kharkiv.ua","kharkov.ua","kherson.ua","khmelnitskiy.ua","khmelnytskyi.ua","kiev.ua","kirovograd.ua","km.ua","kr.ua","krym.ua","ks.ua","kv.ua","kyiv.ua","lg.ua","lt.ua","lugansk.ua","lutsk.ua","lv.ua","lviv.ua","mk.ua","mykolaiv.ua","nikolaev.ua","od.ua","odesa.ua","odessa.ua","pl.ua","poltava.ua","rivne.ua","rovno.ua","rv.ua","sb.ua","sebastopol.ua","sevastopol.ua","sm.ua","sumy.ua","te.ua","ternopil.ua","uz.ua","uzhgorod.ua","vinnica.ua","vinnytsia.ua","vn.ua","volyn.ua","yalta.ua","zaporizhzhe.ua","zaporizhzhia.ua","zhitomir.ua","zhytomyr.ua","zp.ua","zt.ua","ug","co.ug","or.ug","ac.ug","sc.ug","go.ug","ne.ug","com.ug","org.ug","uk","ac.uk","co.uk","gov.uk","ltd.uk","me.uk","net.uk","nhs.uk","org.uk","plc.uk","police.uk","*.sch.uk","us","dni.us","fed.us","isa.us","kids.us","nsn.us","ak.us","al.us","ar.us","as.us","az.us","ca.us","co.us","ct.us","dc.us","de.us","fl.us","ga.us","gu.us","hi.us","ia.us","id.us","il.us","in.us","ks.us","ky.us","la.us","ma.us","md.us","me.us","mi.us","mn.us","mo.us","ms.us","mt.us","nc.us","nd.us","ne.us","nh.us","nj.us","nm.us","nv.us","ny.us","oh.us","ok.us","or.us","pa.us","pr.us","ri.us","sc.us","sd.us","tn.us","tx.us","ut.us","vi.us","vt.us","va.us","wa.us","wi.us","wv.us","wy.us","k12.ak.us","k12.al.us","k12.ar.us","k12.as.us","k12.az.us","k12.ca.us","k12.co.us","k12.ct.us","k12.dc.us","k12.de.us","k12.fl.us","k12.ga.us","k12.gu.us","k12.ia.us","k12.id.us","k12.il.us","k12.in.us","k12.ks.us","k12.ky.us","k12.la.us","k12.ma.us","k12.md.us","k12.me.us","k12.mi.us","k12.mn.us","k12.mo.us","k12.ms.us","k12.mt.us","k12.nc.us","k12.ne.us","k12.nh.us","k12.nj.us","k12.nm.us","k12.nv.us","k12.ny.us","k12.oh.us","k12.ok.us","k12.or.us","k12.pa.us","k12.pr.us","k12.ri.us","k12.sc.us","k12.tn.us","k12.tx.us","k12.ut.us","k12.vi.us","k12.vt.us","k12.va.us","k12.wa.us","k12.wi.us","k12.wy.us","cc.ak.us","cc.al.us","cc.ar.us","cc.as.us","cc.az.us","cc.ca.us","cc.co.us","cc.ct.us","cc.dc.us","cc.de.us","cc.fl.us","cc.ga.us","cc.gu.us","cc.hi.us","cc.ia.us","cc.id.us","cc.il.us","cc.in.us","cc.ks.us","cc.ky.us","cc.la.us","cc.ma.us","cc.md.us","cc.me.us","cc.mi.us","cc.mn.us","cc.mo.us","cc.ms.us","cc.mt.us","cc.nc.us","cc.nd.us","cc.ne.us","cc.nh.us","cc.nj.us","cc.nm.us","cc.nv.us","cc.ny.us","cc.oh.us","cc.ok.us","cc.or.us","cc.pa.us","cc.pr.us","cc.ri.us","cc.sc.us","cc.sd.us","cc.tn.us","cc.tx.us","cc.ut.us","cc.vi.us","cc.vt.us","cc.va.us","cc.wa.us","cc.wi.us","cc.wv.us","cc.wy.us","lib.ak.us","lib.al.us","lib.ar.us","lib.as.us","lib.az.us","lib.ca.us","lib.co.us","lib.ct.us","lib.dc.us","lib.fl.us","lib.ga.us","lib.gu.us","lib.hi.us","lib.ia.us","lib.id.us","lib.il.us","lib.in.us","lib.ks.us","lib.ky.us","lib.la.us","lib.ma.us","lib.md.us","lib.me.us","lib.mi.us","lib.mn.us","lib.mo.us","lib.ms.us","lib.mt.us","lib.nc.us","lib.nd.us","lib.ne.us","lib.nh.us","lib.nj.us","lib.nm.us","lib.nv.us","lib.ny.us","lib.oh.us","lib.ok.us","lib.or.us","lib.pa.us","lib.pr.us","lib.ri.us","lib.sc.us","lib.sd.us","lib.tn.us","lib.tx.us","lib.ut.us","lib.vi.us","lib.vt.us","lib.va.us","lib.wa.us","lib.wi.us","lib.wy.us","pvt.k12.ma.us","chtr.k12.ma.us","paroch.k12.ma.us","ann-arbor.mi.us","cog.mi.us","dst.mi.us","eaton.mi.us","gen.mi.us","mus.mi.us","tec.mi.us","washtenaw.mi.us","uy","com.uy","edu.uy","gub.uy","mil.uy","net.uy","org.uy","uz","co.uz","com.uz","net.uz","org.uz","va","vc","com.vc","net.vc","org.vc","gov.vc","mil.vc","edu.vc","ve","arts.ve","co.ve","com.ve","e12.ve","edu.ve","firm.ve","gob.ve","gov.ve","info.ve","int.ve","mil.ve","net.ve","org.ve","rec.ve","store.ve","tec.ve","web.ve","vg","vi","co.vi","com.vi","k12.vi","net.vi","org.vi","vn","com.vn","net.vn","org.vn","edu.vn","gov.vn","int.vn","ac.vn","biz.vn","info.vn","name.vn","pro.vn","health.vn","vu","com.vu","edu.vu","net.vu","org.vu","wf","ws","com.ws","net.ws","org.ws","gov.ws","edu.ws","yt","امارات","հայ","বাংলা","бг","бел","中国","中國","الجزائر","مصر","ею","გე","ελ","香港","公司.香港","教育.香港","政府.香港","個人.香港","網絡.香港","組織.香港","ಭಾರತ","ଭାରତ","ভাৰত","भारतम्","भारोत","ڀارت","ഭാരതം","भारत","بارت","بھارت","భారత్","ભારત","ਭਾਰਤ","ভারত","இந்தியா","ایران","ايران","عراق","الاردن","한국","қаз","ලංකා","இலங்கை","المغرب","мкд","мон","澳門","澳门","مليسيا","عمان","پاکستان","پاكستان","فلسطين","срб","пр.срб","орг.срб","обр.срб","од.срб","упр.срб","ак.срб","рф","قطر","السعودية","السعودیة","السعودیۃ","السعوديه","سودان","新加坡","சிங்கப்பூர்","سورية","سوريا","ไทย","ศึกษา.ไทย","ธุรกิจ.ไทย","รัฐบาล.ไทย","ทหาร.ไทย","เน็ต.ไทย","องค์กร.ไทย","تونس","台灣","台湾","臺灣","укр","اليمن","xxx","*.ye","ac.za","agric.za","alt.za","co.za","edu.za","gov.za","grondar.za","law.za","mil.za","net.za","ngo.za","nis.za","nom.za","org.za","school.za","tm.za","web.za","zm","ac.zm","biz.zm","co.zm","com.zm","edu.zm","gov.zm","info.zm","mil.zm","net.zm","org.zm","sch.zm","zw","ac.zw","co.zw","gov.zw","mil.zw","org.zw","aaa","aarp","abarth","abb","abbott","abbvie","abc","able","abogado","abudhabi","academy","accenture","accountant","accountants","aco","actor","adac","ads","adult","aeg","aetna","afamilycompany","afl","africa","agakhan","agency","aig","aigo","airbus","airforce","airtel","akdn","alfaromeo","alibaba","alipay","allfinanz","allstate","ally","alsace","alstom","americanexpress","americanfamily","amex","amfam","amica","amsterdam","analytics","android","anquan","anz","aol","apartments","app","apple","aquarelle","arab","aramco","archi","army","art","arte","asda","associates","athleta","attorney","auction","audi","audible","audio","auspost","author","auto","autos","avianca","aws","axa","azure","baby","baidu","banamex","bananarepublic","band","bank","bar","barcelona","barclaycard","barclays","barefoot","bargains","baseball","basketball","bauhaus","bayern","bbc","bbt","bbva","bcg","bcn","beats","beauty","beer","bentley","berlin","best","bestbuy","bet","bharti","bible","bid","bike","bing","bingo","bio","black","blackfriday","blockbuster","blog","bloomberg","blue","bms","bmw","bnl","bnpparibas","boats","boehringer","bofa","bom","bond","boo","book","booking","bosch","bostik","boston","bot","boutique","box","bradesco","bridgestone","broadway","broker","brother","brussels","budapest","bugatti","build","builders","business","buy","buzz","bzh","cab","cafe","cal","call","calvinklein","cam","camera","camp","cancerresearch","canon","capetown","capital","capitalone","car","caravan","cards","care","career","careers","cars","cartier","casa","case","caseih","cash","casino","catering","catholic","cba","cbn","cbre","cbs","ceb","center","ceo","cern","cfa","cfd","chanel","channel","charity","chase","chat","cheap","chintai","christmas","chrome","chrysler","church","cipriani","circle","cisco","citadel","citi","citic","city","cityeats","claims","cleaning","click","clinic","clinique","clothing","cloud","club","clubmed","coach","codes","coffee","college","cologne","comcast","commbank","community","company","compare","computer","comsec","condos","construction","consulting","contact","contractors","cooking","cookingchannel","cool","corsica","country","coupon","coupons","courses","credit","creditcard","creditunion","cricket","crown","crs","cruise","cruises","csc","cuisinella","cymru","cyou","dabur","dad","dance","data","date","dating","datsun","day","dclk","dds","deal","dealer","deals","degree","delivery","dell","deloitte","delta","democrat","dental","dentist","desi","design","dev","dhl","diamonds","diet","digital","direct","directory","discount","discover","dish","diy","dnp","docs","doctor","dodge","dog","domains","dot","download","drive","dtv","dubai","duck","dunlop","duns","dupont","durban","dvag","dvr","earth","eat","eco","edeka","education","email","emerck","energy","engineer","engineering","enterprises","epson","equipment","ericsson","erni","esq","estate","esurance","etisalat","eurovision","eus","events","everbank","exchange","expert","exposed","express","extraspace","fage","fail","fairwinds","faith","family","fan","fans","farm","farmers","fashion","fast","fedex","feedback","ferrari","ferrero","fiat","fidelity","fido","film","final","finance","financial","fire","firestone","firmdale","fish","fishing","fit","fitness","flickr","flights","flir","florist","flowers","fly","foo","food","foodnetwork","football","ford","forex","forsale","forum","foundation","fox","free","fresenius","frl","frogans","frontdoor","frontier","ftr","fujitsu","fujixerox","fun","fund","furniture","futbol","fyi","gal","gallery","gallo","gallup","game","games","gap","garden","gbiz","gdn","gea","gent","genting","george","ggee","gift","gifts","gives","giving","glade","glass","gle","global","globo","gmail","gmbh","gmo","gmx","godaddy","gold","goldpoint","golf","goo","goodyear","goog","google","gop","got","grainger","graphics","gratis","green","gripe","grocery","group","guardian","gucci","guge","guide","guitars","guru","hair","hamburg","hangout","haus","hbo","hdfc","hdfcbank","health","healthcare","help","helsinki","here","hermes","hgtv","hiphop","hisamitsu","hitachi","hiv","hkt","hockey","holdings","holiday","homedepot","homegoods","homes","homesense","honda","honeywell","horse","hospital","host","hosting","hot","hoteles","hotels","hotmail","house","how","hsbc","hughes","hyatt","hyundai","ibm","icbc","ice","icu","ieee","ifm","ikano","imamat","imdb","immo","immobilien","inc","industries","infiniti","ing","ink","institute","insurance","insure","intel","international","intuit","investments","ipiranga","irish","iselect","ismaili","ist","istanbul","itau","itv","iveco","jaguar","java","jcb","jcp","jeep","jetzt","jewelry","jio","jll","jmp","jnj","joburg","jot","joy","jpmorgan","jprs","juegos","juniper","kaufen","kddi","kerryhotels","kerrylogistics","kerryproperties","kfh","kia","kim","kinder","kindle","kitchen","kiwi","koeln","komatsu","kosher","kpmg","kpn","krd","kred","kuokgroup","kyoto","lacaixa","ladbrokes","lamborghini","lamer","lancaster","lancia","lancome","land","landrover","lanxess","lasalle","lat","latino","latrobe","law","lawyer","lds","lease","leclerc","lefrak","legal","lego","lexus","lgbt","liaison","lidl","life","lifeinsurance","lifestyle","lighting","like","lilly","limited","limo","lincoln","linde","link","lipsy","live","living","lixil","llc","loan","loans","locker","locus","loft","lol","london","lotte","lotto","love","lpl","lplfinancial","ltd","ltda","lundbeck","lupin","luxe","luxury","macys","madrid","maif","maison","makeup","man","management","mango","map","market","marketing","markets","marriott","marshalls","maserati","mattel","mba","mckinsey","med","media","meet","melbourne","meme","memorial","men","menu","merckmsd","metlife","miami","microsoft","mini","mint","mit","mitsubishi","mlb","mls","mma","mobile","mobily","moda","moe","moi","mom","monash","money","monster","mopar","mormon","mortgage","moscow","moto","motorcycles","mov","movie","movistar","msd","mtn","mtr","mutual","nab","nadex","nagoya","nationwide","natura","navy","nba","nec","netbank","netflix","network","neustar","new","newholland","news","next","nextdirect","nexus","nfl","ngo","nhk","nico","nike","nikon","ninja","nissan","nissay","nokia","northwesternmutual","norton","now","nowruz","nowtv","nra","nrw","ntt","nyc","obi","observer","off","office","okinawa","olayan","olayangroup","oldnavy","ollo","omega","one","ong","onl","online","onyourside","ooo","open","oracle","orange","organic","origins","osaka","otsuka","ott","ovh","page","panasonic","paris","pars","partners","parts","party","passagens","pay","pccw","pet","pfizer","pharmacy","phd","philips","phone","photo","photography","photos","physio","piaget","pics","pictet","pictures","pid","pin","ping","pink","pioneer","pizza","place","play","playstation","plumbing","plus","pnc","pohl","poker","politie","porn","pramerica","praxi","press","prime","prod","productions","prof","progressive","promo","properties","property","protection","pru","prudential","pub","pwc","qpon","quebec","quest","qvc","racing","radio","raid","read","realestate","realtor","realty","recipes","red","redstone","redumbrella","rehab","reise","reisen","reit","reliance","ren","rent","rentals","repair","report","republican","rest","restaurant","review","reviews","rexroth","rich","richardli","ricoh","rightathome","ril","rio","rip","rmit","rocher","rocks","rodeo","rogers","room","rsvp","rugby","ruhr","run","rwe","ryukyu","saarland","safe","safety","sakura","sale","salon","samsclub","samsung","sandvik","sandvikcoromant","sanofi","sap","sarl","sas","save","saxo","sbi","sbs","sca","scb","schaeffler","schmidt","scholarships","school","schule","schwarz","science","scjohnson","scor","scot","search","seat","secure","security","seek","select","sener","services","ses","seven","sew","sex","sexy","sfr","shangrila","sharp","shaw","shell","shia","shiksha","shoes","shop","shopping","shouji","show","showtime","shriram","silk","sina","singles","site","ski","skin","sky","skype","sling","smart","smile","sncf","soccer","social","softbank","software","sohu","solar","solutions","song","sony","soy","space","sport","spot","spreadbetting","srl","srt","stada","staples","star","starhub","statebank","statefarm","stc","stcgroup","stockholm","storage","store","stream","studio","study","style","sucks","supplies","supply","support","surf","surgery","suzuki","swatch","swiftcover","swiss","sydney","symantec","systems","tab","taipei","talk","taobao","target","tatamotors","tatar","tattoo","tax","taxi","tci","tdk","team","tech","technology","telefonica","temasek","tennis","teva","thd","theater","theatre","tiaa","tickets","tienda","tiffany","tips","tires","tirol","tjmaxx","tjx","tkmaxx","tmall","today","tokyo","tools","top","toray","toshiba","total","tours","town","toyota","toys","trade","trading","training","travel","travelchannel","travelers","travelersinsurance","trust","trv","tube","tui","tunes","tushu","tvs","ubank","ubs","uconnect","unicom","university","uno","uol","ups","vacations","vana","vanguard","vegas","ventures","verisign","versicherung","vet","viajes","video","vig","viking","villas","vin","vip","virgin","visa","vision","vistaprint","viva","vivo","vlaanderen","vodka","volkswagen","volvo","vote","voting","voto","voyage","vuelos","wales","walmart","walter","wang","wanggou","warman","watch","watches","weather","weatherchannel","webcam","weber","website","wed","wedding","weibo","weir","whoswho","wien","wiki","williamhill","win","windows","wine","winners","wme","wolterskluwer","woodside","work","works","world","wow","wtc","wtf","xbox","xerox","xfinity","xihuan","xin","कॉम","セール","佛山","慈善","集团","在线","大众汽车","点看","คอม","八卦","موقع","公益","公司","香格里拉","网站","移动","我爱你","москва","католик","онлайн","сайт","联通","קום","时尚","微博","淡马锡","ファッション","орг","नेट","ストア","삼성","商标","商店","商城","дети","ポイント","新闻","工行","家電","كوم","中文网","中信","娱乐","谷歌","電訊盈科","购物","クラウド","通販","网店","संगठन","餐厅","网络","ком","诺基亚","食品","飞利浦","手表","手机","ارامكو","العليان","اتصالات","بازار","موبايلي","ابوظبي","كاثوليك","همراه","닷컴","政府","شبكة","بيتك","عرب","机构","组织机构","健康","招聘","рус","珠宝","大拿","みんな","グーグル","世界","書籍","网址","닷넷","コム","天主教","游戏","vermögensberater","vermögensberatung","企业","信息","嘉里大酒店","嘉里","广东","政务","xyz","yachts","yahoo","yamaxun","yandex","yodobashi","yoga","yokohama","you","youtube","yun","zappos","zara","zero","zip","zone","zuerich","cc.ua","inf.ua","ltd.ua","beep.pl","barsy.ca","*.compute.estate","*.alces.network","alwaysdata.net","cloudfront.net","*.compute.amazonaws.com","*.compute-1.amazonaws.com","*.compute.amazonaws.com.cn","us-east-1.amazonaws.com","cn-north-1.eb.amazonaws.com.cn","cn-northwest-1.eb.amazonaws.com.cn","elasticbeanstalk.com","ap-northeast-1.elasticbeanstalk.com","ap-northeast-2.elasticbeanstalk.com","ap-northeast-3.elasticbeanstalk.com","ap-south-1.elasticbeanstalk.com","ap-southeast-1.elasticbeanstalk.com","ap-southeast-2.elasticbeanstalk.com","ca-central-1.elasticbeanstalk.com","eu-central-1.elasticbeanstalk.com","eu-west-1.elasticbeanstalk.com","eu-west-2.elasticbeanstalk.com","eu-west-3.elasticbeanstalk.com","sa-east-1.elasticbeanstalk.com","us-east-1.elasticbeanstalk.com","us-east-2.elasticbeanstalk.com","us-gov-west-1.elasticbeanstalk.com","us-west-1.elasticbeanstalk.com","us-west-2.elasticbeanstalk.com","*.elb.amazonaws.com","*.elb.amazonaws.com.cn","s3.amazonaws.com","s3-ap-northeast-1.amazonaws.com","s3-ap-northeast-2.amazonaws.com","s3-ap-south-1.amazonaws.com","s3-ap-southeast-1.amazonaws.com","s3-ap-southeast-2.amazonaws.com","s3-ca-central-1.amazonaws.com","s3-eu-central-1.amazonaws.com","s3-eu-west-1.amazonaws.com","s3-eu-west-2.amazonaws.com","s3-eu-west-3.amazonaws.com","s3-external-1.amazonaws.com","s3-fips-us-gov-west-1.amazonaws.com","s3-sa-east-1.amazonaws.com","s3-us-gov-west-1.amazonaws.com","s3-us-east-2.amazonaws.com","s3-us-west-1.amazonaws.com","s3-us-west-2.amazonaws.com","s3.ap-northeast-2.amazonaws.com","s3.ap-south-1.amazonaws.com","s3.cn-north-1.amazonaws.com.cn","s3.ca-central-1.amazonaws.com","s3.eu-central-1.amazonaws.com","s3.eu-west-2.amazonaws.com","s3.eu-west-3.amazonaws.com","s3.us-east-2.amazonaws.com","s3.dualstack.ap-northeast-1.amazonaws.com","s3.dualstack.ap-northeast-2.amazonaws.com","s3.dualstack.ap-south-1.amazonaws.com","s3.dualstack.ap-southeast-1.amazonaws.com","s3.dualstack.ap-southeast-2.amazonaws.com","s3.dualstack.ca-central-1.amazonaws.com","s3.dualstack.eu-central-1.amazonaws.com","s3.dualstack.eu-west-1.amazonaws.com","s3.dualstack.eu-west-2.amazonaws.com","s3.dualstack.eu-west-3.amazonaws.com","s3.dualstack.sa-east-1.amazonaws.com","s3.dualstack.us-east-1.amazonaws.com","s3.dualstack.us-east-2.amazonaws.com","s3-website-us-east-1.amazonaws.com","s3-website-us-west-1.amazonaws.com","s3-website-us-west-2.amazonaws.com","s3-website-ap-northeast-1.amazonaws.com","s3-website-ap-southeast-1.amazonaws.com","s3-website-ap-southeast-2.amazonaws.com","s3-website-eu-west-1.amazonaws.com","s3-website-sa-east-1.amazonaws.com","s3-website.ap-northeast-2.amazonaws.com","s3-website.ap-south-1.amazonaws.com","s3-website.ca-central-1.amazonaws.com","s3-website.eu-central-1.amazonaws.com","s3-website.eu-west-2.amazonaws.com","s3-website.eu-west-3.amazonaws.com","s3-website.us-east-2.amazonaws.com","t3l3p0rt.net","tele.amune.org","apigee.io","on-aptible.com","user.party.eus","pimienta.org","poivron.org","potager.org","sweetpepper.org","myasustor.com","go-vip.co","go-vip.net","wpcomstaging.com","myfritz.net","*.awdev.ca","*.advisor.ws","b-data.io","backplaneapp.io","app.banzaicloud.io","betainabox.com","bnr.la","blackbaudcdn.net","boomla.net","boxfuse.io","square7.ch","bplaced.com","bplaced.de","square7.de","bplaced.net","square7.net","browsersafetymark.io","uk0.bigv.io","dh.bytemark.co.uk","vm.bytemark.co.uk","mycd.eu","carrd.co","crd.co","uwu.ai","ae.org","ar.com","br.com","cn.com","com.de","com.se","de.com","eu.com","gb.com","gb.net","hu.com","hu.net","jp.net","jpn.com","kr.com","mex.com","no.com","qc.com","ru.com","sa.com","se.net","uk.com","uk.net","us.com","uy.com","za.bz","za.com","africa.com","gr.com","in.net","us.org","co.com","c.la","certmgr.org","xenapponazure.com","discourse.group","virtueeldomein.nl","cleverapps.io","*.lcl.dev","*.stg.dev","c66.me","cloud66.ws","cloud66.zone","jdevcloud.com","wpdevcloud.com","cloudaccess.host","freesite.host","cloudaccess.net","cloudcontrolled.com","cloudcontrolapp.com","workers.dev","wnext.app","co.ca","*.otap.co","co.cz","c.cdn77.org","cdn77-ssl.net","r.cdn77.net","rsc.cdn77.org","ssl.origin.cdn77-secure.org","cloudns.asia","cloudns.biz","cloudns.club","cloudns.cc","cloudns.eu","cloudns.in","cloudns.info","cloudns.org","cloudns.pro","cloudns.pw","cloudns.us","cloudeity.net","cnpy.gdn","co.nl","co.no","webhosting.be","hosting-cluster.nl","dyn.cosidns.de","dynamisches-dns.de","dnsupdater.de","internet-dns.de","l-o-g-i-n.de","dynamic-dns.info","feste-ip.net","knx-server.net","static-access.net","realm.cz","*.cryptonomic.net","cupcake.is","cyon.link","cyon.site","daplie.me","localhost.daplie.me","dattolocal.com","dattorelay.com","dattoweb.com","mydatto.com","dattolocal.net","mydatto.net","biz.dk","co.dk","firm.dk","reg.dk","store.dk","*.dapps.earth","*.bzz.dapps.earth","debian.net","dedyn.io","dnshome.de","online.th","shop.th","drayddns.com","dreamhosters.com","mydrobo.com","drud.io","drud.us","duckdns.org","dy.fi","tunk.org","dyndns-at-home.com","dyndns-at-work.com","dyndns-blog.com","dyndns-free.com","dyndns-home.com","dyndns-ip.com","dyndns-mail.com","dyndns-office.com","dyndns-pics.com","dyndns-remote.com","dyndns-server.com","dyndns-web.com","dyndns-wiki.com","dyndns-work.com","dyndns.biz","dyndns.info","dyndns.org","dyndns.tv","at-band-camp.net","ath.cx","barrel-of-knowledge.info","barrell-of-knowledge.info","better-than.tv","blogdns.com","blogdns.net","blogdns.org","blogsite.org","boldlygoingnowhere.org","broke-it.net","buyshouses.net","cechire.com","dnsalias.com","dnsalias.net","dnsalias.org","dnsdojo.com","dnsdojo.net","dnsdojo.org","does-it.net","doesntexist.com","doesntexist.org","dontexist.com","dontexist.net","dontexist.org","doomdns.com","doomdns.org","dvrdns.org","dyn-o-saur.com","dynalias.com","dynalias.net","dynalias.org","dynathome.net","dyndns.ws","endofinternet.net","endofinternet.org","endoftheinternet.org","est-a-la-maison.com","est-a-la-masion.com","est-le-patron.com","est-mon-blogueur.com","for-better.biz","for-more.biz","for-our.info","for-some.biz","for-the.biz","forgot.her.name","forgot.his.name","from-ak.com","from-al.com","from-ar.com","from-az.net","from-ca.com","from-co.net","from-ct.com","from-dc.com","from-de.com","from-fl.com","from-ga.com","from-hi.com","from-ia.com","from-id.com","from-il.com","from-in.com","from-ks.com","from-ky.com","from-la.net","from-ma.com","from-md.com","from-me.org","from-mi.com","from-mn.com","from-mo.com","from-ms.com","from-mt.com","from-nc.com","from-nd.com","from-ne.com","from-nh.com","from-nj.com","from-nm.com","from-nv.com","from-ny.net","from-oh.com","from-ok.com","from-or.com","from-pa.com","from-pr.com","from-ri.com","from-sc.com","from-sd.com","from-tn.com","from-tx.com","from-ut.com","from-va.com","from-vt.com","from-wa.com","from-wi.com","from-wv.com","from-wy.com","ftpaccess.cc","fuettertdasnetz.de","game-host.org","game-server.cc","getmyip.com","gets-it.net","go.dyndns.org","gotdns.com","gotdns.org","groks-the.info","groks-this.info","ham-radio-op.net","here-for-more.info","hobby-site.com","hobby-site.org","home.dyndns.org","homedns.org","homeftp.net","homeftp.org","homeip.net","homelinux.com","homelinux.net","homelinux.org","homeunix.com","homeunix.net","homeunix.org","iamallama.com","in-the-band.net","is-a-anarchist.com","is-a-blogger.com","is-a-bookkeeper.com","is-a-bruinsfan.org","is-a-bulls-fan.com","is-a-candidate.org","is-a-caterer.com","is-a-celticsfan.org","is-a-chef.com","is-a-chef.net","is-a-chef.org","is-a-conservative.com","is-a-cpa.com","is-a-cubicle-slave.com","is-a-democrat.com","is-a-designer.com","is-a-doctor.com","is-a-financialadvisor.com","is-a-geek.com","is-a-geek.net","is-a-geek.org","is-a-green.com","is-a-guru.com","is-a-hard-worker.com","is-a-hunter.com","is-a-knight.org","is-a-landscaper.com","is-a-lawyer.com","is-a-liberal.com","is-a-libertarian.com","is-a-linux-user.org","is-a-llama.com","is-a-musician.com","is-a-nascarfan.com","is-a-nurse.com","is-a-painter.com","is-a-patsfan.org","is-a-personaltrainer.com","is-a-photographer.com","is-a-player.com","is-a-republican.com","is-a-rockstar.com","is-a-socialist.com","is-a-soxfan.org","is-a-student.com","is-a-teacher.com","is-a-techie.com","is-a-therapist.com","is-an-accountant.com","is-an-actor.com","is-an-actress.com","is-an-anarchist.com","is-an-artist.com","is-an-engineer.com","is-an-entertainer.com","is-by.us","is-certified.com","is-found.org","is-gone.com","is-into-anime.com","is-into-cars.com","is-into-cartoons.com","is-into-games.com","is-leet.com","is-lost.org","is-not-certified.com","is-saved.org","is-slick.com","is-uberleet.com","is-very-bad.org","is-very-evil.org","is-very-good.org","is-very-nice.org","is-very-sweet.org","is-with-theband.com","isa-geek.com","isa-geek.net","isa-geek.org","isa-hockeynut.com","issmarterthanyou.com","isteingeek.de","istmein.de","kicks-ass.net","kicks-ass.org","knowsitall.info","land-4-sale.us","lebtimnetz.de","leitungsen.de","likes-pie.com","likescandy.com","merseine.nu","mine.nu","misconfused.org","mypets.ws","myphotos.cc","neat-url.com","office-on-the.net","on-the-web.tv","podzone.net","podzone.org","readmyblog.org","saves-the-whales.com","scrapper-site.net","scrapping.cc","selfip.biz","selfip.com","selfip.info","selfip.net","selfip.org","sells-for-less.com","sells-for-u.com","sells-it.net","sellsyourhome.org","servebbs.com","servebbs.net","servebbs.org","serveftp.net","serveftp.org","servegame.org","shacknet.nu","simple-url.com","space-to-rent.com","stuff-4-sale.org","stuff-4-sale.us","teaches-yoga.com","thruhere.net","traeumtgerade.de","webhop.biz","webhop.info","webhop.net","webhop.org","worse-than.tv","writesthisblog.com","ddnss.de","dyn.ddnss.de","dyndns.ddnss.de","dyndns1.de","dyn-ip24.de","home-webserver.de","dyn.home-webserver.de","myhome-server.de","ddnss.org","definima.net","definima.io","bci.dnstrace.pro","ddnsfree.com","ddnsgeek.com","giize.com","gleeze.com","kozow.com","loseyourip.com","ooguy.com","theworkpc.com","casacam.net","dynu.net","accesscam.org","camdvr.org","freeddns.org","mywire.org","webredirect.org","myddns.rocks","blogsite.xyz","dynv6.net","e4.cz","mytuleap.com","onred.one","staging.onred.one","enonic.io","customer.enonic.io","eu.org","al.eu.org","asso.eu.org","at.eu.org","au.eu.org","be.eu.org","bg.eu.org","ca.eu.org","cd.eu.org","ch.eu.org","cn.eu.org","cy.eu.org","cz.eu.org","de.eu.org","dk.eu.org","edu.eu.org","ee.eu.org","es.eu.org","fi.eu.org","fr.eu.org","gr.eu.org","hr.eu.org","hu.eu.org","ie.eu.org","il.eu.org","in.eu.org","int.eu.org","is.eu.org","it.eu.org","jp.eu.org","kr.eu.org","lt.eu.org","lu.eu.org","lv.eu.org","mc.eu.org","me.eu.org","mk.eu.org","mt.eu.org","my.eu.org","net.eu.org","ng.eu.org","nl.eu.org","no.eu.org","nz.eu.org","paris.eu.org","pl.eu.org","pt.eu.org","q-a.eu.org","ro.eu.org","ru.eu.org","se.eu.org","si.eu.org","sk.eu.org","tr.eu.org","uk.eu.org","us.eu.org","eu-1.evennode.com","eu-2.evennode.com","eu-3.evennode.com","eu-4.evennode.com","us-1.evennode.com","us-2.evennode.com","us-3.evennode.com","us-4.evennode.com","twmail.cc","twmail.net","twmail.org","mymailer.com.tw","url.tw","apps.fbsbx.com","ru.net","adygeya.ru","bashkiria.ru","bir.ru","cbg.ru","com.ru","dagestan.ru","grozny.ru","kalmykia.ru","kustanai.ru","marine.ru","mordovia.ru","msk.ru","mytis.ru","nalchik.ru","nov.ru","pyatigorsk.ru","spb.ru","vladikavkaz.ru","vladimir.ru","abkhazia.su","adygeya.su","aktyubinsk.su","arkhangelsk.su","armenia.su","ashgabad.su","azerbaijan.su","balashov.su","bashkiria.su","bryansk.su","bukhara.su","chimkent.su","dagestan.su","east-kazakhstan.su","exnet.su","georgia.su","grozny.su","ivanovo.su","jambyl.su","kalmykia.su","kaluga.su","karacol.su","karaganda.su","karelia.su","khakassia.su","krasnodar.su","kurgan.su","kustanai.su","lenug.su","mangyshlak.su","mordovia.su","msk.su","murmansk.su","nalchik.su","navoi.su","north-kazakhstan.su","nov.su","obninsk.su","penza.su","pokrovsk.su","sochi.su","spb.su","tashkent.su","termez.su","togliatti.su","troitsk.su","tselinograd.su","tula.su","tuva.su","vladikavkaz.su","vladimir.su","vologda.su","channelsdvr.net","fastly-terrarium.com","fastlylb.net","map.fastlylb.net","freetls.fastly.net","map.fastly.net","a.prod.fastly.net","global.prod.fastly.net","a.ssl.fastly.net","b.ssl.fastly.net","global.ssl.fastly.net","fastpanel.direct","fastvps-server.com","fhapp.xyz","fedorainfracloud.org","fedorapeople.org","cloud.fedoraproject.org","app.os.fedoraproject.org","app.os.stg.fedoraproject.org","mydobiss.com","filegear.me","filegear-au.me","filegear-de.me","filegear-gb.me","filegear-ie.me","filegear-jp.me","filegear-sg.me","firebaseapp.com","flynnhub.com","flynnhosting.net","freebox-os.com","freeboxos.com","fbx-os.fr","fbxos.fr","freebox-os.fr","freeboxos.fr","freedesktop.org","*.futurecms.at","*.ex.futurecms.at","*.in.futurecms.at","futurehosting.at","futuremailing.at","*.ex.ortsinfo.at","*.kunden.ortsinfo.at","*.statics.cloud","service.gov.uk","gehirn.ne.jp","usercontent.jp","lab.ms","github.io","githubusercontent.com","gitlab.io","glitch.me","cloudapps.digital","london.cloudapps.digital","homeoffice.gov.uk","ro.im","shop.ro","goip.de","run.app","a.run.app","*.0emm.com","appspot.com","blogspot.ae","blogspot.al","blogspot.am","blogspot.ba","blogspot.be","blogspot.bg","blogspot.bj","blogspot.ca","blogspot.cf","blogspot.ch","blogspot.cl","blogspot.co.at","blogspot.co.id","blogspot.co.il","blogspot.co.ke","blogspot.co.nz","blogspot.co.uk","blogspot.co.za","blogspot.com","blogspot.com.ar","blogspot.com.au","blogspot.com.br","blogspot.com.by","blogspot.com.co","blogspot.com.cy","blogspot.com.ee","blogspot.com.eg","blogspot.com.es","blogspot.com.mt","blogspot.com.ng","blogspot.com.tr","blogspot.com.uy","blogspot.cv","blogspot.cz","blogspot.de","blogspot.dk","blogspot.fi","blogspot.fr","blogspot.gr","blogspot.hk","blogspot.hr","blogspot.hu","blogspot.ie","blogspot.in","blogspot.is","blogspot.it","blogspot.jp","blogspot.kr","blogspot.li","blogspot.lt","blogspot.lu","blogspot.md","blogspot.mk","blogspot.mr","blogspot.mx","blogspot.my","blogspot.nl","blogspot.no","blogspot.pe","blogspot.pt","blogspot.qa","blogspot.re","blogspot.ro","blogspot.rs","blogspot.ru","blogspot.se","blogspot.sg","blogspot.si","blogspot.sk","blogspot.sn","blogspot.td","blogspot.tw","blogspot.ug","blogspot.vn","cloudfunctions.net","cloud.goog","codespot.com","googleapis.com","googlecode.com","pagespeedmobilizer.com","publishproxy.com","withgoogle.com","withyoutube.com","fin.ci","free.hr","caa.li","ua.rs","conf.se","hashbang.sh","hasura.app","hasura-app.io","hepforge.org","herokuapp.com","herokussl.com","myravendb.com","ravendb.community","ravendb.me","development.run","ravendb.run","bpl.biz","orx.biz","ng.city","ng.ink","biz.gl","col.ng","gen.ng","ltd.ng","sch.so","häkkinen.fi","*.moonscale.io","moonscale.net","iki.fi","dyn-berlin.de","in-berlin.de","in-brb.de","in-butter.de","in-dsl.de","in-dsl.net","in-dsl.org","in-vpn.de","in-vpn.net","in-vpn.org","biz.at","info.at","info.cx","ac.leg.br","al.leg.br","am.leg.br","ap.leg.br","ba.leg.br","ce.leg.br","df.leg.br","es.leg.br","go.leg.br","ma.leg.br","mg.leg.br","ms.leg.br","mt.leg.br","pa.leg.br","pb.leg.br","pe.leg.br","pi.leg.br","pr.leg.br","rj.leg.br","rn.leg.br","ro.leg.br","rr.leg.br","rs.leg.br","sc.leg.br","se.leg.br","sp.leg.br","to.leg.br","pixolino.com","ipifony.net","mein-iserv.de","test-iserv.de","myjino.ru","*.hosting.myjino.ru","*.landing.myjino.ru","*.spectrum.myjino.ru","*.vps.myjino.ru","*.triton.zone","*.cns.joyent.com","js.org","kaas.gg","khplay.nl","keymachine.de","knightpoint.systems","co.krd","edu.krd","git-repos.de","lcube-server.de","svn-repos.de","leadpages.co","lpages.co","lpusercontent.com","co.business","co.education","co.events","co.financial","co.network","co.place","co.technology","app.lmpm.com","linkitools.space","linkyard.cloud","linkyard-cloud.ch","members.linode.com","nodebalancer.linode.com","we.bs","loginline.app","loginline.dev","loginline.io","loginline.services","loginline.site","krasnik.pl","leczna.pl","lubartow.pl","lublin.pl","poniatowa.pl","swidnik.pl","uklugs.org","glug.org.uk","lug.org.uk","lugs.org.uk","barsy.bg","barsy.co.uk","barsyonline.co.uk","barsycenter.com","barsyonline.com","barsy.club","barsy.de","barsy.eu","barsy.in","barsy.info","barsy.io","barsy.me","barsy.menu","barsy.mobi","barsy.net","barsy.online","barsy.org","barsy.pro","barsy.pub","barsy.shop","barsy.site","barsy.support","barsy.uk","*.magentosite.cloud","mayfirst.info","mayfirst.org","hb.cldmail.ru","miniserver.com","memset.net","cloud.metacentrum.cz","custom.metacentrum.cz","flt.cloud.muni.cz","usr.cloud.muni.cz","meteorapp.com","eu.meteorapp.com","co.pl","azurecontainer.io","azurewebsites.net","azure-mobile.net","cloudapp.net","mozilla-iot.org","bmoattachments.org","net.ru","org.ru","pp.ru","ui.nabu.casa","pony.club","of.fashion","on.fashion","of.football","in.london","of.london","for.men","and.mom","for.mom","for.one","for.sale","of.work","to.work","nctu.me","bitballoon.com","netlify.com","4u.com","ngrok.io","nh-serv.co.uk","nfshost.com","dnsking.ch","mypi.co","n4t.co","001www.com","ddnslive.com","myiphost.com","forumz.info","16-b.it","32-b.it","64-b.it","soundcast.me","tcp4.me","dnsup.net","hicam.net","now-dns.net","ownip.net","vpndns.net","dynserv.org","now-dns.org","x443.pw","now-dns.top","ntdll.top","freeddns.us","crafting.xyz","zapto.xyz","nsupdate.info","nerdpol.ovh","blogsyte.com","brasilia.me","cable-modem.org","ciscofreak.com","collegefan.org","couchpotatofries.org","damnserver.com","ddns.me","ditchyourip.com","dnsfor.me","dnsiskinky.com","dvrcam.info","dynns.com","eating-organic.net","fantasyleague.cc","geekgalaxy.com","golffan.us","health-carereform.com","homesecuritymac.com","homesecuritypc.com","hopto.me","ilovecollege.info","loginto.me","mlbfan.org","mmafan.biz","myactivedirectory.com","mydissent.net","myeffect.net","mymediapc.net","mypsx.net","mysecuritycamera.com","mysecuritycamera.net","mysecuritycamera.org","net-freaks.com","nflfan.org","nhlfan.net","no-ip.ca","no-ip.co.uk","no-ip.net","noip.us","onthewifi.com","pgafan.net","point2this.com","pointto.us","privatizehealthinsurance.net","quicksytes.com","read-books.org","securitytactics.com","serveexchange.com","servehumour.com","servep2p.com","servesarcasm.com","stufftoread.com","ufcfan.org","unusualperson.com","workisboring.com","3utilities.com","bounceme.net","ddns.net","ddnsking.com","gotdns.ch","hopto.org","myftp.biz","myftp.org","myvnc.com","no-ip.biz","no-ip.info","no-ip.org","noip.me","redirectme.net","servebeer.com","serveblog.net","servecounterstrike.com","serveftp.com","servegame.com","servehalflife.com","servehttp.com","serveirc.com","serveminecraft.net","servemp3.com","servepics.com","servequake.com","sytes.net","webhop.me","zapto.org","stage.nodeart.io","nodum.co","nodum.io","pcloud.host","nyc.mn","nom.ae","nom.af","nom.ai","nom.al","nym.by","nym.bz","nom.cl","nom.gd","nom.ge","nom.gl","nym.gr","nom.gt","nym.gy","nom.hn","nym.ie","nom.im","nom.ke","nym.kz","nym.la","nym.lc","nom.li","nym.li","nym.lt","nym.lu","nym.me","nom.mk","nym.mn","nym.mx","nom.nu","nym.nz","nym.pe","nym.pt","nom.pw","nom.qa","nym.ro","nom.rs","nom.si","nym.sk","nom.st","nym.su","nym.sx","nom.tj","nym.tw","nom.ug","nom.uy","nom.vc","nom.vg","cya.gg","cloudycluster.net","nid.io","opencraft.hosting","operaunite.com","outsystemscloud.com","ownprovider.com","own.pm","ox.rs","oy.lc","pgfog.com","pagefrontapp.com","art.pl","gliwice.pl","krakow.pl","poznan.pl","wroc.pl","zakopane.pl","pantheonsite.io","gotpantheon.com","mypep.link","on-web.fr","*.platform.sh","*.platformsh.site","co.bn","xen.prgmr.com","priv.at","prvcy.page","*.dweb.link","protonet.io","chirurgiens-dentistes-en-france.fr","byen.site","instantcloud.cn","ras.ru","qa2.com","dev-myqnapcloud.com","alpha-myqnapcloud.com","myqnapcloud.com","*.quipelements.com","vapor.cloud","vaporcloud.io","rackmaze.com","rackmaze.net","*.on-rancher.cloud","*.on-rio.io","readthedocs.io","rhcloud.com","app.render.com","onrender.com","repl.co","repl.run","resindevice.io","devices.resinstaging.io","hzc.io","wellbeingzone.eu","ptplus.fit","wellbeingzone.co.uk","git-pages.rit.edu","sandcats.io","logoip.de","logoip.com","schokokeks.net","scrysec.com","firewall-gateway.com","firewall-gateway.de","my-gateway.de","my-router.de","spdns.de","spdns.eu","firewall-gateway.net","my-firewall.org","myfirewall.org","spdns.org","*.s5y.io","*.sensiosite.cloud","biz.ua","co.ua","pp.ua","shiftedit.io","myshopblocks.com","mo-siemens.io","1kapp.com","appchizi.com","applinzi.com","sinaapp.com","vipsinaapp.com","siteleaf.net","bounty-full.com","alpha.bounty-full.com","beta.bounty-full.com","stackhero-network.com","static.land","dev.static.land","sites.static.land","apps.lair.io","*.stolos.io","spacekit.io","customer.speedpartner.de","api.stdlib.com","storj.farm","utwente.io","soc.srcf.net","user.srcf.net","temp-dns.com","applicationcloud.io","scapp.io","syncloud.it","diskstation.me","dscloud.biz","dscloud.me","dscloud.mobi","dsmynas.com","dsmynas.net","dsmynas.org","familyds.com","familyds.net","familyds.org","i234.me","myds.me","synology.me","vpnplus.to","taifun-dns.de","gda.pl","gdansk.pl","gdynia.pl","med.pl","sopot.pl","edugit.org","telebit.app","telebit.io","*.telebit.xyz","gwiddle.co.uk","thingdustdata.com","cust.dev.thingdust.io","cust.disrec.thingdust.io","cust.prod.thingdust.io","cust.testing.thingdust.io","arvo.network","azimuth.network","bloxcms.com","townnews-staging.com","12hp.at","2ix.at","4lima.at","lima-city.at","12hp.ch","2ix.ch","4lima.ch","lima-city.ch","trafficplex.cloud","de.cool","12hp.de","2ix.de","4lima.de","lima-city.de","1337.pictures","clan.rip","lima-city.rocks","webspace.rocks","lima.zone","*.transurl.be","*.transurl.eu","*.transurl.nl","tuxfamily.org","dd-dns.de","diskstation.eu","diskstation.org","dray-dns.de","draydns.de","dyn-vpn.de","dynvpn.de","mein-vigor.de","my-vigor.de","my-wan.de","syno-ds.de","synology-diskstation.de","synology-ds.de","uber.space","*.uberspace.de","hk.com","hk.org","ltd.hk","inc.hk","virtualuser.de","virtual-user.de","lib.de.us","2038.io","router.management","v-info.info","voorloper.cloud","wafflecell.com","wedeploy.io","wedeploy.me","wedeploy.sh","remotewd.com","wmflabs.org","half.host","xnbay.com","u2.xnbay.com","u2-local.xnbay.com","cistron.nl","demon.nl","xs4all.space","official.academy","yolasite.com","ybo.faith","yombo.me","homelink.one","ybo.party","ybo.review","ybo.science","ybo.trade","nohost.me","noho.st","za.net","za.org","now.sh","bss.design","basicserver.io","virtualserver.io","site.builder.nu","enterprisecloud.nu","zone.id"];
  
  /***/ }),
  
  /***/ 877:
  /***/ (function(module) {
  
  "use strict";
  var cachedSetTimeout=setTimeout;function createSleepPromise(a,b){var c=b.useCachedSetTimeout,d=c?cachedSetTimeout:setTimeout;return new Promise(function(b){d(b,a)})}function sleep(a){function b(a){return e.then(function(){return a})}var c=1<arguments.length&&void 0!==arguments[1]?arguments[1]:{},d=c.useCachedSetTimeout,e=createSleepPromise(a,{useCachedSetTimeout:d});return b.then=function(){return e.then.apply(e,arguments)},b.catch=Promise.resolve().catch,b}module.exports=sleep;
  
  
  /***/ }),
  
  /***/ 890:
  /***/ (function(module) {
  
  "use strict";
  
  
  var experimentalWarnings = new Set();
  
  function emitExperimentalWarning(feature) {
    if (experimentalWarnings.has(feature)) return;
    var msg = feature + ' is an experimental feature. This feature could ' +
         'change at any time';
    experimentalWarnings.add(feature);
    process.emitWarning(msg, 'ExperimentalWarning');
  }
  
  function noop() {}
  
  module.exports.emitExperimentalWarning = process.emitWarning
    ? emitExperimentalWarning
    : noop;
  
  
  /***/ }),
  
  /***/ 903:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(589)
  const fs = __webpack_require__(813)
  const pathExists = __webpack_require__(734).pathExists
  
  /**
   * Function that returns two types of paths, one relative to symlink, and one
   * relative to the current working directory. Checks if path is absolute or
   * relative. If the path is relative, this function checks if the path is
   * relative to symlink or relative to current working directory. This is an
   * initiative to find a smarter `srcpath` to supply when building symlinks.
   * This allows you to determine which path to use out of one of three possible
   * types of source paths. The first is an absolute path. This is detected by
   * `path.isAbsolute()`. When an absolute path is provided, it is checked to
   * see if it exists. If it does it's used, if not an error is returned
   * (callback)/ thrown (sync). The other two options for `srcpath` are a
   * relative url. By default Node's `fs.symlink` works by creating a symlink
   * using `dstpath` and expects the `srcpath` to be relative to the newly
   * created symlink. If you provide a `srcpath` that does not exist on the file
   * system it results in a broken symlink. To minimize this, the function
   * checks to see if the 'relative to symlink' source file exists, and if it
   * does it will use it. If it does not, it checks if there's a file that
   * exists that is relative to the current working directory, if does its used.
   * This preserves the expectations of the original fs.symlink spec and adds
   * the ability to pass in `relative to current working direcotry` paths.
   */
  
  function symlinkPaths (srcpath, dstpath, callback) {
    if (path.isAbsolute(srcpath)) {
      return fs.lstat(srcpath, (err) => {
        if (err) {
          err.message = err.message.replace('lstat', 'ensureSymlink')
          return callback(err)
        }
        return callback(null, {
          'toCwd': srcpath,
          'toDst': srcpath
        })
      })
    } else {
      const dstdir = path.dirname(dstpath)
      const relativeToDst = path.join(dstdir, srcpath)
      return pathExists(relativeToDst, (err, exists) => {
        if (err) return callback(err)
        if (exists) {
          return callback(null, {
            'toCwd': relativeToDst,
            'toDst': srcpath
          })
        } else {
          return fs.lstat(srcpath, (err) => {
            if (err) {
              err.message = err.message.replace('lstat', 'ensureSymlink')
              return callback(err)
            }
            return callback(null, {
              'toCwd': srcpath,
              'toDst': path.relative(dstdir, srcpath)
            })
          })
        }
      })
    }
  }
  
  function symlinkPathsSync (srcpath, dstpath) {
    let exists
    if (path.isAbsolute(srcpath)) {
      exists = fs.existsSync(srcpath)
      if (!exists) throw new Error('absolute srcpath does not exist')
      return {
        'toCwd': srcpath,
        'toDst': srcpath
      }
    } else {
      const dstdir = path.dirname(dstpath)
      const relativeToDst = path.join(dstdir, srcpath)
      exists = fs.existsSync(relativeToDst)
      if (exists) {
        return {
          'toCwd': relativeToDst,
          'toDst': srcpath
        }
      } else {
        exists = fs.existsSync(srcpath)
        if (!exists) throw new Error('relative srcpath does not exist')
        return {
          'toCwd': srcpath,
          'toDst': path.relative(dstdir, srcpath)
        }
      }
    }
  }
  
  module.exports = {
    symlinkPaths,
    symlinkPathsSync
  }
  
  
  /***/ }),
  
  /***/ 914:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = {
    copySync: __webpack_require__(702)
  }
  
  
  /***/ }),
  
  /***/ 922:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const {PassThrough: PassThroughStream} = __webpack_require__(688);
  
  module.exports = options => {
  	options = {...options};
  
  	const {array} = options;
  	let {encoding} = options;
  	const isBuffer = encoding === 'buffer';
  	let objectMode = false;
  
  	if (array) {
  		objectMode = !(encoding || isBuffer);
  	} else {
  		encoding = encoding || 'utf8';
  	}
  
  	if (isBuffer) {
  		encoding = null;
  	}
  
  	const stream = new PassThroughStream({objectMode});
  
  	if (encoding) {
  		stream.setEncoding(encoding);
  	}
  
  	let length = 0;
  	const chunks = [];
  
  	stream.on('data', chunk => {
  		chunks.push(chunk);
  
  		if (objectMode) {
  			length = chunks.length;
  		} else {
  			length += chunk.length;
  		}
  	});
  
  	stream.getBufferedValue = () => {
  		if (array) {
  			return chunks;
  		}
  
  		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
  	};
  
  	stream.getBufferedLength = () => length;
  
  	return stream;
  };
  
  
  /***/ }),
  
  /***/ 932:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var once = __webpack_require__(83)
  var eos = __webpack_require__(103)
  var fs = __webpack_require__(66) // we only need fs to get the ReadStream and WriteStream prototypes
  
  var noop = function () {}
  var ancient = /^v?\.0/.test(process.version)
  
  var isFn = function (fn) {
    return typeof fn === 'function'
  }
  
  var isFS = function (stream) {
    if (!ancient) return false // newer node version do not need to care about fs is a special way
    if (!fs) return false // browser
    return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
  }
  
  var isRequest = function (stream) {
    return stream.setHeader && isFn(stream.abort)
  }
  
  var destroyer = function (stream, reading, writing, callback) {
    callback = once(callback)
  
    var closed = false
    stream.on('close', function () {
      closed = true
    })
  
    eos(stream, {readable: reading, writable: writing}, function (err) {
      if (err) return callback(err)
      closed = true
      callback()
    })
  
    var destroyed = false
    return function (err) {
      if (closed) return
      if (destroyed) return
      destroyed = true
  
      if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
      if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
  
      if (isFn(stream.destroy)) return stream.destroy()
  
      callback(err || new Error('stream was destroyed'))
    }
  }
  
  var call = function (fn) {
    fn()
  }
  
  var pipe = function (from, to) {
    return from.pipe(to)
  }
  
  var pump = function () {
    var streams = Array.prototype.slice.call(arguments)
    var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
  
    if (Array.isArray(streams[0])) streams = streams[0]
    if (streams.length < 2) throw new Error('pump requires two streams per minimum')
  
    var error
    var destroys = streams.map(function (stream, i) {
      var reading = i < streams.length - 1
      var writing = i > 0
      return destroyer(stream, reading, writing, function (err) {
        if (!error) error = err
        if (err) destroys.forEach(call)
        if (reading) return
        destroys.forEach(call)
        callback(error)
      })
    })
  
    return streams.reduce(pipe)
  }
  
  module.exports = pump
  
  
  /***/ }),
  
  /***/ 935:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const crypto_1 = __webpack_require__(298);
  const fs_extra_1 = __importDefault(__webpack_require__(77));
  /**
   * Computes a hash for the given buf.
   *
   * @param {Buffer} file data
   * @return {String} hex digest
   */
  function hash(buf) {
      return crypto_1.createHash('sha1')
          .update(buf)
          .digest('hex');
  }
  /**
   * Transforms map to object
   * @param map with hashed files
   * @return {object}
   */
  exports.mapToObject = (map) => {
      const obj = {};
      for (const [key, value] of map) {
          obj[key] = value;
      }
      return obj;
  };
  /**
   * Computes hashes for the contents of each file given.
   *
   * @param {Array} of {String} full paths
   * @return {Map}
   */
  async function hashes(files) {
      const map = new Map();
      await Promise.all(files.map(async (name) => {
          const data = await fs_extra_1.default.readFile(name);
          const h = hash(data);
          const entry = map.get(h);
          if (entry) {
              entry.names.push(name);
          }
          else {
              map.set(h, { names: [name], data });
          }
      }));
      return map;
  }
  exports.default = hashes;
  
  
  /***/ }),
  
  /***/ 938:
  /***/ (function(module) {
  
  module.exports = require("constants");
  
  /***/ }),
  
  /***/ 942:
  /***/ (function(module) {
  
  module.exports = require("buffer");
  
  /***/ }),
  
  /***/ 945:
  /***/ (function(module, exports, __webpack_require__) {
  
  /* eslint-disable node/no-deprecated-api */
  var buffer = __webpack_require__(942)
  var Buffer = buffer.Buffer
  
  // alternative to using Object.keys for old browsers
  function copyProps (src, dst) {
    for (var key in src) {
      dst[key] = src[key]
    }
  }
  if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
    module.exports = buffer
  } else {
    // Copy properties from require('buffer')
    copyProps(buffer, exports)
    exports.Buffer = SafeBuffer
  }
  
  function SafeBuffer (arg, encodingOrOffset, length) {
    return Buffer(arg, encodingOrOffset, length)
  }
  
  // Copy static methods from Buffer
  copyProps(Buffer, SafeBuffer)
  
  SafeBuffer.from = function (arg, encodingOrOffset, length) {
    if (typeof arg === 'number') {
      throw new TypeError('Argument must not be a number')
    }
    return Buffer(arg, encodingOrOffset, length)
  }
  
  SafeBuffer.alloc = function (size, fill, encoding) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    var buf = Buffer(size)
    if (fill !== undefined) {
      if (typeof encoding === 'string') {
        buf.fill(fill, encoding)
      } else {
        buf.fill(fill)
      }
    } else {
      buf.fill(0)
    }
    return buf
  }
  
  SafeBuffer.allocUnsafe = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return Buffer(size)
  }
  
  SafeBuffer.allocUnsafeSlow = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return buffer.SlowBuffer(size)
  }
  
  
  /***/ }),
  
  /***/ 951:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http2_1 = __webpack_require__(675);
  const callguard_1 = __webpack_require__(382);
  const abort_1 = __webpack_require__(132);
  const core_1 = __webpack_require__(570);
  const fetch_common_1 = __webpack_require__(301);
  const headers_1 = __webpack_require__(191);
  const response_1 = __webpack_require__(973);
  const utils_1 = __webpack_require__(760);
  const utils_http2_1 = __webpack_require__(987);
  const { 
  // Responses
  HTTP2_HEADER_STATUS, HTTP2_HEADER_LOCATION, HTTP2_HEADER_SET_COOKIE, 
  // Error codes
  NGHTTP2_NO_ERROR, } = http2_1.constants;
  // This is from nghttp2.h, but undocumented in Node.js
  const NGHTTP2_ERR_START_STREAM_NOT_ALLOWED = -516;
  async function fetchImpl(session, input, init = {}, extra) {
      const { cleanup, contentDecoders, endStream, headersToSend, integrity, method, onTrailers, origin, redirect, redirected, request, signal, signalPromise, timeoutAt, timeoutInfo, url, } = await fetch_common_1.setupFetch(session, input, init, extra);
      const { raceConditionedGoaway } = extra;
      const streamPromise = session.get(url);
      async function doFetch() {
          const { session: h2session, cleanup: socketCleanup } = await streamPromise;
          const stream = h2session.request(headersToSend, { endStream });
          const response = new Promise((resolve, reject) => {
              const guard = callguard_1.syncGuard(reject, { catchAsync: true });
              const tryRetryOnGoaway = () => {
                  // This could be due to a race-condition in GOAWAY.
                  // As of current Node.js, the 'goaway' event is emitted on the
                  // session before this event (at least frameError, probably
                  // 'error' too) is emitted, so we will know if we got it.
                  if (!raceConditionedGoaway.has(origin) &&
                      utils_http2_1.hasGotGoaway(h2session)) {
                      // Don't retry again due to potential GOAWAY
                      raceConditionedGoaway.add(origin);
                      // Since we've got the 'goaway' event, the
                      // context has already released the session,
                      // so a retry will create a new session.
                      resolve(fetchImpl(session, request, { signal, onTrailers }, {
                          raceConditionedGoaway,
                          redirected,
                          timeoutAt,
                      }));
                      return true;
                  }
                  return false;
              };
              stream.on("aborted", guard((..._whatever) => {
                  reject(fetch_common_1.makeAbortedError());
              }));
              stream.on("error", guard((err) => {
                  if (err &&
                      err.code === "ERR_HTTP2_STREAM_ERROR" &&
                      err.message &&
                      err.message.includes("NGHTTP2_REFUSED_STREAM")) {
                      if (tryRetryOnGoaway())
                          return;
                  }
                  reject(err);
              }));
              stream.on("frameError", guard((_type, code, _streamId) => {
                  if (code === NGHTTP2_ERR_START_STREAM_NOT_ALLOWED &&
                      endStream) {
                      if (tryRetryOnGoaway())
                          return;
                  }
                  reject(new Error("Request failed"));
              }));
              stream.on("close", guard(() => {
                  socketCleanup();
                  // We'll get an 'error' event if there actually is an
                  // error, but not if we got NGHTTP2_NO_ERROR.
                  // In case of an error, the 'error' event will be awaited
                  // instead, to get (and propagate) the error object.
                  if (stream.rstCode === NGHTTP2_NO_ERROR)
                      reject(new core_1.AbortError("Stream prematurely closed"));
              }));
              stream.on("timeout", guard((..._whatever) => {
                  reject(fetch_common_1.makeTimeoutError());
              }));
              stream.on("trailers", guard((_headers, _flags) => {
                  if (!onTrailers)
                      return;
                  try {
                      const headers = new headers_1.GuardedHeaders("response");
                      Object.keys(_headers).forEach(key => {
                          if (Array.isArray(_headers[key]))
                              _headers[key]
                                  .forEach(value => headers.append(key, value));
                          else
                              headers.set(key, "" + _headers[key]);
                      });
                      onTrailers(headers);
                  }
                  catch (err) {
                      // TODO: Implement #8
                      // tslint:disable-next-line
                      console.warn("Trailer handling failed", err);
                  }
              }));
              // ClientHttp2Stream events
              stream.on("continue", guard((..._whatever) => {
                  reject(fetch_common_1.make100Error());
              }));
              stream.on("headers", guard((headers, _flags) => {
                  const code = headers[HTTP2_HEADER_STATUS];
                  reject(new Error(`Request failed with a ${code} status. ` +
                      "Any 1xx error is unexpected to fetch() and " +
                      "shouldn't happen."));
              }));
              stream.on("response", guard((headers) => {
                  const { signal: bodySignal = void 0, abort: bodyAbort = void 0, } = signal ? new abort_1.AbortController() : {};
                  if (signal) {
                      const abortHandler = () => {
                          bodyAbort();
                          stream.destroy();
                      };
                      if (signal.aborted) {
                          // No reason to continue, the request is aborted
                          abortHandler();
                          return;
                      }
                      signal.once("abort", abortHandler);
                      stream.once("close", () => {
                          signal.removeListener("abort", abortHandler);
                      });
                  }
                  const status = "" + headers[HTTP2_HEADER_STATUS];
                  const location = utils_1.parseLocation(headers[HTTP2_HEADER_LOCATION], url);
                  const isRedirected = utils_1.isRedirectStatus[status];
                  if (headers[HTTP2_HEADER_SET_COOKIE]) {
                      const setCookies = utils_1.arrayify(headers[HTTP2_HEADER_SET_COOKIE]);
                      session.cookieJar.setCookies(setCookies, url);
                  }
                  if (!input.allowForbiddenHeaders) {
                      delete headers["set-cookie"];
                      delete headers["set-cookie2"];
                  }
                  if (isRedirected && !location)
                      return reject(fetch_common_1.makeIllegalRedirectError());
                  if (!isRedirected || redirect === "manual")
                      return resolve(new response_1.StreamResponse(contentDecoders, url, stream, headers, redirect === "manual"
                          ? false
                          : extra.redirected.length > 0, {}, bodySignal, 2, input.allowForbiddenHeaders, integrity));
                  if (redirect === "error")
                      return reject(fetch_common_1.makeRedirectionError(location));
                  // redirect is 'follow'
                  // We don't support re-sending a non-GET/HEAD request (as
                  // we don't want to [can't, if its' streamed] re-send the
                  // body). The concept is fundementally broken anyway...
                  if (!endStream)
                      return reject(fetch_common_1.makeRedirectionMethodError(location, method));
                  if (!location)
                      return reject(fetch_common_1.makeIllegalRedirectError());
                  stream.destroy();
                  resolve(fetchImpl(session, request.clone(location), { signal, onTrailers }, {
                      raceConditionedGoaway,
                      redirected: redirected.concat(url),
                      timeoutAt,
                  }));
              }));
          });
          if (!endStream)
              await request.readable()
                  .then(readable => {
                  readable.pipe(stream);
              });
          return response;
      }
      return fetch_common_1.handleSignalAndTimeout(signalPromise, timeoutInfo, cleanup, doFetch, () => {
          streamPromise
              .then(({ cleanup }) => cleanup())
              .catch(_err => { });
      });
  }
  function fetch(session, input, init) {
      const timeoutAt = void 0;
      const raceConditionedGoaway = new Set();
      const extra = { timeoutAt, redirected: [], raceConditionedGoaway };
      return fetchImpl(session, input, init, extra);
  }
  exports.fetch = fetch;
  //# sourceMappingURL=fetch-http2.js.map
  
  /***/ }),
  
  /***/ 952:
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = function (PromiseArgument) {
    var Promise;
    function throat(size, fn) {
      var queue = new Queue();
      function run(fn, self, args) {
        if (size) {
          size--;
          var result = new Promise(function (resolve) {
            resolve(fn.apply(self, args));
          });
          result.then(release, release);
          return result;
        } else {
          return new Promise(function (resolve) {
            queue.push(new Delayed(resolve, fn, self, args));
          });
        }
      }
      function release() {
        size++;
        if (!queue.isEmpty()) {
          var next = queue.shift();
          next.resolve(run(next.fn, next.self, next.args));
        }
      }
      if (typeof size === 'function') {
        var temp = fn;
        fn = size;
        size = temp;
      }
      if (typeof size !== 'number') {
        throw new TypeError(
          'Expected throat size to be a number but got ' + typeof size
        );
      }
      if (fn !== undefined && typeof fn !== 'function') {
        throw new TypeError(
          'Expected throat fn to be a function but got ' + typeof fn
        );
      }
      if (typeof fn === 'function') {
        return function () {
          var args = [];
          for (var i = 0; i < arguments.length; i++) {
            args.push(arguments[i]);
          }
          return run(fn, this, args);
        };
      } else {
        return function (fn) {
          if (typeof fn !== 'function') {
            throw new TypeError(
              'Expected throat fn to be a function but got ' + typeof fn
            );
          }
          var args = [];
          for (var i = 1; i < arguments.length; i++) {
            args.push(arguments[i]);
          }
          return run(fn, this, args);
        };
      }
    }
    if (arguments.length === 1 && typeof PromiseArgument === 'function') {
      Promise = PromiseArgument;
      return throat;
    } else {
      Promise = module.exports.Promise;
      if (typeof Promise !== 'function') {
        throw new Error(
          'You must provide a Promise polyfill for this library to work in older environments'
        );
      }
      return throat(arguments[0], arguments[1]);
    }
  };
  
  /* istanbul ignore next */
  if (typeof Promise === 'function') {
    module.exports.Promise = Promise;
  }
  
  function Delayed(resolve, fn, self, args) {
    this.resolve = resolve;
    this.fn = fn;
    this.self = self || null;
    this.args = args;
  }
  
  function Queue() {
    this._s1 = [];
    this._s2 = [];
  }
  
  Queue.prototype.push = function (value) {
    this._s1.push(value);
  };
  
  Queue.prototype.shift = function () {
    var s2 = this._s2;
    if (s2.length === 0) {
      var s1 = this._s1;
      if (s1.length === 0) {
        return;
      }
      this._s1 = s2;
      s2 = this._s2 = s1.reverse();
    }
    return s2.pop();
  };
  
  Queue.prototype.isEmpty = function () {
    return !this._s1.length && !this._s2.length;
  };
  
  
  /***/ }),
  
  /***/ 955:
  /***/ (function(module) {
  
  "use strict";
   // undocumented cb() API, needed for core, not for public API
  
  function destroy(err, cb) {
    var _this = this;
  
    var readableDestroyed = this._readableState && this._readableState.destroyed;
    var writableDestroyed = this._writableState && this._writableState.destroyed;
  
    if (readableDestroyed || writableDestroyed) {
      if (cb) {
        cb(err);
      } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
        process.nextTick(emitErrorNT, this, err);
      }
  
      return this;
    } // we set destroyed to true before firing error callbacks in order
    // to make it re-entrance safe in case destroy() is called within callbacks
  
  
    if (this._readableState) {
      this._readableState.destroyed = true;
    } // if this is a duplex stream mark the writable part as destroyed as well
  
  
    if (this._writableState) {
      this._writableState.destroyed = true;
    }
  
    this._destroy(err || null, function (err) {
      if (!cb && err) {
        process.nextTick(emitErrorAndCloseNT, _this, err);
  
        if (_this._writableState) {
          _this._writableState.errorEmitted = true;
        }
      } else if (cb) {
        process.nextTick(emitCloseNT, _this);
        cb(err);
      } else {
        process.nextTick(emitCloseNT, _this);
      }
    });
  
    return this;
  }
  
  function emitErrorAndCloseNT(self, err) {
    emitErrorNT(self, err);
    emitCloseNT(self);
  }
  
  function emitCloseNT(self) {
    if (self._writableState && !self._writableState.emitClose) return;
    if (self._readableState && !self._readableState.emitClose) return;
    self.emit('close');
  }
  
  function undestroy() {
    if (this._readableState) {
      this._readableState.destroyed = false;
      this._readableState.reading = false;
      this._readableState.ended = false;
      this._readableState.endEmitted = false;
    }
  
    if (this._writableState) {
      this._writableState.destroyed = false;
      this._writableState.ended = false;
      this._writableState.ending = false;
      this._writableState.finalCalled = false;
      this._writableState.prefinished = false;
      this._writableState.finished = false;
      this._writableState.errorEmitted = false;
    }
  }
  
  function emitErrorNT(self, err) {
    self.emit('error', err);
  }
  
  module.exports = {
    destroy: destroy,
    undestroy: undestroy
  };
  
  /***/ }),
  
  /***/ 973:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http2_1 = __webpack_require__(675);
  const zlib_1 = __webpack_require__(267);
  const { HTTP2_HEADER_LOCATION, HTTP2_HEADER_STATUS, HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_CONTENT_ENCODING, HTTP2_HEADER_CONTENT_LENGTH, } = http2_1.constants;
  const utils_1 = __webpack_require__(760);
  const headers_1 = __webpack_require__(191);
  const body_1 = __webpack_require__(452);
  class Response extends body_1.Body {
      constructor(body = null, init = {}, extra) {
          super();
          const headers = headers_1.ensureHeaders(init.allowForbiddenHeaders
              ? new headers_1.GuardedHeaders("none", init.headers)
              : init.headers);
          const _extra = (extra || {});
          const type = _extra.type || "basic";
          const redirected = !!_extra.redirected || false;
          const url = _extra.url || "";
          const integrity = _extra.integrity || null;
          this.setSignal(_extra.signal);
          if (body) {
              const contentType = headers.get(HTTP2_HEADER_CONTENT_TYPE);
              const contentLength = headers.get(HTTP2_HEADER_CONTENT_LENGTH);
              const contentEncoding = headers.get(HTTP2_HEADER_CONTENT_ENCODING);
              const length = (contentLength == null || contentEncoding != null)
                  ? null
                  : parseInt(contentLength, 10);
              if (contentType)
                  this.setBody(body, contentType, integrity, length);
              else
                  this.setBody(body, null, integrity, length);
          }
          Object.defineProperties(this, {
              headers: {
                  enumerable: true,
                  value: headers,
              },
              httpVersion: {
                  enumerable: true,
                  value: _extra.httpVersion,
              },
              ok: {
                  enumerable: true,
                  get: () => this.status >= 200 && this.status < 300,
              },
              redirected: {
                  enumerable: true,
                  value: redirected,
              },
              status: {
                  enumerable: true,
                  value: init.status || 200,
              },
              statusText: {
                  enumerable: true,
                  value: init.statusText || "",
              },
              type: {
                  enumerable: true,
                  value: type,
              },
              url: {
                  enumerable: true,
                  value: url,
              },
              useFinalURL: {
                  enumerable: true,
                  value: undefined,
              },
          });
      }
      // Returns a new Response object associated with a network error.
      static error() {
          const headers = new headers_1.GuardedHeaders("immutable");
          const status = 521;
          const statusText = "Web Server Is Down";
          return new Response(null, { headers, status, statusText }, { type: "error" });
      }
      // Creates a new response with a different URL.
      static redirect(url, status) {
          status = status || 302;
          const headers = {
              [HTTP2_HEADER_LOCATION]: url,
          };
          return new Response(null, { headers, status });
      }
      // Creates a clone of a Response object.
      clone() {
          const { headers, status, statusText } = this;
          return new Response(this, { headers, status, statusText });
      }
  }
  exports.Response = Response;
  function makeHeadersFromH2Headers(headers, allowForbiddenHeaders) {
      const out = new headers_1.GuardedHeaders(allowForbiddenHeaders ? "none" : "response");
      for (const key of Object.keys(headers)) {
          if (key.startsWith(":"))
              // We ignore pseudo-headers
              continue;
          const value = headers[key];
          if (Array.isArray(value))
              value.forEach(val => out.append(key, val));
          else if (value != null)
              out.set(key, value);
      }
      return out;
  }
  function makeInitHttp1(inHeaders, allowForbiddenHeaders) {
      // Headers in HTTP/2 are compatible with HTTP/1 (colon illegal in HTTP/1)
      const headers = makeHeadersFromH2Headers(inHeaders, allowForbiddenHeaders);
      return { headers };
  }
  function makeInitHttp2(inHeaders, allowForbiddenHeaders) {
      const status = parseInt("" + inHeaders[HTTP2_HEADER_STATUS], 10);
      const statusText = ""; // Not supported in H2
      const headers = makeHeadersFromH2Headers(inHeaders, allowForbiddenHeaders);
      return { status, statusText, headers };
  }
  function makeExtra(httpVersion, url, redirected, signal, integrity) {
      const type = "basic"; // TODO: Implement CORS
      return { httpVersion, redirected, integrity, signal, type, url };
  }
  function handleEncoding(contentDecoders, stream, headers) {
      const contentEncoding = headers[HTTP2_HEADER_CONTENT_ENCODING];
      if (!contentEncoding)
          return stream;
      const decoders = {
          deflate: (stream) => stream.pipe(zlib_1.createInflate()),
          gzip: (stream) => stream.pipe(zlib_1.createGunzip()),
      };
      if (utils_1.hasBuiltinBrotli()) {
          decoders.br = (stream) => stream.pipe(zlib_1.createBrotliDecompress());
      }
      contentDecoders.forEach(decoder => {
          decoders[decoder.name] = decoder.decode;
      });
      const decoder = decoders[contentEncoding];
      if (!decoder)
          // We haven't asked for this encoding, and we can't handle it.
          // Pushing raw encoded stream through...
          return stream;
      return decoder(stream);
  }
  class StreamResponse extends Response {
      constructor(contentDecoders, url, stream, headers, redirected, init, signal, httpVersion, allowForbiddenHeaders, integrity) {
          super(handleEncoding(contentDecoders, stream, headers), {
              ...init,
              allowForbiddenHeaders,
              ...(httpVersion === 1
                  ? makeInitHttp1(headers, allowForbiddenHeaders)
                  : makeInitHttp2(headers, allowForbiddenHeaders)),
          }, makeExtra(httpVersion, url, redirected, signal, integrity));
      }
  }
  exports.StreamResponse = StreamResponse;
  //# sourceMappingURL=response.js.map
  
  /***/ }),
  
  /***/ 986:
  /***/ (function(module) {
  
  module.exports = require("url");
  
  /***/ }),
  
  /***/ 987:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function hasGotGoaway(session) {
      return !!session.__fetch_h2_goaway;
  }
  exports.hasGotGoaway = hasGotGoaway;
  function setGotGoaway(session) {
      session.__fetch_h2_goaway = true;
  }
  exports.setGotGoaway = setGotGoaway;
  function isDestroyed(session) {
      const monkeySession = session;
      return monkeySession.destroyed || monkeySession.__fetch_h2_destroyed;
  }
  exports.isDestroyed = isDestroyed;
  function setDestroyed(session) {
      session.__fetch_h2_destroyed = true;
  }
  exports.setDestroyed = setDestroyed;
  //# sourceMappingURL=utils-http2.js.map
  
  /***/ }),
  
  /***/ 988:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  
  /*<replacement>*/
  
  var Buffer = __webpack_require__(945).Buffer;
  /*</replacement>*/
  
  var isEncoding = Buffer.isEncoding || function (encoding) {
    encoding = '' + encoding;
    switch (encoding && encoding.toLowerCase()) {
      case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
        return true;
      default:
        return false;
    }
  };
  
  function _normalizeEncoding(enc) {
    if (!enc) return 'utf8';
    var retried;
    while (true) {
      switch (enc) {
        case 'utf8':
        case 'utf-8':
          return 'utf8';
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return 'utf16le';
        case 'latin1':
        case 'binary':
          return 'latin1';
        case 'base64':
        case 'ascii':
        case 'hex':
          return enc;
        default:
          if (retried) return; // undefined
          enc = ('' + enc).toLowerCase();
          retried = true;
      }
    }
  };
  
  // Do not cache `Buffer.isEncoding` when checking encoding names as some
  // modules monkey-patch it to support additional encodings
  function normalizeEncoding(enc) {
    var nenc = _normalizeEncoding(enc);
    if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
    return nenc || enc;
  }
  
  // StringDecoder provides an interface for efficiently splitting a series of
  // buffers into a series of JS strings without breaking apart multi-byte
  // characters.
  exports.StringDecoder = StringDecoder;
  function StringDecoder(encoding) {
    this.encoding = normalizeEncoding(encoding);
    var nb;
    switch (this.encoding) {
      case 'utf16le':
        this.text = utf16Text;
        this.end = utf16End;
        nb = 4;
        break;
      case 'utf8':
        this.fillLast = utf8FillLast;
        nb = 4;
        break;
      case 'base64':
        this.text = base64Text;
        this.end = base64End;
        nb = 3;
        break;
      default:
        this.write = simpleWrite;
        this.end = simpleEnd;
        return;
    }
    this.lastNeed = 0;
    this.lastTotal = 0;
    this.lastChar = Buffer.allocUnsafe(nb);
  }
  
  StringDecoder.prototype.write = function (buf) {
    if (buf.length === 0) return '';
    var r;
    var i;
    if (this.lastNeed) {
      r = this.fillLast(buf);
      if (r === undefined) return '';
      i = this.lastNeed;
      this.lastNeed = 0;
    } else {
      i = 0;
    }
    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
    return r || '';
  };
  
  StringDecoder.prototype.end = utf8End;
  
  // Returns only complete characters in a Buffer
  StringDecoder.prototype.text = utf8Text;
  
  // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
  StringDecoder.prototype.fillLast = function (buf) {
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
    this.lastNeed -= buf.length;
  };
  
  // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
  // continuation byte. If an invalid byte is detected, -2 is returned.
  function utf8CheckByte(byte) {
    if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
    return byte >> 6 === 0x02 ? -1 : -2;
  }
  
  // Checks at most 3 bytes at the end of a Buffer in order to detect an
  // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
  // needed to complete the UTF-8 character (if applicable) are returned.
  function utf8CheckIncomplete(self, buf, i) {
    var j = buf.length - 1;
    if (j < i) return 0;
    var nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 1;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 2;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) {
        if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
      }
      return nb;
    }
    return 0;
  }
  
  // Validates as many continuation bytes for a multi-byte UTF-8 character as
  // needed or are available. If we see a non-continuation byte where we expect
  // one, we "replace" the validated continuation bytes we've seen so far with
  // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
  // behavior. The continuation byte check is included three times in the case
  // where all of the continuation bytes for a character exist in the same buffer.
  // It is also done this way as a slight performance increase instead of using a
  // loop.
  function utf8CheckExtraBytes(self, buf, p) {
    if ((buf[0] & 0xC0) !== 0x80) {
      self.lastNeed = 0;
      return '\ufffd';
    }
    if (self.lastNeed > 1 && buf.length > 1) {
      if ((buf[1] & 0xC0) !== 0x80) {
        self.lastNeed = 1;
        return '\ufffd';
      }
      if (self.lastNeed > 2 && buf.length > 2) {
        if ((buf[2] & 0xC0) !== 0x80) {
          self.lastNeed = 2;
          return '\ufffd';
        }
      }
    }
  }
  
  // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
  function utf8FillLast(buf) {
    var p = this.lastTotal - this.lastNeed;
    var r = utf8CheckExtraBytes(this, buf, p);
    if (r !== undefined) return r;
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, p, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, p, 0, buf.length);
    this.lastNeed -= buf.length;
  }
  
  // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
  // partial character, the character's bytes are buffered until the required
  // number of bytes are available.
  function utf8Text(buf, i) {
    var total = utf8CheckIncomplete(this, buf, i);
    if (!this.lastNeed) return buf.toString('utf8', i);
    this.lastTotal = total;
    var end = buf.length - (total - this.lastNeed);
    buf.copy(this.lastChar, 0, end);
    return buf.toString('utf8', i, end);
  }
  
  // For UTF-8, a replacement character is added when ending on a partial
  // character.
  function utf8End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + '\ufffd';
    return r;
  }
  
  // UTF-16LE typically needs two bytes per character, but even if we have an even
  // number of bytes available, we need to check if we end on a leading/high
  // surrogate. In that case, we need to wait for the next two bytes in order to
  // decode the last character properly.
  function utf16Text(buf, i) {
    if ((buf.length - i) % 2 === 0) {
      var r = buf.toString('utf16le', i);
      if (r) {
        var c = r.charCodeAt(r.length - 1);
        if (c >= 0xD800 && c <= 0xDBFF) {
          this.lastNeed = 2;
          this.lastTotal = 4;
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
          return r.slice(0, -1);
        }
      }
      return r;
    }
    this.lastNeed = 1;
    this.lastTotal = 2;
    this.lastChar[0] = buf[buf.length - 1];
    return buf.toString('utf16le', i, buf.length - 1);
  }
  
  // For UTF-16LE we do not explicitly append special replacement characters if we
  // end on a partial character, we simply let v8 handle that.
  function utf16End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) {
      var end = this.lastTotal - this.lastNeed;
      return r + this.lastChar.toString('utf16le', 0, end);
    }
    return r;
  }
  
  function base64Text(buf, i) {
    var n = (buf.length - i) % 3;
    if (n === 0) return buf.toString('base64', i);
    this.lastNeed = 3 - n;
    this.lastTotal = 3;
    if (n === 1) {
      this.lastChar[0] = buf[buf.length - 1];
    } else {
      this.lastChar[0] = buf[buf.length - 2];
      this.lastChar[1] = buf[buf.length - 1];
    }
    return buf.toString('base64', i, buf.length - n);
  }
  
  function base64End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
    return r;
  }
  
  // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
  function simpleWrite(buf) {
    return buf.toString(this.encoding);
  }
  
  function simpleEnd(buf) {
    return buf && buf.length ? this.write(buf) : '';
  }
  
  /***/ })
  
  /******/ });
  //# sourceMappingURL=index.js.map