text: 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;
  /******/ 	}
  /******/
  /******/
  /******/ 	__webpack_require__.ab = __dirname + "/";
  /******/
  /******/ 	// the startup function
  /******/ 	function startup() {
  /******/ 		// Load entry module and return exports
  /******/ 		return __webpack_require__(198);
  /******/ 	};
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */,
  /* 1 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Returns the position of the last occurrence of an item in an array, or -1 if
   * the item is not included in the array. [`R.equals`](#equals) is used to
   * determine equality.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig a -> [a] -> Number
   * @param {*} target The item to find.
   * @param {Array} xs The array to search in.
   * @return {Number} the index of the target, or -1 if the target is not found.
   * @see R.indexOf
   * @example
   *
   *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6
   *      R.lastIndexOf(10, [1,2,3,4]); //=> -1
   */
  
  
  var lastIndexOf =
  /*#__PURE__*/
  _curry2(function lastIndexOf(target, xs) {
    if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {
      return xs.lastIndexOf(target);
    } else {
      var idx = xs.length - 1;
  
      while (idx >= 0) {
        if (equals(xs[idx], target)) {
          return idx;
        }
  
        idx -= 1;
      }
  
      return -1;
    }
  });
  
  module.exports = lastIndexOf;
  
  /***/ }),
  /* 2 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xfindIndex =
  /*#__PURE__*/
  __webpack_require__(305);
  /**
   * Returns the index of the first element of the list which matches the
   * predicate, or `-1` if no element matches.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category List
   * @sig (a -> Boolean) -> [a] -> Number
   * @param {Function} fn The predicate function used to determine if the element is the
   * desired one.
   * @param {Array} list The array to consider.
   * @return {Number} The index of the element found, or `-1`.
   * @see R.transduce
   * @example
   *
   *      const xs = [{a: 1}, {a: 2}, {a: 3}];
   *      R.findIndex(R.propEq('a', 2))(xs); //=> 1
   *      R.findIndex(R.propEq('a', 4))(xs); //=> -1
   */
  
  
  var findIndex =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xfindIndex, function findIndex(fn, list) {
    var idx = 0;
    var len = list.length;
  
    while (idx < len) {
      if (fn(list[idx])) {
        return idx;
      }
  
      idx += 1;
    }
  
    return -1;
  }));
  
  module.exports = findIndex;
  
  /***/ }),
  /* 3 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  /*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObject(o) {
    return Object.prototype.toString.call(o) === '[object Object]';
  }
  
  function isPlainObject(o) {
    var ctor,prot;
  
    if (isObject(o) === false) return false;
  
    // If has modified constructor
    ctor = o.constructor;
    if (ctor === undefined) return true;
  
    // If has modified prototype
    prot = ctor.prototype;
    if (isObject(prot) === false) return false;
  
    // If constructor does not have an Object-specific method
    if (prot.hasOwnProperty('isPrototypeOf') === false) {
      return false;
    }
  
    // Most likely a plain Object
    return true;
  }
  
  exports.isPlainObject = isPlainObject;
  
  
  /***/ }),
  /* 4 */,
  /* 5 */,
  /* 6 */,
  /* 7 */,
  /* 8 */,
  /* 9 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var once = __webpack_require__(969);
  
  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 cancelled = false;
  
  	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() {
  		process.nextTick(onclosenexttick);
  	};
  
  	var onclosenexttick = function() {
  		if (cancelled) return;
  		if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
  		if (writable && !(ws && (ws.ended && !ws.destroyed))) 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() {
  		cancelled = true;
  		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;
  
  
  /***/ }),
  /* 10 */,
  /* 11 */
  /***/ (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
    }
  }
  
  
  /***/ }),
  /* 12 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xdrop =
  /*#__PURE__*/
  __webpack_require__(738);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns all but the first `n` elements of the given list, string, or
   * transducer/transformer (or object with a `drop` method).
   *
   * Dispatches to the `drop` method of the second argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Number -> [a] -> [a]
   * @sig Number -> String -> String
   * @param {Number} n
   * @param {*} list
   * @return {*} A copy of list without the first `n` elements
   * @see R.take, R.transduce, R.dropLast, R.dropWhile
   * @example
   *
   *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
   *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']
   *      R.drop(3, ['foo', 'bar', 'baz']); //=> []
   *      R.drop(4, ['foo', 'bar', 'baz']); //=> []
   *      R.drop(3, 'ramda');               //=> 'da'
   */
  
  
  var drop =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['drop'], _xdrop, function drop(n, xs) {
    return slice(Math.max(0, n), Infinity, xs);
  }));
  
  module.exports = drop;
  
  /***/ }),
  /* 13 */,
  /* 14 */,
  /* 15 */,
  /* 16 */
  /***/ (function(module) {
  
  module.exports = require("tls");
  
  /***/ }),
  /* 17 */,
  /* 18 */
  /***/ (function() {
  
  eval("require")("encoding");
  
  
  /***/ }),
  /* 19 */,
  /* 20 */
  /***/ (function(module) {
  
  "use strict";
  /*!
   * is-extendable <https://github.com/jonschlinkert/is-extendable>
   *
   * Copyright (c) 2015, Jon Schlinkert.
   * Licensed under the MIT License.
   */
  
  
  
  module.exports = function isExtendable(val) {
    return typeof val !== 'undefined' && val !== null
      && (typeof val === 'object' || typeof val === 'function');
  };
  
  
  /***/ }),
  /* 21 */
  /***/ (function(module) {
  
  /**
   * A special placeholder value used to specify "gaps" within curried functions,
   * allowing partial application of any combination of arguments, regardless of
   * their positions.
   *
   * If `g` is a curried ternary function and `_` is `R.__`, the following are
   * equivalent:
   *
   *   - `g(1, 2, 3)`
   *   - `g(_, 2, 3)(1)`
   *   - `g(_, _, 3)(1)(2)`
   *   - `g(_, _, 3)(1, 2)`
   *   - `g(_, 2, _)(1, 3)`
   *   - `g(_, 2)(1)(3)`
   *   - `g(_, 2)(1, 3)`
   *   - `g(_, 2)(_, 3)(1)`
   *
   * @name __
   * @constant
   * @memberOf R
   * @since v0.6.0
   * @category Function
   * @example
   *
   *      const greet = R.replace('{name}', R.__, 'Hello, {name}!');
   *      greet('Alice'); //=> 'Hello, Alice!'
   */
  module.exports = {
    '@@functional/placeholder': true
  };
  
  /***/ }),
  /* 22 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var composeK =
  /*#__PURE__*/
  __webpack_require__(441);
  
  var reverse =
  /*#__PURE__*/
  __webpack_require__(528);
  /**
   * Returns the left-to-right Kleisli composition of the provided functions,
   * each of which must return a value of a type supported by [`chain`](#chain).
   *
   * `R.pipeK(f, g, h)` is equivalent to `R.pipe(f, R.chain(g), R.chain(h))`.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Function
   * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z)
   * @param {...Function}
   * @return {Function}
   * @see R.composeK
   * @deprecated since v0.26.0
   * @example
   *
   *      //  parseJson :: String -> Maybe *
   *      //  get :: String -> Object -> Maybe *
   *
   *      //  getStateCode :: Maybe String -> Maybe String
   *      const getStateCode = R.pipeK(
   *        parseJson,
   *        get('user'),
   *        get('address'),
   *        get('state'),
   *        R.compose(Maybe.of, R.toUpper)
   *      );
   *
   *      getStateCode('{"user":{"address":{"state":"ny"}}}');
   *      //=> Just('NY')
   *      getStateCode('[Invalid JSON]');
   *      //=> Nothing()
   * @symb R.pipeK(f, g, h)(a) = R.chain(h, R.chain(g, f(a)))
   */
  
  
  function pipeK() {
    if (arguments.length === 0) {
      throw new Error('pipeK requires at least one argument');
    }
  
    return composeK.apply(this, reverse(arguments));
  }
  
  module.exports = pipeK;
  
  /***/ }),
  /* 23 */,
  /* 24 */,
  /* 25 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var defaultTo =
  /*#__PURE__*/
  __webpack_require__(867);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * If the given, non-null object has a value at the given path, returns the
   * value at that path. Otherwise returns the provided default value.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig a -> [Idx] -> {a} -> a
   * @param {*} d The default value.
   * @param {Array} p The path to use.
   * @param {Object} obj The object to retrieve the nested property from.
   * @return {*} The data at `path` of the supplied object or the default value.
   * @example
   *
   *      R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
   *      R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
   */
  
  
  var pathOr =
  /*#__PURE__*/
  _curry3(function pathOr(d, p, obj) {
    return defaultTo(d, path(p, obj));
  });
  
  module.exports = pathOr;
  
  /***/ }),
  /* 26 */,
  /* 27 */,
  /* 28 */,
  /* 29 */,
  /* 30 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Replace a substring or regex match in a string with a replacement.
   *
   * The first two parameters correspond to the parameters of the
   * `String.prototype.replace()` function, so the second parameter can also be a
   * function.
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category String
   * @sig RegExp|String -> String -> String -> String
   * @param {RegExp|String} pattern A regular expression or a substring to match.
   * @param {String} replacement The string to replace the matches with.
   * @param {String} str The String to do the search and replacement in.
   * @return {String} The result.
   * @example
   *
   *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'
   *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'
   *
   *      // Use the "g" (global) flag to replace all occurrences:
   *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'
   */
  
  
  var replace =
  /*#__PURE__*/
  _curry3(function replace(regex, replacement, str) {
    return str.replace(regex, replacement);
  });
  
  module.exports = replace;
  
  /***/ }),
  /* 31 */,
  /* 32 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Inputs = void 0;
  var Inputs;
  (function (Inputs) {
      Inputs["Name"] = "name";
      Inputs["Title"] = "title";
      Inputs["Path"] = "path";
      Inputs["Token"] = "token";
  })(Inputs = exports.Inputs || (exports.Inputs = {}));
  
  
  /***/ }),
  /* 33 */,
  /* 34 */
  /***/ (function(module) {
  
  module.exports = require("https");
  
  /***/ }),
  /* 35 */,
  /* 36 */,
  /* 37 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var add =
  /*#__PURE__*/
  __webpack_require__(792);
  /**
   * Increments its argument.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Math
   * @sig Number -> Number
   * @param {Number} n
   * @return {Number} n + 1
   * @see R.dec
   * @example
   *
   *      R.inc(42); //=> 43
   */
  
  
  var inc =
  /*#__PURE__*/
  add(1);
  module.exports = inc;
  
  /***/ }),
  /* 38 */,
  /* 39 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xtakeWhile =
  /*#__PURE__*/
  __webpack_require__(808);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns a new list containing the first `n` elements of a given list,
   * passing each value to the supplied predicate function, and terminating when
   * the predicate function returns `false`. Excludes the element that caused the
   * predicate function to fail. The predicate function is passed one argument:
   * *(value)*.
   *
   * Dispatches to the `takeWhile` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> [a]
   * @sig (a -> Boolean) -> String -> String
   * @param {Function} fn The function called per iteration.
   * @param {Array} xs The collection to iterate over.
   * @return {Array} A new array.
   * @see R.dropWhile, R.transduce, R.addIndex
   * @example
   *
   *      const isNotFour = x => x !== 4;
   *
   *      R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]
   *
   *      R.takeWhile(x => x !== 'd' , 'Ramda'); //=> 'Ram'
   */
  
  
  var takeWhile =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, xs) {
    var idx = 0;
    var len = xs.length;
  
    while (idx < len && fn(xs[idx])) {
      idx += 1;
    }
  
    return slice(0, idx, xs);
  }));
  
  module.exports = takeWhile;
  
  /***/ }),
  /* 40 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function getUserAgent() {
    if (typeof navigator === "object" && "userAgent" in navigator) {
      return navigator.userAgent;
    }
  
    if (typeof process === "object" && "version" in process) {
      return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
    }
  
    return "<environment undetectable>";
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 41 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * Returns `true` if the specified object property at given path satisfies the
   * given predicate; `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Logic
   * @typedefn Idx = String | Int
   * @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean
   * @param {Function} pred
   * @param {Array} propPath
   * @param {*} obj
   * @return {Boolean}
   * @see R.propSatisfies, R.path
   * @example
   *
   *      R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true
   *      R.pathSatisfies(R.is(Object), [], {x: {y: 2}}); //=> true
   */
  
  
  var pathSatisfies =
  /*#__PURE__*/
  _curry3(function pathSatisfies(pred, propPath, obj) {
    return pred(path(propPath, obj));
  });
  
  module.exports = pathSatisfies;
  
  /***/ }),
  /* 42 */,
  /* 43 */
  /***/ (function(module) {
  
  var XWrap =
  /*#__PURE__*/
  function () {
    function XWrap(fn) {
      this.f = fn;
    }
  
    XWrap.prototype['@@transducer/init'] = function () {
      throw new Error('init not implemented on XWrap');
    };
  
    XWrap.prototype['@@transducer/result'] = function (acc) {
      return acc;
    };
  
    XWrap.prototype['@@transducer/step'] = function (acc, x) {
      return this.f(acc, x);
    };
  
    return XWrap;
  }();
  
  function _xwrap(fn) {
    return new XWrap(fn);
  }
  
  module.exports = _xwrap;
  
  /***/ }),
  /* 44 */,
  /* 45 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isInteger =
  /*#__PURE__*/
  __webpack_require__(802);
  /**
   * `mathMod` behaves like the modulo operator should mathematically, unlike the
   * `%` operator (and by extension, [`R.modulo`](#modulo)). So while
   * `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`. `mathMod` requires Integer
   * arguments, and returns NaN when the modulus is zero or negative.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} m The dividend.
   * @param {Number} p the modulus.
   * @return {Number} The result of `b mod a`.
   * @see R.modulo
   * @example
   *
   *      R.mathMod(-17, 5);  //=> 3
   *      R.mathMod(17, 5);   //=> 2
   *      R.mathMod(17, -5);  //=> NaN
   *      R.mathMod(17, 0);   //=> NaN
   *      R.mathMod(17.2, 5); //=> NaN
   *      R.mathMod(17, 5.3); //=> NaN
   *
   *      const clock = R.mathMod(R.__, 12);
   *      clock(15); //=> 3
   *      clock(24); //=> 0
   *
   *      const seventeenMod = R.mathMod(17);
   *      seventeenMod(3);  //=> 2
   *      seventeenMod(4);  //=> 1
   *      seventeenMod(10); //=> 7
   */
  
  
  var mathMod =
  /*#__PURE__*/
  _curry2(function mathMod(m, p) {
    if (!_isInteger(m)) {
      return NaN;
    }
  
    if (!_isInteger(p) || p < 1) {
      return NaN;
    }
  
    return (m % p + p) % p;
  });
  
  module.exports = mathMod;
  
  /***/ }),
  /* 46 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  /**
   * Returns a single item by iterating through the list, successively calling
   * the iterator function and passing it an accumulator value and the current
   * value from the array, and then passing the result to the next call.
   *
   * The iterator function receives two values: *(acc, value)*. It may use
   * [`R.reduced`](#reduced) to shortcut the iteration.
   *
   * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function
   * is *(value, acc)*.
   *
   * Note: `R.reduce` does not skip deleted or unassigned indices (sparse
   * arrays), unlike the native `Array.prototype.reduce` method. For more details
   * on this behavior, see:
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
   *
   * Dispatches to the `reduce` method of the third argument, if present. When
   * doing so, it is up to the user to handle the [`R.reduced`](#reduced)
   * shortcuting, as this is not implemented by `reduce`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig ((a, b) -> a) -> a -> [b] -> a
   * @param {Function} fn The iterator function. Receives two values, the accumulator and the
   *        current element from the array.
   * @param {*} acc The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.reduced, R.addIndex, R.reduceRight
   * @example
   *
   *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
   *      //          -               -10
   *      //         / \              / \
   *      //        -   4           -6   4
   *      //       / \              / \
   *      //      -   3   ==>     -3   3
   *      //     / \              / \
   *      //    -   2           -1   2
   *      //   / \              / \
   *      //  0   1            0   1
   *
   * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)
   */
  
  
  var reduce =
  /*#__PURE__*/
  _curry3(_reduce);
  
  module.exports = reduce;
  
  /***/ }),
  /* 47 */,
  /* 48 */
  /***/ (function(module, exports) {
  
  exports = module.exports = SemVer
  
  var debug
  /* istanbul ignore next */
  if (typeof process === 'object' &&
      process.env &&
      process.env.NODE_DEBUG &&
      /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
    debug = function () {
      var args = Array.prototype.slice.call(arguments, 0)
      args.unshift('SEMVER')
      console.log.apply(console, args)
    }
  } else {
    debug = function () {}
  }
  
  // Note: this is the semver.org version of the spec that it implements
  // Not necessarily the package version of this code.
  exports.SEMVER_SPEC_VERSION = '2.0.0'
  
  var MAX_LENGTH = 256
  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
    /* istanbul ignore next */ 9007199254740991
  
  // Max safe segment length for coercion.
  var MAX_SAFE_COMPONENT_LENGTH = 16
  
  // The actual regexps go on exports.re
  var re = exports.re = []
  var src = exports.src = []
  var R = 0
  
  // The following Regular Expressions can be used for tokenizing,
  // validating, and parsing SemVer version strings.
  
  // ## Numeric Identifier
  // A single `0`, or a non-zero digit followed by zero or more digits.
  
  var NUMERICIDENTIFIER = R++
  src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
  var NUMERICIDENTIFIERLOOSE = R++
  src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
  
  // ## Non-numeric Identifier
  // Zero or more digits, followed by a letter or hyphen, and then zero or
  // more letters, digits, or hyphens.
  
  var NONNUMERICIDENTIFIER = R++
  src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
  
  // ## Main Version
  // Three dot-separated numeric identifiers.
  
  var MAINVERSION = R++
  src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
                     '(' + src[NUMERICIDENTIFIER] + ')\\.' +
                     '(' + src[NUMERICIDENTIFIER] + ')'
  
  var MAINVERSIONLOOSE = R++
  src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
                          '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
                          '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
  
  // ## Pre-release Version Identifier
  // A numeric identifier, or a non-numeric identifier.
  
  var PRERELEASEIDENTIFIER = R++
  src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
                              '|' + src[NONNUMERICIDENTIFIER] + ')'
  
  var PRERELEASEIDENTIFIERLOOSE = R++
  src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
                                   '|' + src[NONNUMERICIDENTIFIER] + ')'
  
  // ## Pre-release Version
  // Hyphen, followed by one or more dot-separated pre-release version
  // identifiers.
  
  var PRERELEASE = R++
  src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
                    '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
  
  var PRERELEASELOOSE = R++
  src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
                         '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
  
  // ## Build Metadata Identifier
  // Any combination of digits, letters, or hyphens.
  
  var BUILDIDENTIFIER = R++
  src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
  
  // ## Build Metadata
  // Plus sign, followed by one or more period-separated build metadata
  // identifiers.
  
  var BUILD = R++
  src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
               '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
  
  // ## Full Version String
  // A main version, followed optionally by a pre-release version and
  // build metadata.
  
  // Note that the only major, minor, patch, and pre-release sections of
  // the version string are capturing groups.  The build metadata is not a
  // capturing group, because it should not ever be used in version
  // comparison.
  
  var FULL = R++
  var FULLPLAIN = 'v?' + src[MAINVERSION] +
                  src[PRERELEASE] + '?' +
                  src[BUILD] + '?'
  
  src[FULL] = '^' + FULLPLAIN + '$'
  
  // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
  // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
  // common in the npm registry.
  var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
                   src[PRERELEASELOOSE] + '?' +
                   src[BUILD] + '?'
  
  var LOOSE = R++
  src[LOOSE] = '^' + LOOSEPLAIN + '$'
  
  var GTLT = R++
  src[GTLT] = '((?:<|>)?=?)'
  
  // Something like "2.*" or "1.2.x".
  // Note that "x.x" is a valid xRange identifer, meaning "any version"
  // Only the first item is strictly required.
  var XRANGEIDENTIFIERLOOSE = R++
  src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
  var XRANGEIDENTIFIER = R++
  src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
  
  var XRANGEPLAIN = R++
  src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
                     '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
                     '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
                     '(?:' + src[PRERELEASE] + ')?' +
                     src[BUILD] + '?' +
                     ')?)?'
  
  var XRANGEPLAINLOOSE = R++
  src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
                          '(?:' + src[PRERELEASELOOSE] + ')?' +
                          src[BUILD] + '?' +
                          ')?)?'
  
  var XRANGE = R++
  src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
  var XRANGELOOSE = R++
  src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
  
  // Coercion.
  // Extract anything that could conceivably be a part of a valid semver
  var COERCE = R++
  src[COERCE] = '(?:^|[^\\d])' +
                '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
                '(?:$|[^\\d])'
  
  // Tilde ranges.
  // Meaning is "reasonably at or greater than"
  var LONETILDE = R++
  src[LONETILDE] = '(?:~>?)'
  
  var TILDETRIM = R++
  src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
  re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
  var tildeTrimReplace = '$1~'
  
  var TILDE = R++
  src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
  var TILDELOOSE = R++
  src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
  
  // Caret ranges.
  // Meaning is "at least and backwards compatible with"
  var LONECARET = R++
  src[LONECARET] = '(?:\\^)'
  
  var CARETTRIM = R++
  src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
  re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
  var caretTrimReplace = '$1^'
  
  var CARET = R++
  src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
  var CARETLOOSE = R++
  src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
  
  // A simple gt/lt/eq thing, or just "" to indicate "any version"
  var COMPARATORLOOSE = R++
  src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
  var COMPARATOR = R++
  src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
  
  // An expression to strip any whitespace between the gtlt and the thing
  // it modifies, so that `> 1.2.3` ==> `>1.2.3`
  var COMPARATORTRIM = R++
  src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
                        '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
  
  // this one has to use the /g flag
  re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
  var comparatorTrimReplace = '$1$2$3'
  
  // Something like `1.2.3 - 1.2.4`
  // Note that these all use the loose form, because they'll be
  // checked against either the strict or loose comparator form
  // later.
  var HYPHENRANGE = R++
  src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
                     '\\s+-\\s+' +
                     '(' + src[XRANGEPLAIN] + ')' +
                     '\\s*$'
  
  var HYPHENRANGELOOSE = R++
  src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
                          '\\s+-\\s+' +
                          '(' + src[XRANGEPLAINLOOSE] + ')' +
                          '\\s*$'
  
  // Star ranges basically just allow anything at all.
  var STAR = R++
  src[STAR] = '(<|>)?=?\\s*\\*'
  
  // Compile to actual regexp objects.
  // All are flag-free, unless they were created above with a flag.
  for (var i = 0; i < R; i++) {
    debug(i, src[i])
    if (!re[i]) {
      re[i] = new RegExp(src[i])
    }
  }
  
  exports.parse = parse
  function parse (version, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    if (version.length > MAX_LENGTH) {
      return null
    }
  
    var r = options.loose ? re[LOOSE] : re[FULL]
    if (!r.test(version)) {
      return null
    }
  
    try {
      return new SemVer(version, options)
    } catch (er) {
      return null
    }
  }
  
  exports.valid = valid
  function valid (version, options) {
    var v = parse(version, options)
    return v ? v.version : null
  }
  
  exports.clean = clean
  function clean (version, options) {
    var s = parse(version.trim().replace(/^[=v]+/, ''), options)
    return s ? s.version : null
  }
  
  exports.SemVer = SemVer
  
  function SemVer (version, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
    if (version instanceof SemVer) {
      if (version.loose === options.loose) {
        return version
      } else {
        version = version.version
      }
    } else if (typeof version !== 'string') {
      throw new TypeError('Invalid Version: ' + version)
    }
  
    if (version.length > MAX_LENGTH) {
      throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
    }
  
    if (!(this instanceof SemVer)) {
      return new SemVer(version, options)
    }
  
    debug('SemVer', version, options)
    this.options = options
    this.loose = !!options.loose
  
    var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
  
    if (!m) {
      throw new TypeError('Invalid Version: ' + version)
    }
  
    this.raw = version
  
    // these are actually numbers
    this.major = +m[1]
    this.minor = +m[2]
    this.patch = +m[3]
  
    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
      throw new TypeError('Invalid major version')
    }
  
    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
      throw new TypeError('Invalid minor version')
    }
  
    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
      throw new TypeError('Invalid patch version')
    }
  
    // numberify any prerelease numeric ids
    if (!m[4]) {
      this.prerelease = []
    } else {
      this.prerelease = m[4].split('.').map(function (id) {
        if (/^[0-9]+$/.test(id)) {
          var num = +id
          if (num >= 0 && num < MAX_SAFE_INTEGER) {
            return num
          }
        }
        return id
      })
    }
  
    this.build = m[5] ? m[5].split('.') : []
    this.format()
  }
  
  SemVer.prototype.format = function () {
    this.version = this.major + '.' + this.minor + '.' + this.patch
    if (this.prerelease.length) {
      this.version += '-' + this.prerelease.join('.')
    }
    return this.version
  }
  
  SemVer.prototype.toString = function () {
    return this.version
  }
  
  SemVer.prototype.compare = function (other) {
    debug('SemVer.compare', this.version, this.options, other)
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    return this.compareMain(other) || this.comparePre(other)
  }
  
  SemVer.prototype.compareMain = function (other) {
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    return compareIdentifiers(this.major, other.major) ||
           compareIdentifiers(this.minor, other.minor) ||
           compareIdentifiers(this.patch, other.patch)
  }
  
  SemVer.prototype.comparePre = function (other) {
    if (!(other instanceof SemVer)) {
      other = new SemVer(other, this.options)
    }
  
    // NOT having a prerelease is > having one
    if (this.prerelease.length && !other.prerelease.length) {
      return -1
    } else if (!this.prerelease.length && other.prerelease.length) {
      return 1
    } else if (!this.prerelease.length && !other.prerelease.length) {
      return 0
    }
  
    var i = 0
    do {
      var a = this.prerelease[i]
      var b = other.prerelease[i]
      debug('prerelease compare', i, a, b)
      if (a === undefined && b === undefined) {
        return 0
      } else if (b === undefined) {
        return 1
      } else if (a === undefined) {
        return -1
      } else if (a === b) {
        continue
      } else {
        return compareIdentifiers(a, b)
      }
    } while (++i)
  }
  
  // preminor will bump the version up to the next minor release, and immediately
  // down to pre-release. premajor and prepatch work the same way.
  SemVer.prototype.inc = function (release, identifier) {
    switch (release) {
      case 'premajor':
        this.prerelease.length = 0
        this.patch = 0
        this.minor = 0
        this.major++
        this.inc('pre', identifier)
        break
      case 'preminor':
        this.prerelease.length = 0
        this.patch = 0
        this.minor++
        this.inc('pre', identifier)
        break
      case 'prepatch':
        // If this is already a prerelease, it will bump to the next version
        // drop any prereleases that might already exist, since they are not
        // relevant at this point.
        this.prerelease.length = 0
        this.inc('patch', identifier)
        this.inc('pre', identifier)
        break
      // If the input is a non-prerelease version, this acts the same as
      // prepatch.
      case 'prerelease':
        if (this.prerelease.length === 0) {
          this.inc('patch', identifier)
        }
        this.inc('pre', identifier)
        break
  
      case 'major':
        // If this is a pre-major version, bump up to the same major version.
        // Otherwise increment major.
        // 1.0.0-5 bumps to 1.0.0
        // 1.1.0 bumps to 2.0.0
        if (this.minor !== 0 ||
            this.patch !== 0 ||
            this.prerelease.length === 0) {
          this.major++
        }
        this.minor = 0
        this.patch = 0
        this.prerelease = []
        break
      case 'minor':
        // If this is a pre-minor version, bump up to the same minor version.
        // Otherwise increment minor.
        // 1.2.0-5 bumps to 1.2.0
        // 1.2.1 bumps to 1.3.0
        if (this.patch !== 0 || this.prerelease.length === 0) {
          this.minor++
        }
        this.patch = 0
        this.prerelease = []
        break
      case 'patch':
        // If this is not a pre-release version, it will increment the patch.
        // If it is a pre-release it will bump up to the same patch version.
        // 1.2.0-5 patches to 1.2.0
        // 1.2.0 patches to 1.2.1
        if (this.prerelease.length === 0) {
          this.patch++
        }
        this.prerelease = []
        break
      // This probably shouldn't be used publicly.
      // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
      case 'pre':
        if (this.prerelease.length === 0) {
          this.prerelease = [0]
        } else {
          var i = this.prerelease.length
          while (--i >= 0) {
            if (typeof this.prerelease[i] === 'number') {
              this.prerelease[i]++
              i = -2
            }
          }
          if (i === -1) {
            // didn't increment anything
            this.prerelease.push(0)
          }
        }
        if (identifier) {
          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
          if (this.prerelease[0] === identifier) {
            if (isNaN(this.prerelease[1])) {
              this.prerelease = [identifier, 0]
            }
          } else {
            this.prerelease = [identifier, 0]
          }
        }
        break
  
      default:
        throw new Error('invalid increment argument: ' + release)
    }
    this.format()
    this.raw = this.version
    return this
  }
  
  exports.inc = inc
  function inc (version, release, loose, identifier) {
    if (typeof (loose) === 'string') {
      identifier = loose
      loose = undefined
    }
  
    try {
      return new SemVer(version, loose).inc(release, identifier).version
    } catch (er) {
      return null
    }
  }
  
  exports.diff = diff
  function diff (version1, version2) {
    if (eq(version1, version2)) {
      return null
    } else {
      var v1 = parse(version1)
      var v2 = parse(version2)
      var prefix = ''
      if (v1.prerelease.length || v2.prerelease.length) {
        prefix = 'pre'
        var defaultResult = 'prerelease'
      }
      for (var key in v1) {
        if (key === 'major' || key === 'minor' || key === 'patch') {
          if (v1[key] !== v2[key]) {
            return prefix + key
          }
        }
      }
      return defaultResult // may be undefined
    }
  }
  
  exports.compareIdentifiers = compareIdentifiers
  
  var numeric = /^[0-9]+$/
  function compareIdentifiers (a, b) {
    var anum = numeric.test(a)
    var bnum = numeric.test(b)
  
    if (anum && bnum) {
      a = +a
      b = +b
    }
  
    return a === b ? 0
      : (anum && !bnum) ? -1
      : (bnum && !anum) ? 1
      : a < b ? -1
      : 1
  }
  
  exports.rcompareIdentifiers = rcompareIdentifiers
  function rcompareIdentifiers (a, b) {
    return compareIdentifiers(b, a)
  }
  
  exports.major = major
  function major (a, loose) {
    return new SemVer(a, loose).major
  }
  
  exports.minor = minor
  function minor (a, loose) {
    return new SemVer(a, loose).minor
  }
  
  exports.patch = patch
  function patch (a, loose) {
    return new SemVer(a, loose).patch
  }
  
  exports.compare = compare
  function compare (a, b, loose) {
    return new SemVer(a, loose).compare(new SemVer(b, loose))
  }
  
  exports.compareLoose = compareLoose
  function compareLoose (a, b) {
    return compare(a, b, true)
  }
  
  exports.rcompare = rcompare
  function rcompare (a, b, loose) {
    return compare(b, a, loose)
  }
  
  exports.sort = sort
  function sort (list, loose) {
    return list.sort(function (a, b) {
      return exports.compare(a, b, loose)
    })
  }
  
  exports.rsort = rsort
  function rsort (list, loose) {
    return list.sort(function (a, b) {
      return exports.rcompare(a, b, loose)
    })
  }
  
  exports.gt = gt
  function gt (a, b, loose) {
    return compare(a, b, loose) > 0
  }
  
  exports.lt = lt
  function lt (a, b, loose) {
    return compare(a, b, loose) < 0
  }
  
  exports.eq = eq
  function eq (a, b, loose) {
    return compare(a, b, loose) === 0
  }
  
  exports.neq = neq
  function neq (a, b, loose) {
    return compare(a, b, loose) !== 0
  }
  
  exports.gte = gte
  function gte (a, b, loose) {
    return compare(a, b, loose) >= 0
  }
  
  exports.lte = lte
  function lte (a, b, loose) {
    return compare(a, b, loose) <= 0
  }
  
  exports.cmp = cmp
  function cmp (a, op, b, loose) {
    switch (op) {
      case '===':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a === b
  
      case '!==':
        if (typeof a === 'object')
          a = a.version
        if (typeof b === 'object')
          b = b.version
        return a !== b
  
      case '':
      case '=':
      case '==':
        return eq(a, b, loose)
  
      case '!=':
        return neq(a, b, loose)
  
      case '>':
        return gt(a, b, loose)
  
      case '>=':
        return gte(a, b, loose)
  
      case '<':
        return lt(a, b, loose)
  
      case '<=':
        return lte(a, b, loose)
  
      default:
        throw new TypeError('Invalid operator: ' + op)
    }
  }
  
  exports.Comparator = Comparator
  function Comparator (comp, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (comp instanceof Comparator) {
      if (comp.loose === !!options.loose) {
        return comp
      } else {
        comp = comp.value
      }
    }
  
    if (!(this instanceof Comparator)) {
      return new Comparator(comp, options)
    }
  
    debug('comparator', comp, options)
    this.options = options
    this.loose = !!options.loose
    this.parse(comp)
  
    if (this.semver === ANY) {
      this.value = ''
    } else {
      this.value = this.operator + this.semver.version
    }
  
    debug('comp', this)
  }
  
  var ANY = {}
  Comparator.prototype.parse = function (comp) {
    var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
    var m = comp.match(r)
  
    if (!m) {
      throw new TypeError('Invalid comparator: ' + comp)
    }
  
    this.operator = m[1]
    if (this.operator === '=') {
      this.operator = ''
    }
  
    // if it literally is just '>' or '' then allow anything.
    if (!m[2]) {
      this.semver = ANY
    } else {
      this.semver = new SemVer(m[2], this.options.loose)
    }
  }
  
  Comparator.prototype.toString = function () {
    return this.value
  }
  
  Comparator.prototype.test = function (version) {
    debug('Comparator.test', version, this.options.loose)
  
    if (this.semver === ANY) {
      return true
    }
  
    if (typeof version === 'string') {
      version = new SemVer(version, this.options)
    }
  
    return cmp(version, this.operator, this.semver, this.options)
  }
  
  Comparator.prototype.intersects = function (comp, options) {
    if (!(comp instanceof Comparator)) {
      throw new TypeError('a Comparator is required')
    }
  
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    var rangeTmp
  
    if (this.operator === '') {
      rangeTmp = new Range(comp.value, options)
      return satisfies(this.value, rangeTmp, options)
    } else if (comp.operator === '') {
      rangeTmp = new Range(this.value, options)
      return satisfies(comp.semver, rangeTmp, options)
    }
  
    var sameDirectionIncreasing =
      (this.operator === '>=' || this.operator === '>') &&
      (comp.operator === '>=' || comp.operator === '>')
    var sameDirectionDecreasing =
      (this.operator === '<=' || this.operator === '<') &&
      (comp.operator === '<=' || comp.operator === '<')
    var sameSemVer = this.semver.version === comp.semver.version
    var differentDirectionsInclusive =
      (this.operator === '>=' || this.operator === '<=') &&
      (comp.operator === '>=' || comp.operator === '<=')
    var oppositeDirectionsLessThan =
      cmp(this.semver, '<', comp.semver, options) &&
      ((this.operator === '>=' || this.operator === '>') &&
      (comp.operator === '<=' || comp.operator === '<'))
    var oppositeDirectionsGreaterThan =
      cmp(this.semver, '>', comp.semver, options) &&
      ((this.operator === '<=' || this.operator === '<') &&
      (comp.operator === '>=' || comp.operator === '>'))
  
    return sameDirectionIncreasing || sameDirectionDecreasing ||
      (sameSemVer && differentDirectionsInclusive) ||
      oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
  }
  
  exports.Range = Range
  function Range (range, options) {
    if (!options || typeof options !== 'object') {
      options = {
        loose: !!options,
        includePrerelease: false
      }
    }
  
    if (range instanceof Range) {
      if (range.loose === !!options.loose &&
          range.includePrerelease === !!options.includePrerelease) {
        return range
      } else {
        return new Range(range.raw, options)
      }
    }
  
    if (range instanceof Comparator) {
      return new Range(range.value, options)
    }
  
    if (!(this instanceof Range)) {
      return new Range(range, options)
    }
  
    this.options = options
    this.loose = !!options.loose
    this.includePrerelease = !!options.includePrerelease
  
    // First, split based on boolean or ||
    this.raw = range
    this.set = range.split(/\s*\|\|\s*/).map(function (range) {
      return this.parseRange(range.trim())
    }, this).filter(function (c) {
      // throw out any that are not relevant for whatever reason
      return c.length
    })
  
    if (!this.set.length) {
      throw new TypeError('Invalid SemVer Range: ' + range)
    }
  
    this.format()
  }
  
  Range.prototype.format = function () {
    this.range = this.set.map(function (comps) {
      return comps.join(' ').trim()
    }).join('||').trim()
    return this.range
  }
  
  Range.prototype.toString = function () {
    return this.range
  }
  
  Range.prototype.parseRange = function (range) {
    var loose = this.options.loose
    range = range.trim()
    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
    var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
    range = range.replace(hr, hyphenReplace)
    debug('hyphen replace', range)
    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
    range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
    debug('comparator trim', range, re[COMPARATORTRIM])
  
    // `~ 1.2.3` => `~1.2.3`
    range = range.replace(re[TILDETRIM], tildeTrimReplace)
  
    // `^ 1.2.3` => `^1.2.3`
    range = range.replace(re[CARETTRIM], caretTrimReplace)
  
    // normalize spaces
    range = range.split(/\s+/).join(' ')
  
    // At this point, the range is completely trimmed and
    // ready to be split into comparators.
  
    var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
    var set = range.split(' ').map(function (comp) {
      return parseComparator(comp, this.options)
    }, this).join(' ').split(/\s+/)
    if (this.options.loose) {
      // in loose mode, throw out any that are not valid comparators
      set = set.filter(function (comp) {
        return !!comp.match(compRe)
      })
    }
    set = set.map(function (comp) {
      return new Comparator(comp, this.options)
    }, this)
  
    return set
  }
  
  Range.prototype.intersects = function (range, options) {
    if (!(range instanceof Range)) {
      throw new TypeError('a Range is required')
    }
  
    return this.set.some(function (thisComparators) {
      return thisComparators.every(function (thisComparator) {
        return range.set.some(function (rangeComparators) {
          return rangeComparators.every(function (rangeComparator) {
            return thisComparator.intersects(rangeComparator, options)
          })
        })
      })
    })
  }
  
  // Mostly just for testing and legacy API reasons
  exports.toComparators = toComparators
  function toComparators (range, options) {
    return new Range(range, options).set.map(function (comp) {
      return comp.map(function (c) {
        return c.value
      }).join(' ').trim().split(' ')
    })
  }
  
  // comprised of xranges, tildes, stars, and gtlt's at this point.
  // already replaced the hyphen ranges
  // turn into a set of JUST comparators.
  function parseComparator (comp, options) {
    debug('comp', comp, options)
    comp = replaceCarets(comp, options)
    debug('caret', comp)
    comp = replaceTildes(comp, options)
    debug('tildes', comp)
    comp = replaceXRanges(comp, options)
    debug('xrange', comp)
    comp = replaceStars(comp, options)
    debug('stars', comp)
    return comp
  }
  
  function isX (id) {
    return !id || id.toLowerCase() === 'x' || id === '*'
  }
  
  // ~, ~> --> * (any, kinda silly)
  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
  function replaceTildes (comp, options) {
    return comp.trim().split(/\s+/).map(function (comp) {
      return replaceTilde(comp, options)
    }).join(' ')
  }
  
  function replaceTilde (comp, options) {
    var r = options.loose ? re[TILDELOOSE] : re[TILDE]
    return comp.replace(r, function (_, M, m, p, pr) {
      debug('tilde', comp, _, M, m, p, pr)
      var ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
      } else if (isX(p)) {
        // ~1.2 == >=1.2.0 <1.3.0
        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
      } else if (pr) {
        debug('replaceTilde pr', pr)
        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
              ' <' + M + '.' + (+m + 1) + '.0'
      } else {
        // ~1.2.3 == >=1.2.3 <1.3.0
        ret = '>=' + M + '.' + m + '.' + p +
              ' <' + M + '.' + (+m + 1) + '.0'
      }
  
      debug('tilde return', ret)
      return ret
    })
  }
  
  // ^ --> * (any, kinda silly)
  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
  // ^1.2.3 --> >=1.2.3 <2.0.0
  // ^1.2.0 --> >=1.2.0 <2.0.0
  function replaceCarets (comp, options) {
    return comp.trim().split(/\s+/).map(function (comp) {
      return replaceCaret(comp, options)
    }).join(' ')
  }
  
  function replaceCaret (comp, options) {
    debug('caret', comp, options)
    var r = options.loose ? re[CARETLOOSE] : re[CARET]
    return comp.replace(r, function (_, M, m, p, pr) {
      debug('caret', comp, _, M, m, p, pr)
      var ret
  
      if (isX(M)) {
        ret = ''
      } else if (isX(m)) {
        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
      } else if (isX(p)) {
        if (M === '0') {
          ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
        } else {
          ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
        }
      } else if (pr) {
        debug('replaceCaret pr', pr)
        if (M === '0') {
          if (m === '0') {
            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                  ' <' + M + '.' + m + '.' + (+p + 1)
          } else {
            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                  ' <' + M + '.' + (+m + 1) + '.0'
          }
        } else {
          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
                ' <' + (+M + 1) + '.0.0'
        }
      } else {
        debug('no pr')
        if (M === '0') {
          if (m === '0') {
            ret = '>=' + M + '.' + m + '.' + p +
                  ' <' + M + '.' + m + '.' + (+p + 1)
          } else {
            ret = '>=' + M + '.' + m + '.' + p +
                  ' <' + M + '.' + (+m + 1) + '.0'
          }
        } else {
          ret = '>=' + M + '.' + m + '.' + p +
                ' <' + (+M + 1) + '.0.0'
        }
      }
  
      debug('caret return', ret)
      return ret
    })
  }
  
  function replaceXRanges (comp, options) {
    debug('replaceXRanges', comp, options)
    return comp.split(/\s+/).map(function (comp) {
      return replaceXRange(comp, options)
    }).join(' ')
  }
  
  function replaceXRange (comp, options) {
    comp = comp.trim()
    var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
    return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
      debug('xRange', comp, ret, gtlt, M, m, p, pr)
      var xM = isX(M)
      var xm = xM || isX(m)
      var xp = xm || isX(p)
      var anyX = xp
  
      if (gtlt === '=' && anyX) {
        gtlt = ''
      }
  
      if (xM) {
        if (gtlt === '>' || gtlt === '<') {
          // nothing is allowed
          ret = '<0.0.0'
        } else {
          // nothing is forbidden
          ret = '*'
        }
      } else if (gtlt && anyX) {
        // we know patch is an x, because we have any x at all.
        // replace X with 0
        if (xm) {
          m = 0
        }
        p = 0
  
        if (gtlt === '>') {
          // >1 => >=2.0.0
          // >1.2 => >=1.3.0
          // >1.2.3 => >= 1.2.4
          gtlt = '>='
          if (xm) {
            M = +M + 1
            m = 0
            p = 0
          } else {
            m = +m + 1
            p = 0
          }
        } else if (gtlt === '<=') {
          // <=0.7.x is actually <0.8.0, since any 0.7.x should
          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
          gtlt = '<'
          if (xm) {
            M = +M + 1
          } else {
            m = +m + 1
          }
        }
  
        ret = gtlt + M + '.' + m + '.' + p
      } else if (xm) {
        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
      } else if (xp) {
        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
      }
  
      debug('xRange return', ret)
  
      return ret
    })
  }
  
  // Because * is AND-ed with everything else in the comparator,
  // and '' means "any version", just remove the *s entirely.
  function replaceStars (comp, options) {
    debug('replaceStars', comp, options)
    // Looseness is ignored here.  star is always as loose as it gets!
    return comp.trim().replace(re[STAR], '')
  }
  
  // This function is passed to string.replace(re[HYPHENRANGE])
  // M, m, patch, prerelease, build
  // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
  // 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
  // 1.2 - 3.4 => >=1.2.0 <3.5.0
  function hyphenReplace ($0,
    from, fM, fm, fp, fpr, fb,
    to, tM, tm, tp, tpr, tb) {
    if (isX(fM)) {
      from = ''
    } else if (isX(fm)) {
      from = '>=' + fM + '.0.0'
    } else if (isX(fp)) {
      from = '>=' + fM + '.' + fm + '.0'
    } else {
      from = '>=' + from
    }
  
    if (isX(tM)) {
      to = ''
    } else if (isX(tm)) {
      to = '<' + (+tM + 1) + '.0.0'
    } else if (isX(tp)) {
      to = '<' + tM + '.' + (+tm + 1) + '.0'
    } else if (tpr) {
      to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
    } else {
      to = '<=' + to
    }
  
    return (from + ' ' + to).trim()
  }
  
  // if ANY of the sets match ALL of its comparators, then pass
  Range.prototype.test = function (version) {
    if (!version) {
      return false
    }
  
    if (typeof version === 'string') {
      version = new SemVer(version, this.options)
    }
  
    for (var i = 0; i < this.set.length; i++) {
      if (testSet(this.set[i], version, this.options)) {
        return true
      }
    }
    return false
  }
  
  function testSet (set, version, options) {
    for (var i = 0; i < set.length; i++) {
      if (!set[i].test(version)) {
        return false
      }
    }
  
    if (version.prerelease.length && !options.includePrerelease) {
      // Find the set of versions that are allowed to have prereleases
      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
      // That should allow `1.2.3-pr.2` to pass.
      // However, `1.2.4-alpha.notready` should NOT be allowed,
      // even though it's within the range set by the comparators.
      for (i = 0; i < set.length; i++) {
        debug(set[i].semver)
        if (set[i].semver === ANY) {
          continue
        }
  
        if (set[i].semver.prerelease.length > 0) {
          var allowed = set[i].semver
          if (allowed.major === version.major &&
              allowed.minor === version.minor &&
              allowed.patch === version.patch) {
            return true
          }
        }
      }
  
      // Version has a -pre, but it's not one of the ones we like.
      return false
    }
  
    return true
  }
  
  exports.satisfies = satisfies
  function satisfies (version, range, options) {
    try {
      range = new Range(range, options)
    } catch (er) {
      return false
    }
    return range.test(version)
  }
  
  exports.maxSatisfying = maxSatisfying
  function maxSatisfying (versions, range, options) {
    var max = null
    var maxSV = null
    try {
      var rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach(function (v) {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!max || maxSV.compare(v) === -1) {
          // compare(max, v, true)
          max = v
          maxSV = new SemVer(max, options)
        }
      }
    })
    return max
  }
  
  exports.minSatisfying = minSatisfying
  function minSatisfying (versions, range, options) {
    var min = null
    var minSV = null
    try {
      var rangeObj = new Range(range, options)
    } catch (er) {
      return null
    }
    versions.forEach(function (v) {
      if (rangeObj.test(v)) {
        // satisfies(v, range, options)
        if (!min || minSV.compare(v) === 1) {
          // compare(min, v, true)
          min = v
          minSV = new SemVer(min, options)
        }
      }
    })
    return min
  }
  
  exports.minVersion = minVersion
  function minVersion (range, loose) {
    range = new Range(range, loose)
  
    var minver = new SemVer('0.0.0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = new SemVer('0.0.0-0')
    if (range.test(minver)) {
      return minver
    }
  
    minver = null
    for (var i = 0; i < range.set.length; ++i) {
      var comparators = range.set[i]
  
      comparators.forEach(function (comparator) {
        // Clone to avoid manipulating the comparator's semver object.
        var compver = new SemVer(comparator.semver.version)
        switch (comparator.operator) {
          case '>':
            if (compver.prerelease.length === 0) {
              compver.patch++
            } else {
              compver.prerelease.push(0)
            }
            compver.raw = compver.format()
            /* fallthrough */
          case '':
          case '>=':
            if (!minver || gt(minver, compver)) {
              minver = compver
            }
            break
          case '<':
          case '<=':
            /* Ignore maximum versions */
            break
          /* istanbul ignore next */
          default:
            throw new Error('Unexpected operation: ' + comparator.operator)
        }
      })
    }
  
    if (minver && range.test(minver)) {
      return minver
    }
  
    return null
  }
  
  exports.validRange = validRange
  function validRange (range, options) {
    try {
      // Return '*' instead of '' so that truthiness works.
      // This will throw if it's invalid anyway
      return new Range(range, options).range || '*'
    } catch (er) {
      return null
    }
  }
  
  // Determine if version is less than all the versions possible in the range
  exports.ltr = ltr
  function ltr (version, range, options) {
    return outside(version, range, '<', options)
  }
  
  // Determine if version is greater than all the versions possible in the range.
  exports.gtr = gtr
  function gtr (version, range, options) {
    return outside(version, range, '>', options)
  }
  
  exports.outside = outside
  function outside (version, range, hilo, options) {
    version = new SemVer(version, options)
    range = new Range(range, options)
  
    var gtfn, ltefn, ltfn, comp, ecomp
    switch (hilo) {
      case '>':
        gtfn = gt
        ltefn = lte
        ltfn = lt
        comp = '>'
        ecomp = '>='
        break
      case '<':
        gtfn = lt
        ltefn = gte
        ltfn = gt
        comp = '<'
        ecomp = '<='
        break
      default:
        throw new TypeError('Must provide a hilo val of "<" or ">"')
    }
  
    // If it satisifes the range it is not outside
    if (satisfies(version, range, options)) {
      return false
    }
  
    // From now on, variable terms are as if we're in "gtr" mode.
    // but note that everything is flipped for the "ltr" function.
  
    for (var i = 0; i < range.set.length; ++i) {
      var comparators = range.set[i]
  
      var high = null
      var low = null
  
      comparators.forEach(function (comparator) {
        if (comparator.semver === ANY) {
          comparator = new Comparator('>=0.0.0')
        }
        high = high || comparator
        low = low || comparator
        if (gtfn(comparator.semver, high.semver, options)) {
          high = comparator
        } else if (ltfn(comparator.semver, low.semver, options)) {
          low = comparator
        }
      })
  
      // If the edge version comparator has a operator then our version
      // isn't outside it
      if (high.operator === comp || high.operator === ecomp) {
        return false
      }
  
      // If the lowest version comparator has an operator and our version
      // is less than it then it isn't higher than the range
      if ((!low.operator || low.operator === comp) &&
          ltefn(version, low.semver)) {
        return false
      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
        return false
      }
    }
    return true
  }
  
  exports.prerelease = prerelease
  function prerelease (version, options) {
    var parsed = parse(version, options)
    return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
  }
  
  exports.intersects = intersects
  function intersects (r1, r2, options) {
    r1 = new Range(r1, options)
    r2 = new Range(r2, options)
    return r1.intersects(r2)
  }
  
  exports.coerce = coerce
  function coerce (version) {
    if (version instanceof SemVer) {
      return version
    }
  
    if (typeof version !== 'string') {
      return null
    }
  
    var match = version.match(re[COERCE])
  
    if (match == null) {
      return null
    }
  
    return parse(match[1] +
      '.' + (match[2] || '0') +
      '.' + (match[3] || '0'))
  }
  
  
  /***/ }),
  /* 49 */
  /***/ (function(module) {
  
  function _forceReduced(x) {
    return {
      '@@transducer/value': x,
      '@@transducer/reduced': true
    };
  }
  
  module.exports = _forceReduced;
  
  /***/ }),
  /* 50 */,
  /* 51 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _makeFlat =
  /*#__PURE__*/
  __webpack_require__(415);
  /**
   * Returns a new list by pulling every item out of it (and all its sub-arrays)
   * and putting them in a new array, depth-first.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [b]
   * @param {Array} list The array to consider.
   * @return {Array} The flattened list.
   * @see R.unnest
   * @example
   *
   *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
   *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
   */
  
  
  var flatten =
  /*#__PURE__*/
  _curry1(
  /*#__PURE__*/
  _makeFlat(true));
  
  module.exports = flatten;
  
  /***/ }),
  /* 52 */,
  /* 53 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a partial copy of an object omitting the keys specified.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig [String] -> {String: *} -> {String: *}
   * @param {Array} names an array of String property names to omit from the new object
   * @param {Object} obj The object to copy from
   * @return {Object} A new object with properties from `names` not on it.
   * @see R.pick
   * @example
   *
   *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
   */
  
  
  var omit =
  /*#__PURE__*/
  _curry2(function omit(names, obj) {
    var result = {};
    var index = {};
    var idx = 0;
    var len = names.length;
  
    while (idx < len) {
      index[names[idx]] = 1;
      idx += 1;
    }
  
    for (var prop in obj) {
      if (!index.hasOwnProperty(prop)) {
        result[prop] = obj[prop];
      }
    }
  
    return result;
  });
  
  module.exports = omit;
  
  /***/ }),
  /* 54 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Calls an input function `n` times, returning an array containing the results
   * of those function calls.
   *
   * `fn` is passed one argument: The current value of `n`, which begins at `0`
   * and is gradually incremented to `n - 1`.
   *
   * @func
   * @memberOf R
   * @since v0.2.3
   * @category List
   * @sig (Number -> a) -> Number -> [a]
   * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.
   * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.
   * @return {Array} An array containing the return values of all calls to `fn`.
   * @see R.repeat
   * @example
   *
   *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
   * @symb R.times(f, 0) = []
   * @symb R.times(f, 1) = [f(0)]
   * @symb R.times(f, 2) = [f(0), f(1)]
   */
  
  
  var times =
  /*#__PURE__*/
  _curry2(function times(fn, n) {
    var len = Number(n);
    var idx = 0;
    var list;
  
    if (len < 0 || isNaN(len)) {
      throw new RangeError('n must be a non-negative number');
    }
  
    list = new Array(len);
  
    while (idx < len) {
      list[idx] = fn(idx);
      idx += 1;
    }
  
    return list;
  });
  
  module.exports = times;
  
  /***/ }),
  /* 55 */,
  /* 56 */,
  /* 57 */
  /***/ (function(module) {
  
  function _quote(s) {
    var escaped = s.replace(/\\/g, '\\\\').replace(/[\b]/g, '\\b') // \b matches word boundary; [\b] matches backspace
    .replace(/\f/g, '\\f').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t').replace(/\v/g, '\\v').replace(/\0/g, '\\0');
    return '"' + escaped.replace(/"/g, '\\"') + '"';
  }
  
  module.exports = _quote;
  
  /***/ }),
  /* 58 */,
  /* 59 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xdropRepeatsWith =
  /*#__PURE__*/
  __webpack_require__(424);
  
  var dropRepeatsWith =
  /*#__PURE__*/
  __webpack_require__(919);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Returns a new list without any consecutively repeating elements.
   * [`R.equals`](#equals) is used to determine equality.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category List
   * @sig [a] -> [a]
   * @param {Array} list The array to consider.
   * @return {Array} `list` without repeating elements.
   * @see R.transduce
   * @example
   *
   *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
   */
  
  
  var dropRepeats =
  /*#__PURE__*/
  _curry1(
  /*#__PURE__*/
  _dispatchable([],
  /*#__PURE__*/
  _xdropRepeatsWith(equals),
  /*#__PURE__*/
  dropRepeatsWith(equals)));
  
  module.exports = dropRepeats;
  
  /***/ }),
  /* 60 */
  /***/ (function(module) {
  
  module.exports = {
    init: function () {
      return this.xf['@@transducer/init']();
    },
    result: function (result) {
      return this.xf['@@transducer/result'](result);
    }
  };
  
  /***/ }),
  /* 61 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = {};
  module.exports.F =
  /*#__PURE__*/
  __webpack_require__(913);
  module.exports.T =
  /*#__PURE__*/
  __webpack_require__(96);
  module.exports.__ =
  /*#__PURE__*/
  __webpack_require__(21);
  module.exports.add =
  /*#__PURE__*/
  __webpack_require__(792);
  module.exports.addIndex =
  /*#__PURE__*/
  __webpack_require__(731);
  module.exports.adjust =
  /*#__PURE__*/
  __webpack_require__(908);
  module.exports.all =
  /*#__PURE__*/
  __webpack_require__(320);
  module.exports.allPass =
  /*#__PURE__*/
  __webpack_require__(133);
  module.exports.always =
  /*#__PURE__*/
  __webpack_require__(657);
  module.exports.and =
  /*#__PURE__*/
  __webpack_require__(676);
  module.exports.any =
  /*#__PURE__*/
  __webpack_require__(137);
  module.exports.anyPass =
  /*#__PURE__*/
  __webpack_require__(81);
  module.exports.ap =
  /*#__PURE__*/
  __webpack_require__(641);
  module.exports.aperture =
  /*#__PURE__*/
  __webpack_require__(898);
  module.exports.append =
  /*#__PURE__*/
  __webpack_require__(612);
  module.exports.apply =
  /*#__PURE__*/
  __webpack_require__(422);
  module.exports.applySpec =
  /*#__PURE__*/
  __webpack_require__(185);
  module.exports.applyTo =
  /*#__PURE__*/
  __webpack_require__(91);
  module.exports.ascend =
  /*#__PURE__*/
  __webpack_require__(843);
  module.exports.assoc =
  /*#__PURE__*/
  __webpack_require__(414);
  module.exports.assocPath =
  /*#__PURE__*/
  __webpack_require__(194);
  module.exports.binary =
  /*#__PURE__*/
  __webpack_require__(790);
  module.exports.bind =
  /*#__PURE__*/
  __webpack_require__(269);
  module.exports.both =
  /*#__PURE__*/
  __webpack_require__(521);
  module.exports.call =
  /*#__PURE__*/
  __webpack_require__(132);
  module.exports.chain =
  /*#__PURE__*/
  __webpack_require__(481);
  module.exports.clamp =
  /*#__PURE__*/
  __webpack_require__(547);
  module.exports.clone =
  /*#__PURE__*/
  __webpack_require__(176);
  module.exports.comparator =
  /*#__PURE__*/
  __webpack_require__(105);
  module.exports.complement =
  /*#__PURE__*/
  __webpack_require__(541);
  module.exports.compose =
  /*#__PURE__*/
  __webpack_require__(944);
  module.exports.composeK =
  /*#__PURE__*/
  __webpack_require__(441);
  module.exports.composeP =
  /*#__PURE__*/
  __webpack_require__(592);
  module.exports.composeWith =
  /*#__PURE__*/
  __webpack_require__(138);
  module.exports.concat =
  /*#__PURE__*/
  __webpack_require__(818);
  module.exports.cond =
  /*#__PURE__*/
  __webpack_require__(604);
  module.exports.construct =
  /*#__PURE__*/
  __webpack_require__(979);
  module.exports.constructN =
  /*#__PURE__*/
  __webpack_require__(768);
  module.exports.contains =
  /*#__PURE__*/
  __webpack_require__(878);
  module.exports.converge =
  /*#__PURE__*/
  __webpack_require__(886);
  module.exports.countBy =
  /*#__PURE__*/
  __webpack_require__(333);
  module.exports.curry =
  /*#__PURE__*/
  __webpack_require__(447);
  module.exports.curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  module.exports.dec =
  /*#__PURE__*/
  __webpack_require__(613);
  module.exports.defaultTo =
  /*#__PURE__*/
  __webpack_require__(867);
  module.exports.descend =
  /*#__PURE__*/
  __webpack_require__(618);
  module.exports.difference =
  /*#__PURE__*/
  __webpack_require__(275);
  module.exports.differenceWith =
  /*#__PURE__*/
  __webpack_require__(716);
  module.exports.dissoc =
  /*#__PURE__*/
  __webpack_require__(799);
  module.exports.dissocPath =
  /*#__PURE__*/
  __webpack_require__(526);
  module.exports.divide =
  /*#__PURE__*/
  __webpack_require__(921);
  module.exports.drop =
  /*#__PURE__*/
  __webpack_require__(12);
  module.exports.dropLast =
  /*#__PURE__*/
  __webpack_require__(365);
  module.exports.dropLastWhile =
  /*#__PURE__*/
  __webpack_require__(533);
  module.exports.dropRepeats =
  /*#__PURE__*/
  __webpack_require__(59);
  module.exports.dropRepeatsWith =
  /*#__PURE__*/
  __webpack_require__(919);
  module.exports.dropWhile =
  /*#__PURE__*/
  __webpack_require__(531);
  module.exports.either =
  /*#__PURE__*/
  __webpack_require__(446);
  module.exports.empty =
  /*#__PURE__*/
  __webpack_require__(235);
  module.exports.endsWith =
  /*#__PURE__*/
  __webpack_require__(900);
  module.exports.eqBy =
  /*#__PURE__*/
  __webpack_require__(912);
  module.exports.eqProps =
  /*#__PURE__*/
  __webpack_require__(558);
  module.exports.equals =
  /*#__PURE__*/
  __webpack_require__(701);
  module.exports.evolve =
  /*#__PURE__*/
  __webpack_require__(887);
  module.exports.filter =
  /*#__PURE__*/
  __webpack_require__(80);
  module.exports.find =
  /*#__PURE__*/
  __webpack_require__(862);
  module.exports.findIndex =
  /*#__PURE__*/
  __webpack_require__(2);
  module.exports.findLast =
  /*#__PURE__*/
  __webpack_require__(656);
  module.exports.findLastIndex =
  /*#__PURE__*/
  __webpack_require__(593);
  module.exports.flatten =
  /*#__PURE__*/
  __webpack_require__(51);
  module.exports.flip =
  /*#__PURE__*/
  __webpack_require__(328);
  module.exports.forEach =
  /*#__PURE__*/
  __webpack_require__(962);
  module.exports.forEachObjIndexed =
  /*#__PURE__*/
  __webpack_require__(294);
  module.exports.fromPairs =
  /*#__PURE__*/
  __webpack_require__(795);
  module.exports.groupBy =
  /*#__PURE__*/
  __webpack_require__(797);
  module.exports.groupWith =
  /*#__PURE__*/
  __webpack_require__(497);
  module.exports.gt =
  /*#__PURE__*/
  __webpack_require__(573);
  module.exports.gte =
  /*#__PURE__*/
  __webpack_require__(144);
  module.exports.has =
  /*#__PURE__*/
  __webpack_require__(511);
  module.exports.hasIn =
  /*#__PURE__*/
  __webpack_require__(146);
  module.exports.hasPath =
  /*#__PURE__*/
  __webpack_require__(303);
  module.exports.head =
  /*#__PURE__*/
  __webpack_require__(678);
  module.exports.identical =
  /*#__PURE__*/
  __webpack_require__(211);
  module.exports.identity =
  /*#__PURE__*/
  __webpack_require__(534);
  module.exports.ifElse =
  /*#__PURE__*/
  __webpack_require__(462);
  module.exports.inc =
  /*#__PURE__*/
  __webpack_require__(37);
  module.exports.includes =
  /*#__PURE__*/
  __webpack_require__(287);
  module.exports.indexBy =
  /*#__PURE__*/
  __webpack_require__(500);
  module.exports.indexOf =
  /*#__PURE__*/
  __webpack_require__(572);
  module.exports.init =
  /*#__PURE__*/
  __webpack_require__(85);
  module.exports.innerJoin =
  /*#__PURE__*/
  __webpack_require__(367);
  module.exports.insert =
  /*#__PURE__*/
  __webpack_require__(718);
  module.exports.insertAll =
  /*#__PURE__*/
  __webpack_require__(709);
  module.exports.intersection =
  /*#__PURE__*/
  __webpack_require__(859);
  module.exports.intersperse =
  /*#__PURE__*/
  __webpack_require__(126);
  module.exports.into =
  /*#__PURE__*/
  __webpack_require__(889);
  module.exports.invert =
  /*#__PURE__*/
  __webpack_require__(710);
  module.exports.invertObj =
  /*#__PURE__*/
  __webpack_require__(746);
  module.exports.invoker =
  /*#__PURE__*/
  __webpack_require__(691);
  module.exports.is =
  /*#__PURE__*/
  __webpack_require__(452);
  module.exports.isEmpty =
  /*#__PURE__*/
  __webpack_require__(346);
  module.exports.isNil =
  /*#__PURE__*/
  __webpack_require__(317);
  module.exports.join =
  /*#__PURE__*/
  __webpack_require__(644);
  module.exports.juxt =
  /*#__PURE__*/
  __webpack_require__(314);
  module.exports.keys =
  /*#__PURE__*/
  __webpack_require__(89);
  module.exports.keysIn =
  /*#__PURE__*/
  __webpack_require__(620);
  module.exports.last =
  /*#__PURE__*/
  __webpack_require__(951);
  module.exports.lastIndexOf =
  /*#__PURE__*/
  __webpack_require__(1);
  module.exports.length =
  /*#__PURE__*/
  __webpack_require__(262);
  module.exports.lens =
  /*#__PURE__*/
  __webpack_require__(596);
  module.exports.lensIndex =
  /*#__PURE__*/
  __webpack_require__(515);
  module.exports.lensPath =
  /*#__PURE__*/
  __webpack_require__(272);
  module.exports.lensProp =
  /*#__PURE__*/
  __webpack_require__(461);
  module.exports.lift =
  /*#__PURE__*/
  __webpack_require__(127);
  module.exports.liftN =
  /*#__PURE__*/
  __webpack_require__(748);
  module.exports.lt =
  /*#__PURE__*/
  __webpack_require__(125);
  module.exports.lte =
  /*#__PURE__*/
  __webpack_require__(212);
  module.exports.map =
  /*#__PURE__*/
  __webpack_require__(523);
  module.exports.mapAccum =
  /*#__PURE__*/
  __webpack_require__(611);
  module.exports.mapAccumRight =
  /*#__PURE__*/
  __webpack_require__(826);
  module.exports.mapObjIndexed =
  /*#__PURE__*/
  __webpack_require__(284);
  module.exports.match =
  /*#__PURE__*/
  __webpack_require__(488);
  module.exports.mathMod =
  /*#__PURE__*/
  __webpack_require__(45);
  module.exports.max =
  /*#__PURE__*/
  __webpack_require__(793);
  module.exports.maxBy =
  /*#__PURE__*/
  __webpack_require__(937);
  module.exports.mean =
  /*#__PURE__*/
  __webpack_require__(460);
  module.exports.median =
  /*#__PURE__*/
  __webpack_require__(223);
  module.exports.memoizeWith =
  /*#__PURE__*/
  __webpack_require__(999);
  module.exports.merge =
  /*#__PURE__*/
  __webpack_require__(650);
  module.exports.mergeAll =
  /*#__PURE__*/
  __webpack_require__(841);
  module.exports.mergeDeepLeft =
  /*#__PURE__*/
  __webpack_require__(734);
  module.exports.mergeDeepRight =
  /*#__PURE__*/
  __webpack_require__(505);
  module.exports.mergeDeepWith =
  /*#__PURE__*/
  __webpack_require__(120);
  module.exports.mergeDeepWithKey =
  /*#__PURE__*/
  __webpack_require__(492);
  module.exports.mergeLeft =
  /*#__PURE__*/
  __webpack_require__(121);
  module.exports.mergeRight =
  /*#__PURE__*/
  __webpack_require__(690);
  module.exports.mergeWith =
  /*#__PURE__*/
  __webpack_require__(927);
  module.exports.mergeWithKey =
  /*#__PURE__*/
  __webpack_require__(681);
  module.exports.min =
  /*#__PURE__*/
  __webpack_require__(915);
  module.exports.minBy =
  /*#__PURE__*/
  __webpack_require__(669);
  module.exports.modulo =
  /*#__PURE__*/
  __webpack_require__(508);
  module.exports.move =
  /*#__PURE__*/
  __webpack_require__(610);
  module.exports.multiply =
  /*#__PURE__*/
  __webpack_require__(880);
  module.exports.nAry =
  /*#__PURE__*/
  __webpack_require__(425);
  module.exports.negate =
  /*#__PURE__*/
  __webpack_require__(266);
  module.exports.none =
  /*#__PURE__*/
  __webpack_require__(86);
  module.exports.not =
  /*#__PURE__*/
  __webpack_require__(237);
  module.exports.nth =
  /*#__PURE__*/
  __webpack_require__(653);
  module.exports.nthArg =
  /*#__PURE__*/
  __webpack_require__(399);
  module.exports.o =
  /*#__PURE__*/
  __webpack_require__(671);
  module.exports.objOf =
  /*#__PURE__*/
  __webpack_require__(110);
  module.exports.of =
  /*#__PURE__*/
  __webpack_require__(103);
  module.exports.omit =
  /*#__PURE__*/
  __webpack_require__(53);
  module.exports.once =
  /*#__PURE__*/
  __webpack_require__(295);
  module.exports.or =
  /*#__PURE__*/
  __webpack_require__(443);
  module.exports.otherwise =
  /*#__PURE__*/
  __webpack_require__(925);
  module.exports.over =
  /*#__PURE__*/
  __webpack_require__(97);
  module.exports.pair =
  /*#__PURE__*/
  __webpack_require__(77);
  module.exports.partial =
  /*#__PURE__*/
  __webpack_require__(814);
  module.exports.partialRight =
  /*#__PURE__*/
  __webpack_require__(771);
  module.exports.partition =
  /*#__PURE__*/
  __webpack_require__(368);
  module.exports.path =
  /*#__PURE__*/
  __webpack_require__(756);
  module.exports.paths =
  /*#__PURE__*/
  __webpack_require__(394);
  module.exports.pathEq =
  /*#__PURE__*/
  __webpack_require__(449);
  module.exports.pathOr =
  /*#__PURE__*/
  __webpack_require__(25);
  module.exports.pathSatisfies =
  /*#__PURE__*/
  __webpack_require__(41);
  module.exports.pick =
  /*#__PURE__*/
  __webpack_require__(312);
  module.exports.pickAll =
  /*#__PURE__*/
  __webpack_require__(362);
  module.exports.pickBy =
  /*#__PURE__*/
  __webpack_require__(648);
  module.exports.pipe =
  /*#__PURE__*/
  __webpack_require__(918);
  module.exports.pipeK =
  /*#__PURE__*/
  __webpack_require__(22);
  module.exports.pipeP =
  /*#__PURE__*/
  __webpack_require__(984);
  module.exports.pipeWith =
  /*#__PURE__*/
  __webpack_require__(326);
  module.exports.pluck =
  /*#__PURE__*/
  __webpack_require__(819);
  module.exports.prepend =
  /*#__PURE__*/
  __webpack_require__(773);
  module.exports.product =
  /*#__PURE__*/
  __webpack_require__(760);
  module.exports.project =
  /*#__PURE__*/
  __webpack_require__(376);
  module.exports.prop =
  /*#__PURE__*/
  __webpack_require__(196);
  module.exports.propEq =
  /*#__PURE__*/
  __webpack_require__(134);
  module.exports.propIs =
  /*#__PURE__*/
  __webpack_require__(261);
  module.exports.propOr =
  /*#__PURE__*/
  __webpack_require__(167);
  module.exports.propSatisfies =
  /*#__PURE__*/
  __webpack_require__(757);
  module.exports.props =
  /*#__PURE__*/
  __webpack_require__(162);
  module.exports.range =
  /*#__PURE__*/
  __webpack_require__(730);
  module.exports.reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  module.exports.reduceBy =
  /*#__PURE__*/
  __webpack_require__(729);
  module.exports.reduceRight =
  /*#__PURE__*/
  __webpack_require__(382);
  module.exports.reduceWhile =
  /*#__PURE__*/
  __webpack_require__(769);
  module.exports.reduced =
  /*#__PURE__*/
  __webpack_require__(848);
  module.exports.reject =
  /*#__PURE__*/
  __webpack_require__(92);
  module.exports.remove =
  /*#__PURE__*/
  __webpack_require__(917);
  module.exports.repeat =
  /*#__PURE__*/
  __webpack_require__(258);
  module.exports.replace =
  /*#__PURE__*/
  __webpack_require__(30);
  module.exports.reverse =
  /*#__PURE__*/
  __webpack_require__(528);
  module.exports.scan =
  /*#__PURE__*/
  __webpack_require__(559);
  module.exports.sequence =
  /*#__PURE__*/
  __webpack_require__(827);
  module.exports.set =
  /*#__PURE__*/
  __webpack_require__(214);
  module.exports.slice =
  /*#__PURE__*/
  __webpack_require__(232);
  module.exports.sort =
  /*#__PURE__*/
  __webpack_require__(595);
  module.exports.sortBy =
  /*#__PURE__*/
  __webpack_require__(569);
  module.exports.sortWith =
  /*#__PURE__*/
  __webpack_require__(895);
  module.exports.split =
  /*#__PURE__*/
  __webpack_require__(628);
  module.exports.splitAt =
  /*#__PURE__*/
  __webpack_require__(364);
  module.exports.splitEvery =
  /*#__PURE__*/
  __webpack_require__(408);
  module.exports.splitWhen =
  /*#__PURE__*/
  __webpack_require__(221);
  module.exports.startsWith =
  /*#__PURE__*/
  __webpack_require__(996);
  module.exports.subtract =
  /*#__PURE__*/
  __webpack_require__(743);
  module.exports.sum =
  /*#__PURE__*/
  __webpack_require__(218);
  module.exports.symmetricDifference =
  /*#__PURE__*/
  __webpack_require__(90);
  module.exports.symmetricDifferenceWith =
  /*#__PURE__*/
  __webpack_require__(63);
  module.exports.tail =
  /*#__PURE__*/
  __webpack_require__(193);
  module.exports.take =
  /*#__PURE__*/
  __webpack_require__(498);
  module.exports.takeLast =
  /*#__PURE__*/
  __webpack_require__(173);
  module.exports.takeLastWhile =
  /*#__PURE__*/
  __webpack_require__(249);
  module.exports.takeWhile =
  /*#__PURE__*/
  __webpack_require__(39);
  module.exports.tap =
  /*#__PURE__*/
  __webpack_require__(62);
  module.exports.test =
  /*#__PURE__*/
  __webpack_require__(140);
  module.exports.andThen =
  /*#__PURE__*/
  __webpack_require__(598);
  module.exports.times =
  /*#__PURE__*/
  __webpack_require__(54);
  module.exports.toLower =
  /*#__PURE__*/
  __webpack_require__(160);
  module.exports.toPairs =
  /*#__PURE__*/
  __webpack_require__(902);
  module.exports.toPairsIn =
  /*#__PURE__*/
  __webpack_require__(509);
  module.exports.toString =
  /*#__PURE__*/
  __webpack_require__(854);
  module.exports.toUpper =
  /*#__PURE__*/
  __webpack_require__(770);
  module.exports.transduce =
  /*#__PURE__*/
  __webpack_require__(482);
  module.exports.transpose =
  /*#__PURE__*/
  __webpack_require__(992);
  module.exports.traverse =
  /*#__PURE__*/
  __webpack_require__(866);
  module.exports.trim =
  /*#__PURE__*/
  __webpack_require__(356);
  module.exports.tryCatch =
  /*#__PURE__*/
  __webpack_require__(219);
  module.exports.type =
  /*#__PURE__*/
  __webpack_require__(552);
  module.exports.unapply =
  /*#__PURE__*/
  __webpack_require__(64);
  module.exports.unary =
  /*#__PURE__*/
  __webpack_require__(715);
  module.exports.uncurryN =
  /*#__PURE__*/
  __webpack_require__(586);
  module.exports.unfold =
  /*#__PURE__*/
  __webpack_require__(195);
  module.exports.union =
  /*#__PURE__*/
  __webpack_require__(410);
  module.exports.unionWith =
  /*#__PURE__*/
  __webpack_require__(163);
  module.exports.uniq =
  /*#__PURE__*/
  __webpack_require__(732);
  module.exports.uniqBy =
  /*#__PURE__*/
  __webpack_require__(703);
  module.exports.uniqWith =
  /*#__PURE__*/
  __webpack_require__(780);
  module.exports.unless =
  /*#__PURE__*/
  __webpack_require__(986);
  module.exports.unnest =
  /*#__PURE__*/
  __webpack_require__(104);
  module.exports.until =
  /*#__PURE__*/
  __webpack_require__(765);
  module.exports.update =
  /*#__PURE__*/
  __webpack_require__(881);
  module.exports.useWith =
  /*#__PURE__*/
  __webpack_require__(467);
  module.exports.values =
  /*#__PURE__*/
  __webpack_require__(256);
  module.exports.valuesIn =
  /*#__PURE__*/
  __webpack_require__(241);
  module.exports.view =
  /*#__PURE__*/
  __webpack_require__(67);
  module.exports.when =
  /*#__PURE__*/
  __webpack_require__(659);
  module.exports.where =
  /*#__PURE__*/
  __webpack_require__(113);
  module.exports.whereEq =
  /*#__PURE__*/
  __webpack_require__(539);
  module.exports.without =
  /*#__PURE__*/
  __webpack_require__(69);
  module.exports.xor =
  /*#__PURE__*/
  __webpack_require__(536);
  module.exports.xprod =
  /*#__PURE__*/
  __webpack_require__(609);
  module.exports.zip =
  /*#__PURE__*/
  __webpack_require__(630);
  module.exports.zipObj =
  /*#__PURE__*/
  __webpack_require__(956);
  module.exports.zipWith =
  /*#__PURE__*/
  __webpack_require__(837);
  module.exports.thunkify =
  /*#__PURE__*/
  __webpack_require__(159);
  
  /***/ }),
  /* 62 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xtap =
  /*#__PURE__*/
  __webpack_require__(839);
  /**
   * Runs the given function with the supplied object, then returns the object.
   *
   * Acts as a transducer if a transformer is given as second parameter.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig (a -> *) -> a -> a
   * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.
   * @param {*} x
   * @return {*} `x`.
   * @example
   *
   *      const sayX = x => console.log('x is ' + x);
   *      R.tap(sayX, 100); //=> 100
   *      // logs 'x is 100'
   * @symb R.tap(f, a) = a
   */
  
  
  var tap =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xtap, function tap(fn, x) {
    fn(x);
    return x;
  }));
  
  module.exports = tap;
  
  /***/ }),
  /* 63 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var concat =
  /*#__PURE__*/
  __webpack_require__(818);
  
  var differenceWith =
  /*#__PURE__*/
  __webpack_require__(716);
  /**
   * Finds the set (i.e. no duplicates) of all elements contained in the first or
   * second list, but not both. Duplication is determined according to the value
   * returned by applying the supplied predicate to two list elements.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Relation
   * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]
   * @param {Function} pred A predicate used to test whether two items are equal.
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The elements in `list1` or `list2`, but not both.
   * @see R.symmetricDifference, R.difference, R.differenceWith
   * @example
   *
   *      const eqA = R.eqBy(R.prop('a'));
   *      const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
   *      const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
   *      R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
   */
  
  
  var symmetricDifferenceWith =
  /*#__PURE__*/
  _curry3(function symmetricDifferenceWith(pred, list1, list2) {
    return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));
  });
  
  module.exports = symmetricDifferenceWith;
  
  /***/ }),
  /* 64 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Takes a function `fn`, which takes a single array argument, and returns a
   * function which:
   *
   *   - takes any number of positional arguments;
   *   - passes these arguments to `fn` as an array; and
   *   - returns the result.
   *
   * In other words, `R.unapply` derives a variadic function from a function which
   * takes an array. `R.unapply` is the inverse of [`R.apply`](#apply).
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Function
   * @sig ([*...] -> a) -> (*... -> a)
   * @param {Function} fn
   * @return {Function}
   * @see R.apply
   * @example
   *
   *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'
   * @symb R.unapply(f)(a, b) = f([a, b])
   */
  
  
  var unapply =
  /*#__PURE__*/
  _curry1(function unapply(fn) {
    return function () {
      return fn(Array.prototype.slice.call(arguments, 0));
    };
  });
  
  module.exports = unapply;
  
  /***/ }),
  /* 65 */,
  /* 66 */
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = function(tagname, parent, val) {
    this.tagname = tagname;
    this.parent = parent;
    this.child = {}; //child tags
    this.attrsMap = {}; //attributes map
    this.val = val; //text only
    this.addChild = function(child) {
      if (Array.isArray(this.child[child.tagname])) {
        //already presents
        this.child[child.tagname].push(child);
      } else {
        this.child[child.tagname] = [child];
      }
    };
  };
  
  
  /***/ }),
  /* 67 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830); // `Const` is a functor that effectively ignores the function given to `map`.
  
  
  var Const = function (x) {
    return {
      value: x,
      'fantasy-land/map': function () {
        return this;
      }
    };
  };
  /**
   * Returns a "view" of the given data structure, determined by the given lens.
   * The lens's focus determines which portion of the data structure is visible.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig Lens s a -> s -> a
   * @param {Lens} lens
   * @param {*} x
   * @return {*}
   * @see R.prop, R.lensIndex, R.lensProp
   * @example
   *
   *      const xLens = R.lensProp('x');
   *
   *      R.view(xLens, {x: 1, y: 2});  //=> 1
   *      R.view(xLens, {x: 4, y: 2});  //=> 4
   */
  
  
  var view =
  /*#__PURE__*/
  _curry2(function view(lens, x) {
    // Using `Const` effectively ignores the setter function of the `lens`,
    // leaving the value returned by the getter function unmodified.
    return lens(Const)(x).value;
  });
  
  module.exports = view;
  
  /***/ }),
  /* 68 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  async function auth(token) {
    const tokenType = token.split(/\./).length === 3 ? "app" : /^v\d+\./.test(token) ? "installation" : "oauth";
    return {
      type: "token",
      token: token,
      tokenType
    };
  }
  
  /**
   * Prefix token for usage in the Authorization header
   *
   * @param token OAuth token or JSON Web Token
   */
  function withAuthorizationPrefix(token) {
    if (token.split(/\./).length === 3) {
      return `bearer ${token}`;
    }
  
    return `token ${token}`;
  }
  
  async function hook(token, request, route, parameters) {
    const endpoint = request.endpoint.merge(route, parameters);
    endpoint.headers.authorization = withAuthorizationPrefix(token);
    return request(endpoint);
  }
  
  const createTokenAuth = function createTokenAuth(token) {
    if (!token) {
      throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");
    }
  
    if (typeof token !== "string") {
      throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");
    }
  
    token = token.replace(/^(token|bearer) +/i, "");
    return Object.assign(auth.bind(null, token), {
      hook: hook.bind(null, token)
    });
  };
  
  exports.createTokenAuth = createTokenAuth;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 69 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var flip =
  /*#__PURE__*/
  __webpack_require__(328);
  
  var reject =
  /*#__PURE__*/
  __webpack_require__(92);
  /**
   * Returns a new list without values in the first argument.
   * [`R.equals`](#equals) is used to determine equality.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig [a] -> [a] -> [a]
   * @param {Array} list1 The values to be removed from `list2`.
   * @param {Array} list2 The array to remove values from.
   * @return {Array} The new array without values in `list1`.
   * @see R.transduce, R.difference, R.remove
   * @example
   *
   *      R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
   */
  
  
  var without =
  /*#__PURE__*/
  _curry2(function (xs, list) {
    return reject(flip(_includes)(xs), list);
  });
  
  module.exports = without;
  
  /***/ }),
  /* 70 */,
  /* 71 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const cp = __webpack_require__(129);
  const parse = __webpack_require__(568);
  const enoent = __webpack_require__(478);
  
  function spawn(command, args, options) {
      // Parse the arguments
      const parsed = parse(command, args, options);
  
      // Spawn the child process
      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
  
      // Hook into child process "exit" event to emit an error if the command
      // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
      enoent.hookChildProcess(spawned, parsed);
  
      return spawned;
  }
  
  function spawnSync(command, args, options) {
      // Parse the arguments
      const parsed = parse(command, args, options);
  
      // Spawn the child process
      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
  
      // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
  
      return result;
  }
  
  module.exports = spawn;
  module.exports.spawn = spawn;
  module.exports.sync = spawnSync;
  
  module.exports._parse = parse;
  module.exports._enoent = enoent;
  
  
  /***/ }),
  /* 72 */,
  /* 73 */,
  /* 74 */,
  /* 75 */,
  /* 76 */,
  /* 77 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category List
   * @sig a -> b -> (a,b)
   * @param {*} fst
   * @param {*} snd
   * @return {Array}
   * @see R.objOf, R.of
   * @example
   *
   *      R.pair('foo', 'bar'); //=> ['foo', 'bar']
   */
  
  
  var pair =
  /*#__PURE__*/
  _curry2(function pair(fst, snd) {
    return [fst, snd];
  });
  
  module.exports = pair;
  
  /***/ }),
  /* 78 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isPlaceholder =
  /*#__PURE__*/
  __webpack_require__(953);
  /**
   * Optimized internal three-arity curry function.
   *
   * @private
   * @category Function
   * @param {Function} fn The function to curry.
   * @return {Function} The curried function.
   */
  
  
  function _curry3(fn) {
    return function f3(a, b, c) {
      switch (arguments.length) {
        case 0:
          return f3;
  
        case 1:
          return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {
            return fn(a, _b, _c);
          });
  
        case 2:
          return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {
            return fn(_a, b, _c);
          }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {
            return fn(a, _b, _c);
          }) : _curry1(function (_c) {
            return fn(a, b, _c);
          });
  
        default:
          return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {
            return fn(_a, _b, c);
          }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {
            return fn(_a, b, _c);
          }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {
            return fn(a, _b, _c);
          }) : _isPlaceholder(a) ? _curry1(function (_a) {
            return fn(_a, b, c);
          }) : _isPlaceholder(b) ? _curry1(function (_b) {
            return fn(a, _b, c);
          }) : _isPlaceholder(c) ? _curry1(function (_c) {
            return fn(a, b, _c);
          }) : fn(a, b, c);
      }
    };
  }
  
  module.exports = _curry3;
  
  /***/ }),
  /* 79 */,
  /* 80 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _filter =
  /*#__PURE__*/
  __webpack_require__(695);
  
  var _isObject =
  /*#__PURE__*/
  __webpack_require__(662);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xfilter =
  /*#__PURE__*/
  __webpack_require__(959);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Takes a predicate and a `Filterable`, and returns a new filterable of the
   * same type containing the members of the given filterable which satisfy the
   * given predicate. Filterable objects include plain objects or any object
   * that has a filter method such as `Array`.
   *
   * Dispatches to the `filter` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Filterable f => (a -> Boolean) -> f a -> f a
   * @param {Function} pred
   * @param {Array} filterable
   * @return {Array} Filterable
   * @see R.reject, R.transduce, R.addIndex
   * @example
   *
   *      const isEven = n => n % 2 === 0;
   *
   *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
   *
   *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
   */
  
  
  var filter =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['filter'], _xfilter, function (pred, filterable) {
    return _isObject(filterable) ? _reduce(function (acc, key) {
      if (pred(filterable[key])) {
        acc[key] = filterable[key];
      }
  
      return acc;
    }, {}, keys(filterable)) : // else
    _filter(pred, filterable);
  }));
  
  module.exports = filter;
  
  /***/ }),
  /* 81 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var max =
  /*#__PURE__*/
  __webpack_require__(793);
  
  var pluck =
  /*#__PURE__*/
  __webpack_require__(819);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Takes a list of predicates and returns a predicate that returns true for a
   * given list of arguments if at least one of the provided predicates is
   * satisfied by those arguments.
   *
   * The function returned is a curried function whose arity matches that of the
   * highest-arity predicate.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Logic
   * @sig [(*... -> Boolean)] -> (*... -> Boolean)
   * @param {Array} predicates An array of predicates to check
   * @return {Function} The combined predicate
   * @see R.allPass
   * @example
   *
   *      const isClub = R.propEq('suit', '♣');
   *      const isSpade = R.propEq('suit', '♠');
   *      const isBlackCard = R.anyPass([isClub, isSpade]);
   *
   *      isBlackCard({rank: '10', suit: '♣'}); //=> true
   *      isBlackCard({rank: 'Q', suit: '♠'}); //=> true
   *      isBlackCard({rank: 'Q', suit: '♦'}); //=> false
   */
  
  
  var anyPass =
  /*#__PURE__*/
  _curry1(function anyPass(preds) {
    return curryN(reduce(max, 0, pluck('length', preds)), function () {
      var idx = 0;
      var len = preds.length;
  
      while (idx < len) {
        if (preds[idx].apply(this, arguments)) {
          return true;
        }
  
        idx += 1;
      }
  
      return false;
    });
  });
  
  module.exports = anyPass;
  
  /***/ }),
  /* 82 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.toCommandValue = void 0;
  /**
   * Sanitizes an input into a string so it can be passed into issueCommand safely
   * @param input input to sanitize into a string
   */
  function toCommandValue(input) {
      if (input === null || input === undefined) {
          return '';
      }
      else if (typeof input === 'string' || input instanceof String) {
          return input;
      }
      return JSON.stringify(input);
  }
  exports.toCommandValue = toCommandValue;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  /* 83 */,
  /* 84 */,
  /* 85 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns all but the last element of the given list or string.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category List
   * @sig [a] -> [a]
   * @sig String -> String
   * @param {*} list
   * @return {*}
   * @see R.last, R.head, R.tail
   * @example
   *
   *      R.init([1, 2, 3]);  //=> [1, 2]
   *      R.init([1, 2]);     //=> [1]
   *      R.init([1]);        //=> []
   *      R.init([]);         //=> []
   *
   *      R.init('abc');  //=> 'ab'
   *      R.init('ab');   //=> 'a'
   *      R.init('a');    //=> ''
   *      R.init('');     //=> ''
   */
  
  
  var init =
  /*#__PURE__*/
  slice(0, -1);
  module.exports = init;
  
  /***/ }),
  /* 86 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _complement =
  /*#__PURE__*/
  __webpack_require__(964);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var all =
  /*#__PURE__*/
  __webpack_require__(320);
  /**
   * Returns `true` if no elements of the list match the predicate, `false`
   * otherwise.
   *
   * Dispatches to the `all` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> Boolean
   * @param {Function} fn The predicate function.
   * @param {Array} list The array to consider.
   * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.
   * @see R.all, R.any
   * @example
   *
   *      const isEven = n => n % 2 === 0;
   *      const isOdd = n => n % 2 === 1;
   *
   *      R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true
   *      R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false
   */
  
  
  var none =
  /*#__PURE__*/
  _curry2(function none(fn, input) {
    return all(_complement(fn), input);
  });
  
  module.exports = none;
  
  /***/ }),
  /* 87 */
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  /* 88 */,
  /* 89 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var _isArguments =
  /*#__PURE__*/
  __webpack_require__(960); // cover IE < 9 keys issues
  
  
  var hasEnumBug = !
  /*#__PURE__*/
  {
    toString: null
  }.propertyIsEnumerable('toString');
  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug
  
  var hasArgsEnumBug =
  /*#__PURE__*/
  function () {
    'use strict';
  
    return arguments.propertyIsEnumerable('length');
  }();
  
  var contains = function contains(list, item) {
    var idx = 0;
  
    while (idx < list.length) {
      if (list[idx] === item) {
        return true;
      }
  
      idx += 1;
    }
  
    return false;
  };
  /**
   * Returns a list containing the names of all the enumerable own properties of
   * the supplied object.
   * Note that the order of the output array is not guaranteed to be consistent
   * across different JS platforms.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig {k: v} -> [k]
   * @param {Object} obj The object to extract properties from
   * @return {Array} An array of the object's own properties.
   * @see R.keysIn, R.values
   * @example
   *
   *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
   */
  
  
  var keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?
  /*#__PURE__*/
  _curry1(function keys(obj) {
    return Object(obj) !== obj ? [] : Object.keys(obj);
  }) :
  /*#__PURE__*/
  _curry1(function keys(obj) {
    if (Object(obj) !== obj) {
      return [];
    }
  
    var prop, nIdx;
    var ks = [];
  
    var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
  
    for (prop in obj) {
      if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
        ks[ks.length] = prop;
      }
    }
  
    if (hasEnumBug) {
      nIdx = nonEnumerableProps.length - 1;
  
      while (nIdx >= 0) {
        prop = nonEnumerableProps[nIdx];
  
        if (_has(prop, obj) && !contains(ks, prop)) {
          ks[ks.length] = prop;
        }
  
        nIdx -= 1;
      }
    }
  
    return ks;
  });
  module.exports = keys;
  
  /***/ }),
  /* 90 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var concat =
  /*#__PURE__*/
  __webpack_require__(818);
  
  var difference =
  /*#__PURE__*/
  __webpack_require__(275);
  /**
   * Finds the set (i.e. no duplicates) of all elements contained in the first or
   * second list, but not both.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Relation
   * @sig [*] -> [*] -> [*]
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The elements in `list1` or `list2`, but not both.
   * @see R.symmetricDifferenceWith, R.difference, R.differenceWith
   * @example
   *
   *      R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]
   *      R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]
   */
  
  
  var symmetricDifference =
  /*#__PURE__*/
  _curry2(function symmetricDifference(list1, list2) {
    return concat(difference(list1, list2), difference(list2, list1));
  });
  
  module.exports = symmetricDifference;
  
  /***/ }),
  /* 91 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Takes a value and applies a function to it.
   *
   * This function is also known as the `thrush` combinator.
   *
   * @func
   * @memberOf R
   * @since v0.25.0
   * @category Function
   * @sig a -> (a -> b) -> b
   * @param {*} x The value
   * @param {Function} f The function to apply
   * @return {*} The result of applying `f` to `x`
   * @example
   *
   *      const t42 = R.applyTo(42);
   *      t42(R.identity); //=> 42
   *      t42(R.add(1)); //=> 43
   */
  
  
  var applyTo =
  /*#__PURE__*/
  _curry2(function applyTo(x, f) {
    return f(x);
  });
  
  module.exports = applyTo;
  
  /***/ }),
  /* 92 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _complement =
  /*#__PURE__*/
  __webpack_require__(964);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var filter =
  /*#__PURE__*/
  __webpack_require__(80);
  /**
   * The complement of [`filter`](#filter).
   *
   * Acts as a transducer if a transformer is given in list position. Filterable
   * objects include plain objects or any object that has a filter method such
   * as `Array`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Filterable f => (a -> Boolean) -> f a -> f a
   * @param {Function} pred
   * @param {Array} filterable
   * @return {Array}
   * @see R.filter, R.transduce, R.addIndex
   * @example
   *
   *      const isOdd = (n) => n % 2 === 1;
   *
   *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
   *
   *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
   */
  
  
  var reject =
  /*#__PURE__*/
  _curry2(function reject(pred, filterable) {
    return filter(_complement(pred), filterable);
  });
  
  module.exports = reject;
  
  /***/ }),
  /* 93 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = minimatch
  minimatch.Minimatch = Minimatch
  
  var path = { sep: '/' }
  try {
    path = __webpack_require__(622)
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
  var expand = __webpack_require__(306)
  
  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, '\\$&')
  }
  
  
  /***/ }),
  /* 94 */,
  /* 95 */,
  /* 96 */
  /***/ (function(module) {
  
  /**
   * A function that always returns `true`. Any passed in parameters are ignored.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Function
   * @sig * -> Boolean
   * @param {*}
   * @return {Boolean}
   * @see R.F
   * @example
   *
   *      R.T(); //=> true
   */
  var T = function () {
    return true;
  };
  
  module.exports = T;
  
  /***/ }),
  /* 97 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78); // `Identity` is a functor that holds a single value, where `map` simply
  // transforms the held value with the provided function.
  
  
  var Identity = function (x) {
    return {
      value: x,
      map: function (f) {
        return Identity(f(x));
      }
    };
  };
  /**
   * Returns the result of "setting" the portion of the given data structure
   * focused by the given lens to the result of applying the given function to
   * the focused value.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig Lens s a -> (a -> a) -> s -> s
   * @param {Lens} lens
   * @param {*} v
   * @param {*} x
   * @return {*}
   * @see R.prop, R.lensIndex, R.lensProp
   * @example
   *
   *      const headLens = R.lensIndex(0);
   *
   *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
   */
  
  
  var over =
  /*#__PURE__*/
  _curry3(function over(lens, f, x) {
    // The value returned by the getter function is first transformed with `f`,
    // then set as the value of an `Identity`. This is then mapped over with the
    // setter function of the lens.
    return lens(function (y) {
      return Identity(f(y));
    })(x).value;
  });
  
  module.exports = over;
  
  /***/ }),
  /* 98 */,
  /* 99 */,
  /* 100 */,
  /* 101 */,
  /* 102 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.issueCommand = void 0;
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar(__webpack_require__(747));
  const os = __importStar(__webpack_require__(87));
  const utils_1 = __webpack_require__(82);
  function issueCommand(command, message) {
      const filePath = process.env[`GITHUB_${command}`];
      if (!filePath) {
          throw new Error(`Unable to find environment variable for file command ${command}`);
      }
      if (!fs.existsSync(filePath)) {
          throw new Error(`Missing file at path: ${filePath}`);
      }
      fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
          encoding: 'utf8'
      });
  }
  exports.issueCommand = issueCommand;
  //# sourceMappingURL=file-command.js.map
  
  /***/ }),
  /* 103 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _of =
  /*#__PURE__*/
  __webpack_require__(501);
  /**
   * Returns a singleton array containing the value provided.
   *
   * Note this `of` is different from the ES6 `of`; See
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category Function
   * @sig a -> [a]
   * @param {*} x any value
   * @return {Array} An array wrapping `x`.
   * @example
   *
   *      R.of(null); //=> [null]
   *      R.of([42]); //=> [[42]]
   */
  
  
  var of =
  /*#__PURE__*/
  _curry1(_of);
  
  module.exports = of;
  
  /***/ }),
  /* 104 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _identity =
  /*#__PURE__*/
  __webpack_require__(631);
  
  var chain =
  /*#__PURE__*/
  __webpack_require__(481);
  /**
   * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from
   * any [Chain](https://github.com/fantasyland/fantasy-land#chain).
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category List
   * @sig Chain c => c (c a) -> c a
   * @param {*} list
   * @return {*}
   * @see R.flatten, R.chain
   * @example
   *
   *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]
   *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]
   */
  
  
  var unnest =
  /*#__PURE__*/
  chain(_identity);
  module.exports = unnest;
  
  /***/ }),
  /* 105 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Makes a comparator function out of a function that reports whether the first
   * element is less than the second.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig ((a, b) -> Boolean) -> ((a, b) -> Number)
   * @param {Function} pred A predicate function of arity two which will return `true` if the first argument
   * is less than the second, `false` otherwise
   * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`
   * @example
   *
   *      const byAge = R.comparator((a, b) => a.age < b.age);
   *      const people = [
   *        { name: 'Emma', age: 70 },
   *        { name: 'Peter', age: 78 },
   *        { name: 'Mikhail', age: 62 },
   *      ];
   *      const peopleByIncreasingAge = R.sort(byAge, people);
   *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]
   */
  
  
  var comparator =
  /*#__PURE__*/
  _curry1(function comparator(pred) {
    return function (a, b) {
      return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;
    };
  });
  
  module.exports = comparator;
  
  /***/ }),
  /* 106 */,
  /* 107 */,
  /* 108 */
  /***/ (function(module) {
  
  module.exports = require("net");
  
  /***/ }),
  /* 109 */,
  /* 110 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates an object containing a single key:value pair.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category Object
   * @sig String -> a -> {String:a}
   * @param {String} key
   * @param {*} val
   * @return {Object}
   * @see R.pair
   * @example
   *
   *      const matchPhrases = R.compose(
   *        R.objOf('must'),
   *        R.map(R.objOf('match_phrase'))
   *      );
   *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}
   */
  
  
  var objOf =
  /*#__PURE__*/
  _curry2(function objOf(key, val) {
    var obj = {};
    obj[key] = val;
    return obj;
  });
  
  module.exports = objOf;
  
  /***/ }),
  /* 111 */,
  /* 112 */,
  /* 113 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  /**
   * Takes a spec object and a test object; returns true if the test satisfies
   * the spec. Each of the spec's own properties must be a predicate function.
   * Each predicate is applied to the value of the corresponding property of the
   * test object. `where` returns true if all the predicates return true, false
   * otherwise.
   *
   * `where` is well suited to declaratively expressing constraints for other
   * functions such as [`filter`](#filter) and [`find`](#find).
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category Object
   * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean
   * @param {Object} spec
   * @param {Object} testObj
   * @return {Boolean}
   * @see R.propSatisfies, R.whereEq
   * @example
   *
   *      // pred :: Object -> Boolean
   *      const pred = R.where({
   *        a: R.equals('foo'),
   *        b: R.complement(R.equals('bar')),
   *        x: R.gt(R.__, 10),
   *        y: R.lt(R.__, 20)
   *      });
   *
   *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
   *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
   *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
   *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
   *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false
   */
  
  
  var where =
  /*#__PURE__*/
  _curry2(function where(spec, testObj) {
    for (var prop in spec) {
      if (_has(prop, spec) && !spec[prop](testObj[prop])) {
        return false;
      }
    }
  
    return true;
  });
  
  module.exports = where;
  
  /***/ }),
  /* 114 */,
  /* 115 */,
  /* 116 */,
  /* 117 */,
  /* 118 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  
  const nameMap = new Map([
  	[21, ['Monterey', '12']],
  	[20, ['Big Sur', '11']],
  	[19, ['Catalina', '10.15']],
  	[18, ['Mojave', '10.14']],
  	[17, ['High Sierra', '10.13']],
  	[16, ['Sierra', '10.12']],
  	[15, ['El Capitan', '10.11']],
  	[14, ['Yosemite', '10.10']],
  	[13, ['Mavericks', '10.9']],
  	[12, ['Mountain Lion', '10.8']],
  	[11, ['Lion', '10.7']],
  	[10, ['Snow Leopard', '10.6']],
  	[9, ['Leopard', '10.5']],
  	[8, ['Tiger', '10.4']],
  	[7, ['Panther', '10.3']],
  	[6, ['Jaguar', '10.2']],
  	[5, ['Puma', '10.1']]
  ]);
  
  const macosRelease = release => {
  	release = Number((release || os.release()).split('.')[0]);
  
  	const [name, version] = nameMap.get(release);
  
  	return {
  		name,
  		version
  	};
  };
  
  module.exports = macosRelease;
  // TODO: remove this in the next major version
  module.exports.default = macosRelease;
  
  
  /***/ }),
  /* 119 */,
  /* 120 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var mergeDeepWithKey =
  /*#__PURE__*/
  __webpack_require__(492);
  /**
   * Creates a new object with the own properties of the two provided objects.
   * If a key exists in both objects:
   * - and both associated values are also objects then the values will be
   *   recursively merged.
   * - otherwise the provided function is applied to associated values using the
   *   resulting value as the new value associated with the key.
   * If a key only exists in one object, the value will be associated with the key
   * of the resulting object.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Object
   * @sig ((a, a) -> a) -> {a} -> {a} -> {a}
   * @param {Function} fn
   * @param {Object} lObj
   * @param {Object} rObj
   * @return {Object}
   * @see R.mergeWith, R.mergeDeepWithKey
   * @example
   *
   *      R.mergeDeepWith(R.concat,
   *                      { a: true, c: { values: [10, 20] }},
   *                      { b: true, c: { values: [15, 35] }});
   *      //=> { a: true, b: true, c: { values: [10, 20, 15, 35] }}
   */
  
  
  var mergeDeepWith =
  /*#__PURE__*/
  _curry3(function mergeDeepWith(fn, lObj, rObj) {
    return mergeDeepWithKey(function (k, lVal, rVal) {
      return fn(lVal, rVal);
    }, lObj, rObj);
  });
  
  module.exports = mergeDeepWith;
  
  /***/ }),
  /* 121 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectAssign =
  /*#__PURE__*/
  __webpack_require__(289);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Create a new object with the own properties of the first object merged with
   * the own properties of the second object. If a key exists in both objects,
   * the value from the first object will be used.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Object
   * @sig {k: v} -> {k: v} -> {k: v}
   * @param {Object} l
   * @param {Object} r
   * @return {Object}
   * @see R.mergeRight, R.mergeDeepLeft, R.mergeWith, R.mergeWithKey
   * @example
   *
   *      R.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
   *      //=> { 'name': 'fred', 'age': 40 }
   *
   *      const resetToDefault = R.mergeLeft({x: 0});
   *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
   * @symb R.mergeLeft(a, b) = {...b, ...a}
   */
  
  
  var mergeLeft =
  /*#__PURE__*/
  _curry2(function mergeLeft(l, r) {
    return _objectAssign({}, r, l);
  });
  
  module.exports = mergeLeft;
  
  /***/ }),
  /* 122 */,
  /* 123 */,
  /* 124 */,
  /* 125 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the first argument is less than the second; `false`
   * otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> Boolean
   * @param {*} a
   * @param {*} b
   * @return {Boolean}
   * @see R.gt
   * @example
   *
   *      R.lt(2, 1); //=> false
   *      R.lt(2, 2); //=> false
   *      R.lt(2, 3); //=> true
   *      R.lt('a', 'z'); //=> true
   *      R.lt('z', 'a'); //=> false
   */
  
  
  var lt =
  /*#__PURE__*/
  _curry2(function lt(a, b) {
    return a < b;
  });
  
  module.exports = lt;
  
  /***/ }),
  /* 126 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _checkForMethod =
  /*#__PURE__*/
  __webpack_require__(417);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a new list with the separator interposed between elements.
   *
   * Dispatches to the `intersperse` method of the second argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category List
   * @sig a -> [a] -> [a]
   * @param {*} separator The element to add to the list.
   * @param {Array} list The list to be interposed.
   * @return {Array} The new list.
   * @example
   *
   *      R.intersperse('a', ['b', 'n', 'n', 's']); //=> ['b', 'a', 'n', 'a', 'n', 'a', 's']
   */
  
  
  var intersperse =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _checkForMethod('intersperse', function intersperse(separator, list) {
    var out = [];
    var idx = 0;
    var length = list.length;
  
    while (idx < length) {
      if (idx === length - 1) {
        out.push(list[idx]);
      } else {
        out.push(list[idx], separator);
      }
  
      idx += 1;
    }
  
    return out;
  }));
  
  module.exports = intersperse;
  
  /***/ }),
  /* 127 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var liftN =
  /*#__PURE__*/
  __webpack_require__(748);
  /**
   * "lifts" a function of arity > 1 so that it may "map over" a list, Function or other
   * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Function
   * @sig (*... -> *) -> ([*]... -> [*])
   * @param {Function} fn The function to lift into higher context
   * @return {Function} The lifted function.
   * @see R.liftN
   * @example
   *
   *      const madd3 = R.lift((a, b, c) => a + b + c);
   *
   *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
   *
   *      const madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);
   *
   *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]
   */
  
  
  var lift =
  /*#__PURE__*/
  _curry1(function lift(fn) {
    return liftN(fn.length, fn);
  });
  
  module.exports = lift;
  
  /***/ }),
  /* 128 */,
  /* 129 */
  /***/ (function(module) {
  
  module.exports = require("child_process");
  
  /***/ }),
  /* 130 */,
  /* 131 */,
  /* 132 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var curry =
  /*#__PURE__*/
  __webpack_require__(447);
  /**
   * Returns the result of calling its first argument with the remaining
   * arguments. This is occasionally useful as a converging function for
   * [`R.converge`](#converge): the first branch can produce a function while the
   * remaining branches produce values to be passed to that function as its
   * arguments.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Function
   * @sig (*... -> a),*... -> a
   * @param {Function} fn The function to apply to the remaining arguments.
   * @param {...*} args Any number of positional arguments.
   * @return {*}
   * @see R.apply
   * @example
   *
   *      R.call(R.add, 1, 2); //=> 3
   *
   *      const indentN = R.pipe(R.repeat(' '),
   *                           R.join(''),
   *                           R.replace(/^(?!$)/gm));
   *
   *      const format = R.converge(R.call, [
   *                                  R.pipe(R.prop('indent'), indentN),
   *                                  R.prop('value')
   *                              ]);
   *
   *      format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> '  foo\n  bar\n  baz\n'
   * @symb R.call(f, a, b) = f(a, b)
   */
  
  
  var call =
  /*#__PURE__*/
  curry(function call(fn) {
    return fn.apply(this, Array.prototype.slice.call(arguments, 1));
  });
  module.exports = call;
  
  /***/ }),
  /* 133 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var max =
  /*#__PURE__*/
  __webpack_require__(793);
  
  var pluck =
  /*#__PURE__*/
  __webpack_require__(819);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Takes a list of predicates and returns a predicate that returns true for a
   * given list of arguments if every one of the provided predicates is satisfied
   * by those arguments.
   *
   * The function returned is a curried function whose arity matches that of the
   * highest-arity predicate.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Logic
   * @sig [(*... -> Boolean)] -> (*... -> Boolean)
   * @param {Array} predicates An array of predicates to check
   * @return {Function} The combined predicate
   * @see R.anyPass
   * @example
   *
   *      const isQueen = R.propEq('rank', 'Q');
   *      const isSpade = R.propEq('suit', '♠︎');
   *      const isQueenOfSpades = R.allPass([isQueen, isSpade]);
   *
   *      isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
   *      isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true
   */
  
  
  var allPass =
  /*#__PURE__*/
  _curry1(function allPass(preds) {
    return curryN(reduce(max, 0, pluck('length', preds)), function () {
      var idx = 0;
      var len = preds.length;
  
      while (idx < len) {
        if (!preds[idx].apply(this, arguments)) {
          return false;
        }
  
        idx += 1;
      }
  
      return true;
    });
  });
  
  module.exports = allPass;
  
  /***/ }),
  /* 134 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Returns `true` if the specified object property is equal, in
   * [`R.equals`](#equals) terms, to the given value; `false` otherwise.
   * You can test multiple properties with [`R.whereEq`](#whereEq).
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig String -> a -> Object -> Boolean
   * @param {String} name
   * @param {*} val
   * @param {*} obj
   * @return {Boolean}
   * @see R.whereEq, R.propSatisfies, R.equals
   * @example
   *
   *      const abby = {name: 'Abby', age: 7, hair: 'blond'};
   *      const fred = {name: 'Fred', age: 12, hair: 'brown'};
   *      const rusty = {name: 'Rusty', age: 10, hair: 'brown'};
   *      const alois = {name: 'Alois', age: 15, disposition: 'surly'};
   *      const kids = [abby, fred, rusty, alois];
   *      const hasBrownHair = R.propEq('hair', 'brown');
   *      R.filter(hasBrownHair, kids); //=> [fred, rusty]
   */
  
  
  var propEq =
  /*#__PURE__*/
  _curry3(function propEq(name, val, obj) {
    return equals(val, obj[name]);
  });
  
  module.exports = propEq;
  
  /***/ }),
  /* 135 */,
  /* 136 */,
  /* 137 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xany =
  /*#__PURE__*/
  __webpack_require__(876);
  /**
   * Returns `true` if at least one of the elements of the list match the predicate,
   * `false` otherwise.
   *
   * Dispatches to the `any` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> Boolean
   * @param {Function} fn The predicate function.
   * @param {Array} list The array to consider.
   * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`
   *         otherwise.
   * @see R.all, R.none, R.transduce
   * @example
   *
   *      const lessThan0 = R.flip(R.lt)(0);
   *      const lessThan2 = R.flip(R.lt)(2);
   *      R.any(lessThan0)([1, 2]); //=> false
   *      R.any(lessThan2)([1, 2]); //=> true
   */
  
  
  var any =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['any'], _xany, function any(fn, list) {
    var idx = 0;
  
    while (idx < list.length) {
      if (fn(list[idx])) {
        return true;
      }
  
      idx += 1;
    }
  
    return false;
  }));
  
  module.exports = any;
  
  /***/ }),
  /* 138 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var pipeWith =
  /*#__PURE__*/
  __webpack_require__(326);
  
  var reverse =
  /*#__PURE__*/
  __webpack_require__(528);
  /**
   * Performs right-to-left function composition using transforming function. The last argument may have
   * any arity; the remaining arguments must be unary.
   *
   * **Note:** The result of compose is not automatically curried. Transforming function is not used on the
   * last argument.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Function
   * @sig ((* -> *), [(y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)]) -> ((a, b, ..., n) -> z)
   * @param {...Function} ...functions The functions to compose
   * @return {Function}
   * @see R.compose, R.pipeWith
   * @example
   *
   *      const composeWhileNotNil = R.composeWith((f, res) => R.isNil(res) ? res : f(res));
   *
   *      composeWhileNotNil([R.inc, R.prop('age')])({age: 1}) //=> 2
   *      composeWhileNotNil([R.inc, R.prop('age')])({}) //=> undefined
   *
   * @symb R.composeWith(f)([g, h, i])(...args) = f(g, f(h, i(...args)))
   */
  
  
  var composeWith =
  /*#__PURE__*/
  _curry2(function composeWith(xf, list) {
    return pipeWith.apply(this, [xf, reverse(list)]);
  });
  
  module.exports = composeWith;
  
  /***/ }),
  /* 139 */,
  /* 140 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _cloneRegExp =
  /*#__PURE__*/
  __webpack_require__(480);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isRegExp =
  /*#__PURE__*/
  __webpack_require__(945);
  
  var toString =
  /*#__PURE__*/
  __webpack_require__(854);
  /**
   * Determines whether a given string matches a given regular expression.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category String
   * @sig RegExp -> String -> Boolean
   * @param {RegExp} pattern
   * @param {String} str
   * @return {Boolean}
   * @see R.match
   * @example
   *
   *      R.test(/^x/, 'xyz'); //=> true
   *      R.test(/^y/, 'xyz'); //=> false
   */
  
  
  var test =
  /*#__PURE__*/
  _curry2(function test(pattern, str) {
    if (!_isRegExp(pattern)) {
      throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));
    }
  
    return _cloneRegExp(pattern).test(str);
  });
  
  module.exports = test;
  
  /***/ }),
  /* 141 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  var net = __webpack_require__(108);
  var tls = __webpack_require__(16);
  var http = __webpack_require__(605);
  var https = __webpack_require__(34);
  var events = __webpack_require__(614);
  var assert = __webpack_require__(357);
  var util = __webpack_require__(853);
  
  
  exports.httpOverHttp = httpOverHttp;
  exports.httpsOverHttp = httpsOverHttp;
  exports.httpOverHttps = httpOverHttps;
  exports.httpsOverHttps = httpsOverHttps;
  
  
  function httpOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    return agent;
  }
  
  function httpsOverHttp(options) {
    var agent = new TunnelingAgent(options);
    agent.request = http.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  function httpOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    return agent;
  }
  
  function httpsOverHttps(options) {
    var agent = new TunnelingAgent(options);
    agent.request = https.request;
    agent.createSocket = createSecureSocket;
    agent.defaultPort = 443;
    return agent;
  }
  
  
  function TunnelingAgent(options) {
    var self = this;
    self.options = options || {};
    self.proxyOptions = self.options.proxy || {};
    self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets;
    self.requests = [];
    self.sockets = [];
  
    self.on('free', function onFree(socket, host, port, localAddress) {
      var options = toOptions(host, port, localAddress);
      for (var i = 0, len = self.requests.length; i < len; ++i) {
        var pending = self.requests[i];
        if (pending.host === options.host && pending.port === options.port) {
          // Detect the request to connect same origin server,
          // reuse the connection.
          self.requests.splice(i, 1);
          pending.request.onSocket(socket);
          return;
        }
      }
      socket.destroy();
      self.removeSocket(socket);
    });
  }
  util.inherits(TunnelingAgent, events.EventEmitter);
  
  TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
    var self = this;
    var options = mergeOptions({request: req}, self.options, toOptions(host, port, localAddress));
  
    if (self.sockets.length >= this.maxSockets) {
      // We are over limit so we'll add it to the queue.
      self.requests.push(options);
      return;
    }
  
    // If we are under maxSockets create a new one.
    self.createSocket(options, function(socket) {
      socket.on('free', onFree);
      socket.on('close', onCloseOrRemove);
      socket.on('agentRemove', onCloseOrRemove);
      req.onSocket(socket);
  
      function onFree() {
        self.emit('free', socket, options);
      }
  
      function onCloseOrRemove(err) {
        self.removeSocket(socket);
        socket.removeListener('free', onFree);
        socket.removeListener('close', onCloseOrRemove);
        socket.removeListener('agentRemove', onCloseOrRemove);
      }
    });
  };
  
  TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
    var self = this;
    var placeholder = {};
    self.sockets.push(placeholder);
  
    var connectOptions = mergeOptions({}, self.proxyOptions, {
      method: 'CONNECT',
      path: options.host + ':' + options.port,
      agent: false,
      headers: {
        host: options.host + ':' + options.port
      }
    });
    if (options.localAddress) {
      connectOptions.localAddress = options.localAddress;
    }
    if (connectOptions.proxyAuth) {
      connectOptions.headers = connectOptions.headers || {};
      connectOptions.headers['Proxy-Authorization'] = 'Basic ' +
          new Buffer(connectOptions.proxyAuth).toString('base64');
    }
  
    debug('making CONNECT request');
    var connectReq = self.request(connectOptions);
    connectReq.useChunkedEncodingByDefault = false; // for v0.6
    connectReq.once('response', onResponse); // for v0.6
    connectReq.once('upgrade', onUpgrade);   // for v0.6
    connectReq.once('connect', onConnect);   // for v0.7 or later
    connectReq.once('error', onError);
    connectReq.end();
  
    function onResponse(res) {
      // Very hacky. This is necessary to avoid http-parser leaks.
      res.upgrade = true;
    }
  
    function onUpgrade(res, socket, head) {
      // Hacky.
      process.nextTick(function() {
        onConnect(res, socket, head);
      });
    }
  
    function onConnect(res, socket, head) {
      connectReq.removeAllListeners();
      socket.removeAllListeners();
  
      if (res.statusCode !== 200) {
        debug('tunneling socket could not be established, statusCode=%d',
          res.statusCode);
        socket.destroy();
        var error = new Error('tunneling socket could not be established, ' +
          'statusCode=' + res.statusCode);
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      if (head.length > 0) {
        debug('got illegal response body from proxy');
        socket.destroy();
        var error = new Error('got illegal response body from proxy');
        error.code = 'ECONNRESET';
        options.request.emit('error', error);
        self.removeSocket(placeholder);
        return;
      }
      debug('tunneling connection has established');
      self.sockets[self.sockets.indexOf(placeholder)] = socket;
      return cb(socket);
    }
  
    function onError(cause) {
      connectReq.removeAllListeners();
  
      debug('tunneling socket could not be established, cause=%s\n',
            cause.message, cause.stack);
      var error = new Error('tunneling socket could not be established, ' +
                            'cause=' + cause.message);
      error.code = 'ECONNRESET';
      options.request.emit('error', error);
      self.removeSocket(placeholder);
    }
  };
  
  TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
    var pos = this.sockets.indexOf(socket)
    if (pos === -1) {
      return;
    }
    this.sockets.splice(pos, 1);
  
    var pending = this.requests.shift();
    if (pending) {
      // If we have pending requests and a socket gets closed a new one
      // needs to be created to take over in the pool for the one that closed.
      this.createSocket(pending, function(socket) {
        pending.request.onSocket(socket);
      });
    }
  };
  
  function createSecureSocket(options, cb) {
    var self = this;
    TunnelingAgent.prototype.createSocket.call(self, options, function(socket) {
      var hostHeader = options.request.getHeader('host');
      var tlsOptions = mergeOptions({}, self.options, {
        socket: socket,
        servername: hostHeader ? hostHeader.replace(/:.*$/, '') : options.host
      });
  
      // 0 is dummy port for v0.6
      var secureSocket = tls.connect(0, tlsOptions);
      self.sockets[self.sockets.indexOf(socket)] = secureSocket;
      cb(secureSocket);
    });
  }
  
  
  function toOptions(host, port, localAddress) {
    if (typeof host === 'string') { // since v0.10
      return {
        host: host,
        port: port,
        localAddress: localAddress
      };
    }
    return host; // for v0.11 or later
  }
  
  function mergeOptions(target) {
    for (var i = 1, len = arguments.length; i < len; ++i) {
      var overrides = arguments[i];
      if (typeof overrides === 'object') {
        var keys = Object.keys(overrides);
        for (var j = 0, keyLen = keys.length; j < keyLen; ++j) {
          var k = keys[j];
          if (overrides[k] !== undefined) {
            target[k] = overrides[k];
          }
        }
      }
    }
    return target;
  }
  
  
  var debug;
  if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) {
    debug = function() {
      var args = Array.prototype.slice.call(arguments);
      if (typeof args[0] === 'string') {
        args[0] = 'TUNNEL: ' + args[0];
      } else {
        args.unshift('TUNNEL:');
      }
      console.error.apply(console, args);
    }
  } else {
    debug = function() {};
  }
  exports.debug = debug; // for test
  
  
  /***/ }),
  /* 142 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = which
  which.sync = whichSync
  
  var isWindows = process.platform === 'win32' ||
      process.env.OSTYPE === 'cygwin' ||
      process.env.OSTYPE === 'msys'
  
  var path = __webpack_require__(622)
  var COLON = isWindows ? ';' : ':'
  var isexe = __webpack_require__(813)
  
  function getNotFoundError (cmd) {
    var er = new Error('not found: ' + cmd)
    er.code = 'ENOENT'
  
    return er
  }
  
  function getPathInfo (cmd, opt) {
    var colon = opt.colon || COLON
    var pathEnv = opt.path || process.env.PATH || ''
    var pathExt = ['']
  
    pathEnv = pathEnv.split(colon)
  
    var pathExtExe = ''
    if (isWindows) {
      pathEnv.unshift(process.cwd())
      pathExtExe = (opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
      pathExt = pathExtExe.split(colon)
  
  
      // Always test the cmd itself first.  isexe will check to make sure
      // it's found in the pathExt set.
      if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
        pathExt.unshift('')
    }
  
    // If it has a slash, then we don't bother searching the pathenv.
    // just check the file itself, and that's it.
    if (cmd.match(/\//) || isWindows && cmd.match(/\\/))
      pathEnv = ['']
  
    return {
      env: pathEnv,
      ext: pathExt,
      extExe: pathExtExe
    }
  }
  
  function which (cmd, opt, cb) {
    if (typeof opt === 'function') {
      cb = opt
      opt = {}
    }
  
    var info = getPathInfo(cmd, opt)
    var pathEnv = info.env
    var pathExt = info.ext
    var pathExtExe = info.extExe
    var found = []
  
    ;(function F (i, l) {
      if (i === l) {
        if (opt.all && found.length)
          return cb(null, found)
        else
          return cb(getNotFoundError(cmd))
      }
  
      var pathPart = pathEnv[i]
      if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
        pathPart = pathPart.slice(1, -1)
  
      var p = path.join(pathPart, cmd)
      if (!pathPart && (/^\.[\\\/]/).test(cmd)) {
        p = cmd.slice(0, 2) + p
      }
      ;(function E (ii, ll) {
        if (ii === ll) return F(i + 1, l)
        var ext = pathExt[ii]
        isexe(p + ext, { pathExt: pathExtExe }, function (er, is) {
          if (!er && is) {
            if (opt.all)
              found.push(p + ext)
            else
              return cb(null, p + ext)
          }
          return E(ii + 1, ll)
        })
      })(0, pathExt.length)
    })(0, pathEnv.length)
  }
  
  function whichSync (cmd, opt) {
    opt = opt || {}
  
    var info = getPathInfo(cmd, opt)
    var pathEnv = info.env
    var pathExt = info.ext
    var pathExtExe = info.extExe
    var found = []
  
    for (var i = 0, l = pathEnv.length; i < l; i ++) {
      var pathPart = pathEnv[i]
      if (pathPart.charAt(0) === '"' && pathPart.slice(-1) === '"')
        pathPart = pathPart.slice(1, -1)
  
      var p = path.join(pathPart, cmd)
      if (!pathPart && /^\.[\\\/]/.test(cmd)) {
        p = cmd.slice(0, 2) + p
      }
      for (var j = 0, ll = pathExt.length; j < ll; j ++) {
        var cur = p + pathExt[j]
        var is
        try {
          is = isexe.sync(cur, { pathExt: pathExtExe })
          if (is) {
            if (opt.all)
              found.push(cur)
            else
              return cur
          }
        } catch (ex) {}
      }
    }
  
    if (opt.all && found.length)
      return found
  
    if (opt.nothrow)
      return null
  
    throw getNotFoundError(cmd)
  }
  
  
  /***/ }),
  /* 143 */,
  /* 144 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the first argument is greater than or equal to the second;
   * `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> Boolean
   * @param {Number} a
   * @param {Number} b
   * @return {Boolean}
   * @see R.lte
   * @example
   *
   *      R.gte(2, 1); //=> true
   *      R.gte(2, 2); //=> true
   *      R.gte(2, 3); //=> false
   *      R.gte('a', 'z'); //=> false
   *      R.gte('z', 'a'); //=> true
   */
  
  
  var gte =
  /*#__PURE__*/
  _curry2(function gte(a, b) {
    return a >= b;
  });
  
  module.exports = gte;
  
  /***/ }),
  /* 145 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const pump = __webpack_require__(453);
  const bufferStream = __webpack_require__(158);
  
  class MaxBufferError extends Error {
  	constructor() {
  		super('maxBuffer exceeded');
  		this.name = 'MaxBufferError';
  	}
  }
  
  function getStream(inputStream, options) {
  	if (!inputStream) {
  		return Promise.reject(new Error('Expected a stream'));
  	}
  
  	options = Object.assign({maxBuffer: Infinity}, options);
  
  	const {maxBuffer} = options;
  
  	let stream;
  	return 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());
  			}
  		});
  	}).then(() => stream.getBufferedValue());
  }
  
  module.exports = getStream;
  module.exports.buffer = (stream, options) => getStream(stream, Object.assign({}, options, {encoding: 'buffer'}));
  module.exports.array = (stream, options) => getStream(stream, Object.assign({}, options, {array: true}));
  module.exports.MaxBufferError = MaxBufferError;
  
  
  /***/ }),
  /* 146 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns whether or not an object or its prototype chain has a property with
   * the specified name
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Object
   * @sig s -> {s: x} -> Boolean
   * @param {String} prop The name of the property to check for.
   * @param {Object} obj The object to query.
   * @return {Boolean} Whether the property exists.
   * @example
   *
   *      function Rectangle(width, height) {
   *        this.width = width;
   *        this.height = height;
   *      }
   *      Rectangle.prototype.area = function() {
   *        return this.width * this.height;
   *      };
   *
   *      const square = new Rectangle(2, 2);
   *      R.hasIn('width', square);  //=> true
   *      R.hasIn('area', square);  //=> true
   */
  
  
  var hasIn =
  /*#__PURE__*/
  _curry2(function hasIn(prop, obj) {
    return prop in obj;
  });
  
  module.exports = hasIn;
  
  /***/ }),
  /* 147 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.annotationsForPath = void 0;
  const core = __importStar(__webpack_require__(470));
  const checkstyle_1 = __webpack_require__(646);
  const fast_xml_parser_1 = __importDefault(__webpack_require__(989));
  const fs_1 = __importDefault(__webpack_require__(747));
  const path = __importStar(__webpack_require__(622));
  const github_1 = __webpack_require__(824);
  const ramda_1 = __webpack_require__(61);
  const unescape_1 = __importDefault(__webpack_require__(444));
  const XML_PARSE_OPTIONS = {
      allowBooleanAttributes: true,
      ignoreAttributes: false,
      attributeNamePrefix: ''
  };
  function asArray(arg) {
      return !arg ? [] : Array.isArray(arg) ? arg : [arg];
  }
  function getWarningLevel(arg) {
      switch (arg) {
          case checkstyle_1.Severity.error:
              return github_1.AnnotationLevel.failure;
          case checkstyle_1.Severity.warning:
              return github_1.AnnotationLevel.warning;
          default:
              return github_1.AnnotationLevel.notice;
      }
  }
  function annotationsForPath(resultFile) {
      var _a;
      core.info(`Creating annotations for ${resultFile}`);
      const root = process.env['GITHUB_WORKSPACE'] || '';
      const result = fast_xml_parser_1.default.parse(fs_1.default.readFileSync(resultFile, 'UTF-8'), XML_PARSE_OPTIONS);
      return ramda_1.chain(file => {
          return ramda_1.map(violation => {
              const annotation = {
                  annotation_level: getWarningLevel(violation.severity),
                  path: path.relative(root, file.name),
                  start_line: Number(violation.line || 1),
                  end_line: Number(violation.line || 1),
                  title: violation.source,
                  message: unescape_1.default(violation.message)
              };
              return annotation;
          }, asArray(file.error));
      }, asArray((_a = result.checkstyle) === null || _a === void 0 ? void 0 : _a.file));
  }
  exports.annotationsForPath = annotationsForPath;
  
  
  /***/ }),
  /* 148 */,
  /* 149 */,
  /* 150 */,
  /* 151 */,
  /* 152 */,
  /* 153 */,
  /* 154 */,
  /* 155 */,
  /* 156 */,
  /* 157 */,
  /* 158 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const {PassThrough} = __webpack_require__(418);
  
  module.exports = options => {
  	options = Object.assign({}, options);
  
  	const {array} = options;
  	let {encoding} = options;
  	const buffer = encoding === 'buffer';
  	let objectMode = false;
  
  	if (array) {
  		objectMode = !(encoding || buffer);
  	} else {
  		encoding = encoding || 'utf8';
  	}
  
  	if (buffer) {
  		encoding = null;
  	}
  
  	let len = 0;
  	const ret = [];
  	const stream = new PassThrough({objectMode});
  
  	if (encoding) {
  		stream.setEncoding(encoding);
  	}
  
  	stream.on('data', chunk => {
  		ret.push(chunk);
  
  		if (objectMode) {
  			len = ret.length;
  		} else {
  			len += chunk.length;
  		}
  	});
  
  	stream.getBufferedValue = () => {
  		if (array) {
  			return ret;
  		}
  
  		return buffer ? Buffer.concat(ret, len) : ret.join('');
  	};
  
  	stream.getBufferedLength = () => len;
  
  	return stream;
  };
  
  
  /***/ }),
  /* 159 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Creates a thunk out of a function. A thunk delays a calculation until
   * its result is needed, providing lazy evaluation of arguments.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Function
   * @sig ((a, b, ..., j) -> k) -> (a, b, ..., j) -> (() -> k)
   * @param {Function} fn A function to wrap in a thunk
   * @return {Function} Expects arguments for `fn` and returns a new function
   *  that, when called, applies those arguments to `fn`.
   * @see R.partial, R.partialRight
   * @example
   *
   *      R.thunkify(R.identity)(42)(); //=> 42
   *      R.thunkify((a, b) => a + b)(25, 17)(); //=> 42
   */
  
  
  var thunkify =
  /*#__PURE__*/
  _curry1(function thunkify(fn) {
    return curryN(fn.length, function createThunk() {
      var fnArgs = arguments;
      return function invokeThunk() {
        return fn.apply(this, fnArgs);
      };
    });
  });
  
  module.exports = thunkify;
  
  /***/ }),
  /* 160 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var invoker =
  /*#__PURE__*/
  __webpack_require__(691);
  /**
   * The lower case version of a string.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category String
   * @sig String -> String
   * @param {String} str The string to lower case.
   * @return {String} The lower case version of `str`.
   * @see R.toUpper
   * @example
   *
   *      R.toLower('XYZ'); //=> 'xyz'
   */
  
  
  var toLower =
  /*#__PURE__*/
  invoker(0, 'toLowerCase');
  module.exports = toLower;
  
  /***/ }),
  /* 161 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _Set =
  /*#__PURE__*/
  function () {
    function _Set() {
      /* globals Set */
      this._nativeSet = typeof Set === 'function' ? new Set() : null;
      this._items = {};
    }
  
    // until we figure out why jsdoc chokes on this
    // @param item The item to add to the Set
    // @returns {boolean} true if the item did not exist prior, otherwise false
    //
    _Set.prototype.add = function (item) {
      return !hasOrAdd(item, true, this);
    }; //
    // @param item The item to check for existence in the Set
    // @returns {boolean} true if the item exists in the Set, otherwise false
    //
  
  
    _Set.prototype.has = function (item) {
      return hasOrAdd(item, false, this);
    }; //
    // Combines the logic for checking whether an item is a member of the set and
    // for adding a new item to the set.
    //
    // @param item       The item to check or add to the Set instance.
    // @param shouldAdd  If true, the item will be added to the set if it doesn't
    //                   already exist.
    // @param set        The set instance to check or add to.
    // @return {boolean} true if the item already existed, otherwise false.
    //
  
  
    return _Set;
  }();
  
  function hasOrAdd(item, shouldAdd, set) {
    var type = typeof item;
    var prevSize, newSize;
  
    switch (type) {
      case 'string':
      case 'number':
        // distinguish between +0 and -0
        if (item === 0 && 1 / item === -Infinity) {
          if (set._items['-0']) {
            return true;
          } else {
            if (shouldAdd) {
              set._items['-0'] = true;
            }
  
            return false;
          }
        } // these types can all utilise the native Set
  
  
        if (set._nativeSet !== null) {
          if (shouldAdd) {
            prevSize = set._nativeSet.size;
  
            set._nativeSet.add(item);
  
            newSize = set._nativeSet.size;
            return newSize === prevSize;
          } else {
            return set._nativeSet.has(item);
          }
        } else {
          if (!(type in set._items)) {
            if (shouldAdd) {
              set._items[type] = {};
              set._items[type][item] = true;
            }
  
            return false;
          } else if (item in set._items[type]) {
            return true;
          } else {
            if (shouldAdd) {
              set._items[type][item] = true;
            }
  
            return false;
          }
        }
  
      case 'boolean':
        // set._items['boolean'] holds a two element array
        // representing [ falseExists, trueExists ]
        if (type in set._items) {
          var bIdx = item ? 1 : 0;
  
          if (set._items[type][bIdx]) {
            return true;
          } else {
            if (shouldAdd) {
              set._items[type][bIdx] = true;
            }
  
            return false;
          }
        } else {
          if (shouldAdd) {
            set._items[type] = item ? [false, true] : [true, false];
          }
  
          return false;
        }
  
      case 'function':
        // compare functions for reference equality
        if (set._nativeSet !== null) {
          if (shouldAdd) {
            prevSize = set._nativeSet.size;
  
            set._nativeSet.add(item);
  
            newSize = set._nativeSet.size;
            return newSize === prevSize;
          } else {
            return set._nativeSet.has(item);
          }
        } else {
          if (!(type in set._items)) {
            if (shouldAdd) {
              set._items[type] = [item];
            }
  
            return false;
          }
  
          if (!_includes(item, set._items[type])) {
            if (shouldAdd) {
              set._items[type].push(item);
            }
  
            return false;
          }
  
          return true;
        }
  
      case 'undefined':
        if (set._items[type]) {
          return true;
        } else {
          if (shouldAdd) {
            set._items[type] = true;
          }
  
          return false;
        }
  
      case 'object':
        if (item === null) {
          if (!set._items['null']) {
            if (shouldAdd) {
              set._items['null'] = true;
            }
  
            return false;
          }
  
          return true;
        }
  
      /* falls through */
  
      default:
        // reduce the search size of heterogeneous sets by creating buckets
        // for each type.
        type = Object.prototype.toString.call(item);
  
        if (!(type in set._items)) {
          if (shouldAdd) {
            set._items[type] = [item];
          }
  
          return false;
        } // scan through all previously applied items
  
  
        if (!_includes(item, set._items[type])) {
          if (shouldAdd) {
            set._items[type].push(item);
          }
  
          return false;
        }
  
        return true;
    }
  } // A simple Set type that honours R.equals semantics
  
  
  module.exports = _Set;
  
  /***/ }),
  /* 162 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * Acts as multiple `prop`: array of keys in, array of values out. Preserves
   * order.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig [k] -> {k: v} -> [v]
   * @param {Array} ps The property names to fetch
   * @param {Object} obj The object to query
   * @return {Array} The corresponding values or partially applied function.
   * @example
   *
   *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]
   *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]
   *
   *      const fullName = R.compose(R.join(' '), R.props(['first', 'last']));
   *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'
   */
  
  
  var props =
  /*#__PURE__*/
  _curry2(function props(ps, obj) {
    return ps.map(function (p) {
      return path([p], obj);
    });
  });
  
  module.exports = props;
  
  /***/ }),
  /* 163 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var uniqWith =
  /*#__PURE__*/
  __webpack_require__(780);
  /**
   * Combines two lists into a set (i.e. no duplicates) composed of the elements
   * of each list. Duplication is determined according to the value returned by
   * applying the supplied predicate to two list elements.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig ((a, a) -> Boolean) -> [*] -> [*] -> [*]
   * @param {Function} pred A predicate used to test whether two items are equal.
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The first and second lists concatenated, with
   *         duplicates removed.
   * @see R.union
   * @example
   *
   *      const l1 = [{a: 1}, {a: 2}];
   *      const l2 = [{a: 1}, {a: 4}];
   *      R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]
   */
  
  
  var unionWith =
  /*#__PURE__*/
  _curry3(function unionWith(pred, list1, list2) {
    return uniqWith(pred, _concat(list1, list2));
  });
  
  module.exports = unionWith;
  
  /***/ }),
  /* 164 */,
  /* 165 */,
  /* 166 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  function _createPartialApplicator(concat) {
    return _curry2(function (fn, args) {
      return _arity(Math.max(0, fn.length - args.length), function () {
        return fn.apply(this, concat(args, arguments));
      });
    });
  }
  
  module.exports = _createPartialApplicator;
  
  /***/ }),
  /* 167 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var pathOr =
  /*#__PURE__*/
  __webpack_require__(25);
  /**
   * If the given, non-null object has an own property with the specified name,
   * returns the value of that property. Otherwise returns the provided default
   * value.
   *
   * @func
   * @memberOf R
   * @since v0.6.0
   * @category Object
   * @sig a -> String -> Object -> a
   * @param {*} val The default value.
   * @param {String} p The name of the property to return.
   * @param {Object} obj The object to query.
   * @return {*} The value of given property of the supplied object or the default value.
   * @example
   *
   *      const alice = {
   *        name: 'ALICE',
   *        age: 101
   *      };
   *      const favorite = R.prop('favoriteLibrary');
   *      const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');
   *
   *      favorite(alice);  //=> undefined
   *      favoriteWithDefault(alice);  //=> 'Ramda'
   */
  
  
  var propOr =
  /*#__PURE__*/
  _curry3(function propOr(val, p, obj) {
    return pathOr(val, [p], obj);
  });
  
  module.exports = propOr;
  
  /***/ }),
  /* 168 */
  /***/ (function(module) {
  
  "use strict";
  
  const alias = ['stdin', 'stdout', 'stderr'];
  
  const hasAlias = opts => alias.some(x => Boolean(opts[x]));
  
  module.exports = opts => {
  	if (!opts) {
  		return null;
  	}
  
  	if (opts.stdio && hasAlias(opts)) {
  		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${alias.map(x => `\`${x}\``).join(', ')}`);
  	}
  
  	if (typeof opts.stdio === 'string') {
  		return opts.stdio;
  	}
  
  	const stdio = opts.stdio || [];
  
  	if (!Array.isArray(stdio)) {
  		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
  	}
  
  	const result = [];
  	const len = Math.max(stdio.length, alias.length);
  
  	for (let i = 0; i < len; i++) {
  		let value = null;
  
  		if (stdio[i] !== undefined) {
  			value = stdio[i];
  		} else if (opts[alias[i]] !== undefined) {
  			value = opts[alias[i]];
  		}
  
  		result[i] = value;
  	}
  
  	return result;
  };
  
  
  /***/ }),
  /* 169 */,
  /* 170 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  const util = __webpack_require__(343);
  const buildOptions = __webpack_require__(343).buildOptions;
  const xmlNode = __webpack_require__(66);
  const regx =
    '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
    .replace(/NAME/g, util.nameRegexp);
  
  //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
  //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
  
  //polyfill
  if (!Number.parseInt && window.parseInt) {
    Number.parseInt = window.parseInt;
  }
  if (!Number.parseFloat && window.parseFloat) {
    Number.parseFloat = window.parseFloat;
  }
  
  const defaultOptions = {
    attributeNamePrefix: '@_',
    attrNodeName: false,
    textNodeName: '#text',
    ignoreAttributes: true,
    ignoreNameSpace: false,
    allowBooleanAttributes: false, //a tag can have attributes without any value
    //ignoreRootElement : false,
    parseNodeValue: true,
    parseAttributeValue: false,
    arrayMode: false,
    trimValues: true, //Trim string values of tag and attributes
    cdataTagName: false,
    cdataPositionChar: '\\c',
    tagValueProcessor: function(a, tagName) {
      return a;
    },
    attrValueProcessor: function(a, attrName) {
      return a;
    },
    stopNodes: []
    //decodeStrict: false,
  };
  
  exports.defaultOptions = defaultOptions;
  
  const props = [
    'attributeNamePrefix',
    'attrNodeName',
    'textNodeName',
    'ignoreAttributes',
    'ignoreNameSpace',
    'allowBooleanAttributes',
    'parseNodeValue',
    'parseAttributeValue',
    'arrayMode',
    'trimValues',
    'cdataTagName',
    'cdataPositionChar',
    'tagValueProcessor',
    'attrValueProcessor',
    'parseTrueNumberOnly',
    'stopNodes'
  ];
  exports.props = props;
  
  /**
   * Trim -> valueProcessor -> parse value
   * @param {string} tagName
   * @param {string} val
   * @param {object} options
   */
  function processTagValue(tagName, val, options) {
    if (val) {
      if (options.trimValues) {
        val = val.trim();
      }
      val = options.tagValueProcessor(val, tagName);
      val = parseValue(val, options.parseNodeValue, options.parseTrueNumberOnly);
    }
  
    return val;
  }
  
  function resolveNameSpace(tagname, options) {
    if (options.ignoreNameSpace) {
      const tags = tagname.split(':');
      const prefix = tagname.charAt(0) === '/' ? '/' : '';
      if (tags[0] === 'xmlns') {
        return '';
      }
      if (tags.length === 2) {
        tagname = prefix + tags[1];
      }
    }
    return tagname;
  }
  
  function parseValue(val, shouldParse, parseTrueNumberOnly) {
    if (shouldParse && typeof val === 'string') {
      let parsed;
      if (val.trim() === '' || isNaN(val)) {
        parsed = val === 'true' ? true : val === 'false' ? false : val;
      } else {
        if (val.indexOf('0x') !== -1) {
          //support hexa decimal
          parsed = Number.parseInt(val, 16);
        } else if (val.indexOf('.') !== -1) {
          parsed = Number.parseFloat(val);
          val = val.replace(/\.?0+$/, "");
        } else {
          parsed = Number.parseInt(val, 10);
        }
        if (parseTrueNumberOnly) {
          parsed = String(parsed) === val ? parsed : val;
        }
      }
      return parsed;
    } else {
      if (util.isExist(val)) {
        return val;
      } else {
        return '';
      }
    }
  }
  
  //TODO: change regex to capture NS
  //const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm");
  const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])(.*?)\\3)?', 'g');
  
  function buildAttributesMap(attrStr, options) {
    if (!options.ignoreAttributes && typeof attrStr === 'string') {
      attrStr = attrStr.replace(/\r?\n/g, ' ');
      //attrStr = attrStr || attrStr.trim();
  
      const matches = util.getAllMatches(attrStr, attrsRegx);
      const len = matches.length; //don't make it inline
      const attrs = {};
      for (let i = 0; i < len; i++) {
        const attrName = resolveNameSpace(matches[i][1], options);
        if (attrName.length) {
          if (matches[i][4] !== undefined) {
            if (options.trimValues) {
              matches[i][4] = matches[i][4].trim();
            }
            matches[i][4] = options.attrValueProcessor(matches[i][4], attrName);
            attrs[options.attributeNamePrefix + attrName] = parseValue(
              matches[i][4],
              options.parseAttributeValue,
              options.parseTrueNumberOnly
            );
          } else if (options.allowBooleanAttributes) {
            attrs[options.attributeNamePrefix + attrName] = true;
          }
        }
      }
      if (!Object.keys(attrs).length) {
        return;
      }
      if (options.attrNodeName) {
        const attrCollection = {};
        attrCollection[options.attrNodeName] = attrs;
        return attrCollection;
      }
      return attrs;
    }
  }
  
  const getTraversalObj = function(xmlData, options) {
    xmlData = xmlData.replace(/\r\n?/g, "\n");
    options = buildOptions(options, defaultOptions, props);
    const xmlObj = new xmlNode('!xml');
    let currentNode = xmlObj;
    let textData = "";
  
  //function match(xmlData){
    for(let i=0; i< xmlData.length; i++){
      const ch = xmlData[i];
      if(ch === '<'){
        if( xmlData[i+1] === '/') {//Closing Tag
          const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.")
          let tagName = xmlData.substring(i+2,closeIndex).trim();
  
          if(options.ignoreNameSpace){
            const colonIndex = tagName.indexOf(":");
            if(colonIndex !== -1){
              tagName = tagName.substr(colonIndex+1);
            }
          }
  
          /* if (currentNode.parent) {
            currentNode.parent.val = util.getValue(currentNode.parent.val) + '' + processTagValue2(tagName, textData , options);
          } */
          if(currentNode){
            if(currentNode.val){
              currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(tagName, textData , options);
            }else{
              currentNode.val = processTagValue(tagName, textData , options);
            }
          }
  
          if (options.stopNodes.length && options.stopNodes.includes(currentNode.tagname)) {
            currentNode.child = []
            if (currentNode.attrsMap == undefined) { currentNode.attrsMap = {}}
            currentNode.val = xmlData.substr(currentNode.startIndex + 1, i - currentNode.startIndex - 1)
          }
          currentNode = currentNode.parent;
          textData = "";
          i = closeIndex;
        } else if( xmlData[i+1] === '?') {
          i = findClosingIndex(xmlData, "?>", i, "Pi Tag is not closed.")
        } else if(xmlData.substr(i + 1, 3) === '!--') {
          i = findClosingIndex(xmlData, "-->", i, "Comment is not closed.")
        } else if( xmlData.substr(i + 1, 2) === '!D') {
          const closeIndex = findClosingIndex(xmlData, ">", i, "DOCTYPE is not closed.")
          const tagExp = xmlData.substring(i, closeIndex);
          if(tagExp.indexOf("[") >= 0){
            i = xmlData.indexOf("]>", i) + 1;
          }else{
            i = closeIndex;
          }
        }else if(xmlData.substr(i + 1, 2) === '![') {
          const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2
          const tagExp = xmlData.substring(i + 9,closeIndex);
  
          //considerations
          //1. CDATA will always have parent node
          //2. A tag with CDATA is not a leaf node so it's value would be string type.
          if(textData){
            currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(currentNode.tagname, textData , options);
            textData = "";
          }
  
          if (options.cdataTagName) {
            //add cdata node
            const childNode = new xmlNode(options.cdataTagName, currentNode, tagExp);
            currentNode.addChild(childNode);
            //for backtracking
            currentNode.val = util.getValue(currentNode.val) + options.cdataPositionChar;
            //add rest value to parent node
            if (tagExp) {
              childNode.val = tagExp;
            }
          } else {
            currentNode.val = (currentNode.val || '') + (tagExp || '');
          }
  
          i = closeIndex + 2;
        }else {//Opening tag
          const result = closingIndexForOpeningTag(xmlData, i+1)
          let tagExp = result.data;
          const closeIndex = result.index;
          const separatorIndex = tagExp.indexOf(" ");
          let tagName = tagExp;
          let shouldBuildAttributesMap = true;
          if(separatorIndex !== -1){
            tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
            tagExp = tagExp.substr(separatorIndex + 1);
          }
  
          if(options.ignoreNameSpace){
            const colonIndex = tagName.indexOf(":");
            if(colonIndex !== -1){
              tagName = tagName.substr(colonIndex+1);
              shouldBuildAttributesMap = tagName !== result.data.substr(colonIndex + 1);
            }
          }
  
          //save text to parent node
          if (currentNode && textData) {
            if(currentNode.tagname !== '!xml'){
              currentNode.val = util.getValue(currentNode.val) + '' + processTagValue( currentNode.tagname, textData, options);
            }
          }
  
          if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){//selfClosing tag
  
            if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
              tagName = tagName.substr(0, tagName.length - 1);
              tagExp = tagName;
            }else{
              tagExp = tagExp.substr(0, tagExp.length - 1);
            }
  
            const childNode = new xmlNode(tagName, currentNode, '');
            if(tagName !== tagExp){
              childNode.attrsMap = buildAttributesMap(tagExp, options);
            }
            currentNode.addChild(childNode);
          }else{//opening tag
  
            const childNode = new xmlNode( tagName, currentNode );
            if (options.stopNodes.length && options.stopNodes.includes(childNode.tagname)) {
              childNode.startIndex=closeIndex;
            }
            if(tagName !== tagExp && shouldBuildAttributesMap){
              childNode.attrsMap = buildAttributesMap(tagExp, options);
            }
            currentNode.addChild(childNode);
            currentNode = childNode;
          }
          textData = "";
          i = closeIndex;
        }
      }else{
        textData += xmlData[i];
      }
    }
    return xmlObj;
  }
  
  function closingIndexForOpeningTag(data, i){
    let attrBoundary;
    let tagExp = "";
    for (let index = i; index < data.length; index++) {
      let ch = data[index];
      if (attrBoundary) {
          if (ch === attrBoundary) attrBoundary = "";//reset
      } else if (ch === '"' || ch === "'") {
          attrBoundary = ch;
      } else if (ch === '>') {
          return {
            data: tagExp,
            index: index
          }
      } else if (ch === '\t') {
        ch = " "
      }
      tagExp += ch;
    }
  }
  
  function findClosingIndex(xmlData, str, i, errMsg){
    const closingIndex = xmlData.indexOf(str, i);
    if(closingIndex === -1){
      throw new Error(errMsg)
    }else{
      return closingIndex + str.length - 1;
    }
  }
  
  exports.getTraversalObj = getTraversalObj;
  
  
  /***/ }),
  /* 171 */,
  /* 172 */,
  /* 173 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var drop =
  /*#__PURE__*/
  __webpack_require__(12);
  /**
   * Returns a new list containing the last `n` elements of the given list.
   * If `n > list.length`, returns a list of `list.length` elements.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig Number -> [a] -> [a]
   * @sig Number -> String -> String
   * @param {Number} n The number of elements to return.
   * @param {Array} xs The collection to consider.
   * @return {Array}
   * @see R.dropLast
   * @example
   *
   *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']
   *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
   *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
   *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
   *      R.takeLast(3, 'ramda');               //=> 'mda'
   */
  
  
  var takeLast =
  /*#__PURE__*/
  _curry2(function takeLast(n, xs) {
    return drop(n >= 0 ? xs.length - n : 0, xs);
  });
  
  module.exports = takeLast;
  
  /***/ }),
  /* 174 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Context = void 0;
  const fs_1 = __webpack_require__(747);
  const os_1 = __webpack_require__(87);
  class Context {
      /**
       * Hydrate the context from the environment
       */
      constructor() {
          this.payload = {};
          if (process.env.GITHUB_EVENT_PATH) {
              if (fs_1.existsSync(process.env.GITHUB_EVENT_PATH)) {
                  this.payload = JSON.parse(fs_1.readFileSync(process.env.GITHUB_EVENT_PATH, { encoding: 'utf8' }));
              }
              else {
                  const path = process.env.GITHUB_EVENT_PATH;
                  process.stdout.write(`GITHUB_EVENT_PATH ${path} does not exist${os_1.EOL}`);
              }
          }
          this.eventName = process.env.GITHUB_EVENT_NAME;
          this.sha = process.env.GITHUB_SHA;
          this.ref = process.env.GITHUB_REF;
          this.workflow = process.env.GITHUB_WORKFLOW;
          this.action = process.env.GITHUB_ACTION;
          this.actor = process.env.GITHUB_ACTOR;
      }
      get issue() {
          const payload = this.payload;
          return Object.assign(Object.assign({}, this.repo), { number: (payload.issue || payload.pull_request || payload).number });
      }
      get repo() {
          if (process.env.GITHUB_REPOSITORY) {
              const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
              return { owner, repo };
          }
          if (this.payload.repository) {
              return {
                  owner: this.payload.repository.owner.login,
                  repo: this.payload.repository.name
              };
          }
          throw new Error("context.repo requires a GITHUB_REPOSITORY environment variable like 'owner/repo'");
      }
  }
  exports.Context = Context;
  //# sourceMappingURL=context.js.map
  
  /***/ }),
  /* 175 */,
  /* 176 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _clone =
  /*#__PURE__*/
  __webpack_require__(794);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Creates a deep copy of the value which may contain (nested) `Array`s and
   * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are
   * assigned by reference rather than copied
   *
   * Dispatches to a `clone` method if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig {*} -> {*}
   * @param {*} value The object or array to clone
   * @return {*} A deeply cloned copy of `val`
   * @example
   *
   *      const objects = [{}, {}, {}];
   *      const objectsClone = R.clone(objects);
   *      objects === objectsClone; //=> false
   *      objects[0] === objectsClone[0]; //=> false
   */
  
  
  var clone =
  /*#__PURE__*/
  _curry1(function clone(value) {
    return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);
  });
  
  module.exports = clone;
  
  /***/ }),
  /* 177 */,
  /* 178 */,
  /* 179 */,
  /* 180 */,
  /* 181 */,
  /* 182 */,
  /* 183 */,
  /* 184 */,
  /* 185 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var apply =
  /*#__PURE__*/
  __webpack_require__(422);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var max =
  /*#__PURE__*/
  __webpack_require__(793);
  
  var pluck =
  /*#__PURE__*/
  __webpack_require__(819);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  
  var values =
  /*#__PURE__*/
  __webpack_require__(256); // Use custom mapValues function to avoid issues with specs that include a "map" key and R.map
  // delegating calls to .map
  
  
  function mapValues(fn, obj) {
    return keys(obj).reduce(function (acc, key) {
      acc[key] = fn(obj[key]);
      return acc;
    }, {});
  }
  /**
   * Given a spec object recursively mapping properties to functions, creates a
   * function producing an object of the same structure, by mapping each property
   * to the result of calling its associated function with the supplied arguments.
   *
   * @func
   * @memberOf R
   * @since v0.20.0
   * @category Function
   * @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v})
   * @param {Object} spec an object recursively mapping properties to functions for
   *        producing the values for these properties.
   * @return {Function} A function that returns an object of the same structure
   * as `spec', with each property set to the value returned by calling its
   * associated function with the supplied arguments.
   * @see R.converge, R.juxt
   * @example
   *
   *      const getMetrics = R.applySpec({
   *        sum: R.add,
   *        nested: { mul: R.multiply }
   *      });
   *      getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }
   * @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } }
   */
  
  
  var applySpec =
  /*#__PURE__*/
  _curry1(function applySpec(spec) {
    spec = mapValues(function (v) {
      return typeof v == 'function' ? v : applySpec(v);
    }, spec);
    return curryN(reduce(max, 0, pluck('length', values(spec))), function () {
      var args = arguments;
      return mapValues(function (f) {
        return apply(f, args);
      }, spec);
    });
  });
  
  module.exports = applySpec;
  
  /***/ }),
  /* 186 */,
  /* 187 */,
  /* 188 */,
  /* 189 */,
  /* 190 */,
  /* 191 */,
  /* 192 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var request = __webpack_require__(753);
  var universalUserAgent = __webpack_require__(789);
  
  const VERSION = "4.6.4";
  
  class GraphqlError extends Error {
    constructor(request, response) {
      const message = response.data.errors[0].message;
      super(message);
      Object.assign(this, response.data);
      Object.assign(this, {
        headers: response.headers
      });
      this.name = "GraphqlError";
      this.request = request; // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
    }
  
  }
  
  const NON_VARIABLE_OPTIONS = ["method", "baseUrl", "url", "headers", "request", "query", "mediaType"];
  const FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
  const GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
  function graphql(request, query, options) {
    if (options) {
      if (typeof query === "string" && "query" in options) {
        return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
      }
  
      for (const key in options) {
        if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key)) continue;
        return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
      }
    }
  
    const parsedOptions = typeof query === "string" ? Object.assign({
      query
    }, options) : query;
    const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
      if (NON_VARIABLE_OPTIONS.includes(key)) {
        result[key] = parsedOptions[key];
        return result;
      }
  
      if (!result.variables) {
        result.variables = {};
      }
  
      result.variables[key] = parsedOptions[key];
      return result;
    }, {}); // workaround for GitHub Enterprise baseUrl set with /api/v3 suffix
    // https://github.com/octokit/auth-app.js/issues/111#issuecomment-657610451
  
    const baseUrl = parsedOptions.baseUrl || request.endpoint.DEFAULTS.baseUrl;
  
    if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
      requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
    }
  
    return request(requestOptions).then(response => {
      if (response.data.errors) {
        const headers = {};
  
        for (const key of Object.keys(response.headers)) {
          headers[key] = response.headers[key];
        }
  
        throw new GraphqlError(requestOptions, {
          headers,
          data: response.data
        });
      }
  
      return response.data.data;
    });
  }
  
  function withDefaults(request$1, newDefaults) {
    const newRequest = request$1.defaults(newDefaults);
  
    const newApi = (query, options) => {
      return graphql(newRequest, query, options);
    };
  
    return Object.assign(newApi, {
      defaults: withDefaults.bind(null, newRequest),
      endpoint: request.request.endpoint
    });
  }
  
  const graphql$1 = withDefaults(request.request, {
    headers: {
      "user-agent": `octokit-graphql.js/${VERSION} ${universalUserAgent.getUserAgent()}`
    },
    method: "POST",
    url: "/graphql"
  });
  function withCustomRequest(customRequest) {
    return withDefaults(customRequest, {
      method: "POST",
      url: "/graphql"
    });
  }
  
  exports.graphql = graphql$1;
  exports.withCustomRequest = withCustomRequest;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 193 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _checkForMethod =
  /*#__PURE__*/
  __webpack_require__(417);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns all but the first element of the given list or string (or object
   * with a `tail` method).
   *
   * Dispatches to the `slice` method of the first argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [a]
   * @sig String -> String
   * @param {*} list
   * @return {*}
   * @see R.head, R.init, R.last
   * @example
   *
   *      R.tail([1, 2, 3]);  //=> [2, 3]
   *      R.tail([1, 2]);     //=> [2]
   *      R.tail([1]);        //=> []
   *      R.tail([]);         //=> []
   *
   *      R.tail('abc');  //=> 'bc'
   *      R.tail('ab');   //=> 'b'
   *      R.tail('a');    //=> ''
   *      R.tail('');     //=> ''
   */
  
  
  var tail =
  /*#__PURE__*/
  _curry1(
  /*#__PURE__*/
  _checkForMethod('tail',
  /*#__PURE__*/
  slice(1, Infinity)));
  
  module.exports = tail;
  
  /***/ }),
  /* 194 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var _isInteger =
  /*#__PURE__*/
  __webpack_require__(802);
  
  var assoc =
  /*#__PURE__*/
  __webpack_require__(414);
  
  var isNil =
  /*#__PURE__*/
  __webpack_require__(317);
  /**
   * Makes a shallow clone of an object, setting or overriding the nodes required
   * to create the given path, and placing the specific value at the tail end of
   * that path. Note that this copies and flattens prototype properties onto the
   * new object as well. All non-primitive properties are copied by reference.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig [Idx] -> a -> {a} -> {a}
   * @param {Array} path the path to set
   * @param {*} val The new value
   * @param {Object} obj The object to clone
   * @return {Object} A new object equivalent to the original except along the specified path.
   * @see R.dissocPath
   * @example
   *
   *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
   *
   *      // Any missing or non-object keys in path will be overridden
   *      R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}
   */
  
  
  var assocPath =
  /*#__PURE__*/
  _curry3(function assocPath(path, val, obj) {
    if (path.length === 0) {
      return val;
    }
  
    var idx = path[0];
  
    if (path.length > 1) {
      var nextObj = !isNil(obj) && _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};
      val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);
    }
  
    if (_isInteger(idx) && _isArray(obj)) {
      var arr = [].concat(obj);
      arr[idx] = val;
      return arr;
    } else {
      return assoc(idx, val, obj);
    }
  });
  
  module.exports = assocPath;
  
  /***/ }),
  /* 195 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Builds a list from a seed value. Accepts an iterator function, which returns
   * either false to stop iteration or an array of length 2 containing the value
   * to add to the resulting list and the seed to be used in the next call to the
   * iterator function.
   *
   * The iterator function receives one argument: *(seed)*.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category List
   * @sig (a -> [b]) -> * -> [b]
   * @param {Function} fn The iterator function. receives one argument, `seed`, and returns
   *        either false to quit iteration or an array of length two to proceed. The element
   *        at index 0 of this array will be added to the resulting array, and the element
   *        at index 1 will be passed to the next call to `fn`.
   * @param {*} seed The seed value.
   * @return {Array} The final list.
   * @example
   *
   *      const f = n => n > 50 ? false : [-n, n + 10];
   *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
   * @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...]
   */
  
  
  var unfold =
  /*#__PURE__*/
  _curry2(function unfold(fn, seed) {
    var pair = fn(seed);
    var result = [];
  
    while (pair && pair.length) {
      result[result.length] = pair[0];
      pair = fn(pair[1]);
    }
  
    return result;
  });
  
  module.exports = unfold;
  
  /***/ }),
  /* 196 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * Returns a function that when supplied an object returns the indicated
   * property of that object, if it exists.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig Idx -> {s: a} -> a | Undefined
   * @param {String|Number} p The property name or array index
   * @param {Object} obj The object to query
   * @return {*} The value at `obj.p`.
   * @see R.path, R.nth
   * @example
   *
   *      R.prop('x', {x: 100}); //=> 100
   *      R.prop('x', {}); //=> undefined
   *      R.prop(0, [100]); //=> 100
   *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4
   */
  
  
  var prop =
  /*#__PURE__*/
  _curry2(function prop(p, obj) {
    return path([p], obj);
  });
  
  module.exports = prop;
  
  /***/ }),
  /* 197 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = isexe
  isexe.sync = sync
  
  var fs = __webpack_require__(747)
  
  function isexe (path, options, cb) {
    fs.stat(path, function (er, stat) {
      cb(er, er ? false : checkStat(stat, options))
    })
  }
  
  function sync (path, options) {
    return checkStat(fs.statSync(path), options)
  }
  
  function checkStat (stat, options) {
    return stat.isFile() && checkMode(stat, options)
  }
  
  function checkMode (stat, options) {
    var mod = stat.mode
    var uid = stat.uid
    var gid = stat.gid
  
    var myUid = options.uid !== undefined ?
      options.uid : process.getuid && process.getuid()
    var myGid = options.gid !== undefined ?
      options.gid : process.getgid && process.getgid()
  
    var u = parseInt('100', 8)
    var g = parseInt('010', 8)
    var o = parseInt('001', 8)
    var ug = u | g
  
    var ret = (mod & o) ||
      (mod & g) && gid === myGid ||
      (mod & u) && uid === myUid ||
      (mod & ug) && myUid === 0
  
    return ret
  }
  
  
  /***/ }),
  /* 198 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const core = __importStar(__webpack_require__(470));
  const search_1 = __webpack_require__(589);
  const constants_1 = __webpack_require__(32);
  const annotations_1 = __webpack_require__(147);
  const ramda_1 = __webpack_require__(61);
  const github_1 = __webpack_require__(824);
  const github_2 = __webpack_require__(469);
  const MAX_ANNOTATIONS_PER_REQUEST = 50;
  function run() {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              const path = core.getInput(constants_1.Inputs.Path, { required: true });
              const name = core.getInput(constants_1.Inputs.Name);
              const title = core.getInput(constants_1.Inputs.Title);
              const searchResult = yield search_1.findResults(path);
              if (searchResult.filesToUpload.length === 0) {
                  core.warning(`No files were found for the provided path: ${path}. No results will be uploaded.`);
              }
              else {
                  core.info(`With the provided path, there will be ${searchResult.filesToUpload.length} results uploaded`);
                  core.debug(`Root artifact directory is ${searchResult.rootDirectory}`);
                  const annotations = ramda_1.chain(annotations_1.annotationsForPath, searchResult.filesToUpload);
                  core.debug(`Grouping ${annotations.length} annotations into chunks of ${MAX_ANNOTATIONS_PER_REQUEST}`);
                  const groupedAnnotations = annotations.length > MAX_ANNOTATIONS_PER_REQUEST
                      ? ramda_1.splitEvery(MAX_ANNOTATIONS_PER_REQUEST, annotations)
                      : [annotations];
                  core.debug(`Created ${groupedAnnotations.length} buckets`);
                  const conclusion = getConclusion(annotations);
                  for (const annotationSet of groupedAnnotations) {
                      yield createCheck(name, title, annotationSet, annotations.length, conclusion);
                  }
              }
          }
          catch (error) {
              core.setFailed(error);
          }
      });
  }
  function getConclusion(annotations) {
      if (annotations.length === 0) {
          return 'success';
      }
      const annotationsByLevel = ramda_1.groupBy(a => a.annotation_level, annotations);
      if (annotationsByLevel[github_1.AnnotationLevel.failure] &&
          annotationsByLevel[github_1.AnnotationLevel.failure].length) {
          return 'failure';
      }
      else if (annotationsByLevel[github_1.AnnotationLevel.warning] &&
          annotationsByLevel[github_1.AnnotationLevel.warning].length) {
          return 'neutral';
      }
      return 'success';
  }
  function createCheck(name, title, annotations, numErrors, conclusion) {
      return __awaiter(this, void 0, void 0, function* () {
          core.info(`Uploading ${annotations.length} / ${numErrors} annotations to GitHub as ${name} with conclusion ${conclusion}`);
          const octokit = github_2.getOctokit(core.getInput(constants_1.Inputs.Token));
          let sha = github_2.context.sha;
          if (github_2.context.payload.pull_request) {
              sha = github_2.context.payload.pull_request.head.sha;
          }
          const req = Object.assign(Object.assign({}, github_2.context.repo), { ref: sha });
          const res = yield octokit.checks.listForRef(req);
          var res1 = JSON.stringify(res, null, 4);
          core.debug(`Current Response: '${res1}'`);
          const existingCheckRun = res.data.check_runs.find(check => check.name === name);
          //if (!existingCheckRun) {
          const createRequest = Object.assign(Object.assign({}, github_2.context.repo), { head_sha: sha, conclusion,
              name, status: 'completed', output: {
                  title,
                  summary: `${numErrors} violation(s) found`,
                  annotations
              } });
          core.debug(`Creating new check`);
          yield octokit.checks.create(createRequest);
          core.debug(`Created new check`);
          // } else {
          //   const check_run_id = existingCheckRun.id
          //   const update_req = {
          //     ...context.repo,
          //     conclusion,
          //     check_run_id,
          //     status: <const>'completed',
          //     output: {
          //       title,
          //       summary: `${numErrors} violation(s) found`,
          //       annotations
          //     }
          //   }
          //   core.debug(`Updating existing check`)
          //   await octokit.checks.update(update_req)
          //   core.debug(`Updated existing check`)
          // }
      });
  }
  run();
  
  
  /***/ }),
  /* 199 */,
  /* 200 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  //parse Empty Node as self closing node
  const buildOptions = __webpack_require__(343).buildOptions;
  
  const defaultOptions = {
    attributeNamePrefix: '@_',
    attrNodeName: false,
    textNodeName: '#text',
    ignoreAttributes: true,
    cdataTagName: false,
    cdataPositionChar: '\\c',
    format: false,
    indentBy: '  ',
    supressEmptyNode: false,
    tagValueProcessor: function(a) {
      return a;
    },
    attrValueProcessor: function(a) {
      return a;
    },
  };
  
  const props = [
    'attributeNamePrefix',
    'attrNodeName',
    'textNodeName',
    'ignoreAttributes',
    'cdataTagName',
    'cdataPositionChar',
    'format',
    'indentBy',
    'supressEmptyNode',
    'tagValueProcessor',
    'attrValueProcessor',
  ];
  
  function Parser(options) {
    this.options = buildOptions(options, defaultOptions, props);
    if (this.options.ignoreAttributes || this.options.attrNodeName) {
      this.isAttribute = function(/*a*/) {
        return false;
      };
    } else {
      this.attrPrefixLen = this.options.attributeNamePrefix.length;
      this.isAttribute = isAttribute;
    }
    if (this.options.cdataTagName) {
      this.isCDATA = isCDATA;
    } else {
      this.isCDATA = function(/*a*/) {
        return false;
      };
    }
    this.replaceCDATAstr = replaceCDATAstr;
    this.replaceCDATAarr = replaceCDATAarr;
  
    if (this.options.format) {
      this.indentate = indentate;
      this.tagEndChar = '>\n';
      this.newLine = '\n';
    } else {
      this.indentate = function() {
        return '';
      };
      this.tagEndChar = '>';
      this.newLine = '';
    }
  
    if (this.options.supressEmptyNode) {
      this.buildTextNode = buildEmptyTextNode;
      this.buildObjNode = buildEmptyObjNode;
    } else {
      this.buildTextNode = buildTextValNode;
      this.buildObjNode = buildObjectNode;
    }
  
    this.buildTextValNode = buildTextValNode;
    this.buildObjectNode = buildObjectNode;
  }
  
  Parser.prototype.parse = function(jObj) {
    return this.j2x(jObj, 0).val;
  };
  
  Parser.prototype.j2x = function(jObj, level) {
    let attrStr = '';
    let val = '';
    const keys = Object.keys(jObj);
    const len = keys.length;
    for (let i = 0; i < len; i++) {
      const key = keys[i];
      if (typeof jObj[key] === 'undefined') {
        // supress undefined node
      } else if (jObj[key] === null) {
        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
      } else if (jObj[key] instanceof Date) {
        val += this.buildTextNode(jObj[key], key, '', level);
      } else if (typeof jObj[key] !== 'object') {
        //premitive type
        const attr = this.isAttribute(key);
        if (attr) {
          attrStr += ' ' + attr + '="' + this.options.attrValueProcessor('' + jObj[key]) + '"';
        } else if (this.isCDATA(key)) {
          if (jObj[this.options.textNodeName]) {
            val += this.replaceCDATAstr(jObj[this.options.textNodeName], jObj[key]);
          } else {
            val += this.replaceCDATAstr('', jObj[key]);
          }
        } else {
          //tag value
          if (key === this.options.textNodeName) {
            if (jObj[this.options.cdataTagName]) {
              //value will added while processing cdata
            } else {
              val += this.options.tagValueProcessor('' + jObj[key]);
            }
          } else {
            val += this.buildTextNode(jObj[key], key, '', level);
          }
        }
      } else if (Array.isArray(jObj[key])) {
        //repeated nodes
        if (this.isCDATA(key)) {
          val += this.indentate(level);
          if (jObj[this.options.textNodeName]) {
            val += this.replaceCDATAarr(jObj[this.options.textNodeName], jObj[key]);
          } else {
            val += this.replaceCDATAarr('', jObj[key]);
          }
        } else {
          //nested nodes
          const arrLen = jObj[key].length;
          for (let j = 0; j < arrLen; j++) {
            const item = jObj[key][j];
            if (typeof item === 'undefined') {
              // supress undefined node
            } else if (item === null) {
              val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
            } else if (typeof item === 'object') {
              const result = this.j2x(item, level + 1);
              val += this.buildObjNode(result.val, key, result.attrStr, level);
            } else {
              val += this.buildTextNode(item, key, '', level);
            }
          }
        }
      } else {
        //nested node
        if (this.options.attrNodeName && key === this.options.attrNodeName) {
          const Ks = Object.keys(jObj[key]);
          const L = Ks.length;
          for (let j = 0; j < L; j++) {
            attrStr += ' ' + Ks[j] + '="' + this.options.attrValueProcessor('' + jObj[key][Ks[j]]) + '"';
          }
        } else {
          const result = this.j2x(jObj[key], level + 1);
          val += this.buildObjNode(result.val, key, result.attrStr, level);
        }
      }
    }
    return {attrStr: attrStr, val: val};
  };
  
  function replaceCDATAstr(str, cdata) {
    str = this.options.tagValueProcessor('' + str);
    if (this.options.cdataPositionChar === '' || str === '') {
      return str + '<![CDATA[' + cdata + ']]' + this.tagEndChar;
    } else {
      return str.replace(this.options.cdataPositionChar, '<![CDATA[' + cdata + ']]' + this.tagEndChar);
    }
  }
  
  function replaceCDATAarr(str, cdata) {
    str = this.options.tagValueProcessor('' + str);
    if (this.options.cdataPositionChar === '' || str === '') {
      return str + '<![CDATA[' + cdata.join(']]><![CDATA[') + ']]' + this.tagEndChar;
    } else {
      for (let v in cdata) {
        str = str.replace(this.options.cdataPositionChar, '<![CDATA[' + cdata[v] + ']]>');
      }
      return str + this.newLine;
    }
  }
  
  function buildObjectNode(val, key, attrStr, level) {
    if (attrStr && !val.includes('<')) {
      return (
        this.indentate(level) +
        '<' +
        key +
        attrStr +
        '>' +
        val +
        //+ this.newLine
        // + this.indentate(level)
        '</' +
        key +
        this.tagEndChar
      );
    } else {
      return (
        this.indentate(level) +
        '<' +
        key +
        attrStr +
        this.tagEndChar +
        val +
        //+ this.newLine
        this.indentate(level) +
        '</' +
        key +
        this.tagEndChar
      );
    }
  }
  
  function buildEmptyObjNode(val, key, attrStr, level) {
    if (val !== '') {
      return this.buildObjectNode(val, key, attrStr, level);
    } else {
      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
      //+ this.newLine
    }
  }
  
  function buildTextValNode(val, key, attrStr, level) {
    return (
      this.indentate(level) +
      '<' +
      key +
      attrStr +
      '>' +
      this.options.tagValueProcessor(val) +
      '</' +
      key +
      this.tagEndChar
    );
  }
  
  function buildEmptyTextNode(val, key, attrStr, level) {
    if (val !== '') {
      return this.buildTextValNode(val, key, attrStr, level);
    } else {
      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
    }
  }
  
  function indentate(level) {
    return this.options.indentBy.repeat(level);
  }
  
  function isAttribute(name /*, options*/) {
    if (name.startsWith(this.options.attributeNamePrefix)) {
      return name.substr(this.attrPrefixLen);
    } else {
      return false;
    }
  }
  
  function isCDATA(name) {
    return name === this.options.cdataTagName;
  }
  
  //formatting
  //indentation
  //\n after each closing or self closing tag
  
  module.exports = Parser;
  
  
  /***/ }),
  /* 201 */,
  /* 202 */,
  /* 203 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _map =
  /*#__PURE__*/
  __webpack_require__(626);
  
  var _quote =
  /*#__PURE__*/
  __webpack_require__(57);
  
  var _toISOString =
  /*#__PURE__*/
  __webpack_require__(291);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  
  var reject =
  /*#__PURE__*/
  __webpack_require__(92);
  
  function _toString(x, seen) {
    var recur = function recur(y) {
      var xs = seen.concat([x]);
      return _includes(y, xs) ? '<Circular>' : _toString(y, xs);
    }; //  mapPairs :: (Object, [String]) -> [String]
  
  
    var mapPairs = function (obj, keys) {
      return _map(function (k) {
        return _quote(k) + ': ' + recur(obj[k]);
      }, keys.slice().sort());
    };
  
    switch (Object.prototype.toString.call(x)) {
      case '[object Arguments]':
        return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
  
      case '[object Array]':
        return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {
          return /^\d+$/.test(k);
        }, keys(x)))).join(', ') + ']';
  
      case '[object Boolean]':
        return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
  
      case '[object Date]':
        return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
  
      case '[object Null]':
        return 'null';
  
      case '[object Number]':
        return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);
  
      case '[object String]':
        return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);
  
      case '[object Undefined]':
        return 'undefined';
  
      default:
        if (typeof x.toString === 'function') {
          var repr = x.toString();
  
          if (repr !== '[object Object]') {
            return repr;
          }
        }
  
        return '{' + mapPairs(x, keys(x)).join(', ') + '}';
    }
  }
  
  module.exports = _toString;
  
  /***/ }),
  /* 204 */,
  /* 205 */,
  /* 206 */,
  /* 207 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  const util = __webpack_require__(343);
  const buildOptions = __webpack_require__(343).buildOptions;
  const x2j = __webpack_require__(170);
  
  //TODO: do it later
  const convertToJsonString = function(node, options) {
    options = buildOptions(options, x2j.defaultOptions, x2j.props);
  
    options.indentBy = options.indentBy || '';
    return _cToJsonStr(node, options, 0);
  };
  
  const _cToJsonStr = function(node, options, level) {
    let jObj = '{';
  
    //traver through all the children
    const keys = Object.keys(node.child);
  
    for (let index = 0; index < keys.length; index++) {
      var tagname = keys[index];
      if (node.child[tagname] && node.child[tagname].length > 1) {
        jObj += '"' + tagname + '" : [ ';
        for (var tag in node.child[tagname]) {
          jObj += _cToJsonStr(node.child[tagname][tag], options) + ' , ';
        }
        jObj = jObj.substr(0, jObj.length - 1) + ' ] '; //remove extra comma in last
      } else {
        jObj += '"' + tagname + '" : ' + _cToJsonStr(node.child[tagname][0], options) + ' ,';
      }
    }
    util.merge(jObj, node.attrsMap);
    //add attrsMap as new children
    if (util.isEmptyObject(jObj)) {
      return util.isExist(node.val) ? node.val : '';
    } else {
      if (util.isExist(node.val)) {
        if (!(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) {
          jObj += '"' + options.textNodeName + '" : ' + stringval(node.val);
        }
      }
    }
    //add value
    if (jObj[jObj.length - 1] === ',') {
      jObj = jObj.substr(0, jObj.length - 2);
    }
    return jObj + '}';
  };
  
  function stringval(v) {
    if (v === true || v === false || !isNaN(v)) {
      return v;
    } else {
      return '"' + v + '"';
    }
  }
  
  function indentate(options, level) {
    return options.indentBy.repeat(level);
  }
  
  exports.convertToJsonString = convertToJsonString;
  
  
  /***/ }),
  /* 208 */,
  /* 209 */,
  /* 210 */,
  /* 211 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectIs =
  /*#__PURE__*/
  __webpack_require__(268);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns true if its arguments are identical, false otherwise. Values are
   * identical if they reference the same memory. `NaN` is identical to `NaN`;
   * `0` and `-0` are not identical.
   *
   * Note this is merely a curried version of ES6 `Object.is`.
   *
   * @func
   * @memberOf R
   * @since v0.15.0
   * @category Relation
   * @sig a -> a -> Boolean
   * @param {*} a
   * @param {*} b
   * @return {Boolean}
   * @example
   *
   *      const o = {};
   *      R.identical(o, o); //=> true
   *      R.identical(1, 1); //=> true
   *      R.identical(1, '1'); //=> false
   *      R.identical([], []); //=> false
   *      R.identical(0, -0); //=> false
   *      R.identical(NaN, NaN); //=> true
   */
  
  
  var identical =
  /*#__PURE__*/
  _curry2(_objectIs);
  
  module.exports = identical;
  
  /***/ }),
  /* 212 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the first argument is less than or equal to the second;
   * `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> Boolean
   * @param {Number} a
   * @param {Number} b
   * @return {Boolean}
   * @see R.gte
   * @example
   *
   *      R.lte(2, 1); //=> false
   *      R.lte(2, 2); //=> true
   *      R.lte(2, 3); //=> true
   *      R.lte('a', 'z'); //=> true
   *      R.lte('z', 'a'); //=> false
   */
  
  
  var lte =
  /*#__PURE__*/
  _curry2(function lte(a, b) {
    return a <= b;
  });
  
  module.exports = lte;
  
  /***/ }),
  /* 213 */,
  /* 214 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var always =
  /*#__PURE__*/
  __webpack_require__(657);
  
  var over =
  /*#__PURE__*/
  __webpack_require__(97);
  /**
   * Returns the result of "setting" the portion of the given data structure
   * focused by the given lens to the given value.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig Lens s a -> a -> s -> s
   * @param {Lens} lens
   * @param {*} v
   * @param {*} x
   * @return {*}
   * @see R.prop, R.lensIndex, R.lensProp
   * @example
   *
   *      const xLens = R.lensProp('x');
   *
   *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}
   *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}
   */
  
  
  var set =
  /*#__PURE__*/
  _curry3(function set(lens, v, x) {
    return over(lens, always(v), x);
  });
  
  module.exports = set;
  
  /***/ }),
  /* 215 */,
  /* 216 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _indexOf =
  /*#__PURE__*/
  __webpack_require__(627);
  
  function _includes(a, list) {
    return _indexOf(list, a, 0) >= 0;
  }
  
  module.exports = _includes;
  
  /***/ }),
  /* 217 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const http = __webpack_require__(605);
  const https = __webpack_require__(34);
  const pm = __webpack_require__(950);
  let tunnel;
  var HttpCodes;
  (function (HttpCodes) {
      HttpCodes[HttpCodes["OK"] = 200] = "OK";
      HttpCodes[HttpCodes["MultipleChoices"] = 300] = "MultipleChoices";
      HttpCodes[HttpCodes["MovedPermanently"] = 301] = "MovedPermanently";
      HttpCodes[HttpCodes["ResourceMoved"] = 302] = "ResourceMoved";
      HttpCodes[HttpCodes["SeeOther"] = 303] = "SeeOther";
      HttpCodes[HttpCodes["NotModified"] = 304] = "NotModified";
      HttpCodes[HttpCodes["UseProxy"] = 305] = "UseProxy";
      HttpCodes[HttpCodes["SwitchProxy"] = 306] = "SwitchProxy";
      HttpCodes[HttpCodes["TemporaryRedirect"] = 307] = "TemporaryRedirect";
      HttpCodes[HttpCodes["PermanentRedirect"] = 308] = "PermanentRedirect";
      HttpCodes[HttpCodes["BadRequest"] = 400] = "BadRequest";
      HttpCodes[HttpCodes["Unauthorized"] = 401] = "Unauthorized";
      HttpCodes[HttpCodes["PaymentRequired"] = 402] = "PaymentRequired";
      HttpCodes[HttpCodes["Forbidden"] = 403] = "Forbidden";
      HttpCodes[HttpCodes["NotFound"] = 404] = "NotFound";
      HttpCodes[HttpCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
      HttpCodes[HttpCodes["NotAcceptable"] = 406] = "NotAcceptable";
      HttpCodes[HttpCodes["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
      HttpCodes[HttpCodes["RequestTimeout"] = 408] = "RequestTimeout";
      HttpCodes[HttpCodes["Conflict"] = 409] = "Conflict";
      HttpCodes[HttpCodes["Gone"] = 410] = "Gone";
      HttpCodes[HttpCodes["TooManyRequests"] = 429] = "TooManyRequests";
      HttpCodes[HttpCodes["InternalServerError"] = 500] = "InternalServerError";
      HttpCodes[HttpCodes["NotImplemented"] = 501] = "NotImplemented";
      HttpCodes[HttpCodes["BadGateway"] = 502] = "BadGateway";
      HttpCodes[HttpCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
      HttpCodes[HttpCodes["GatewayTimeout"] = 504] = "GatewayTimeout";
  })(HttpCodes = exports.HttpCodes || (exports.HttpCodes = {}));
  var Headers;
  (function (Headers) {
      Headers["Accept"] = "accept";
      Headers["ContentType"] = "content-type";
  })(Headers = exports.Headers || (exports.Headers = {}));
  var MediaTypes;
  (function (MediaTypes) {
      MediaTypes["ApplicationJson"] = "application/json";
  })(MediaTypes = exports.MediaTypes || (exports.MediaTypes = {}));
  /**
   * Returns the proxy URL, depending upon the supplied url and proxy environment variables.
   * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
   */
  function getProxyUrl(serverUrl) {
      let proxyUrl = pm.getProxyUrl(new URL(serverUrl));
      return proxyUrl ? proxyUrl.href : '';
  }
  exports.getProxyUrl = getProxyUrl;
  const HttpRedirectCodes = [
      HttpCodes.MovedPermanently,
      HttpCodes.ResourceMoved,
      HttpCodes.SeeOther,
      HttpCodes.TemporaryRedirect,
      HttpCodes.PermanentRedirect
  ];
  const HttpResponseRetryCodes = [
      HttpCodes.BadGateway,
      HttpCodes.ServiceUnavailable,
      HttpCodes.GatewayTimeout
  ];
  const RetryableHttpVerbs = ['OPTIONS', 'GET', 'DELETE', 'HEAD'];
  const ExponentialBackoffCeiling = 10;
  const ExponentialBackoffTimeSlice = 5;
  class HttpClientError extends Error {
      constructor(message, statusCode) {
          super(message);
          this.name = 'HttpClientError';
          this.statusCode = statusCode;
          Object.setPrototypeOf(this, HttpClientError.prototype);
      }
  }
  exports.HttpClientError = HttpClientError;
  class HttpClientResponse {
      constructor(message) {
          this.message = message;
      }
      readBody() {
          return new Promise(async (resolve, reject) => {
              let output = Buffer.alloc(0);
              this.message.on('data', (chunk) => {
                  output = Buffer.concat([output, chunk]);
              });
              this.message.on('end', () => {
                  resolve(output.toString());
              });
          });
      }
  }
  exports.HttpClientResponse = HttpClientResponse;
  function isHttps(requestUrl) {
      let parsedUrl = new URL(requestUrl);
      return parsedUrl.protocol === 'https:';
  }
  exports.isHttps = isHttps;
  class HttpClient {
      constructor(userAgent, handlers, requestOptions) {
          this._ignoreSslError = false;
          this._allowRedirects = true;
          this._allowRedirectDowngrade = false;
          this._maxRedirects = 50;
          this._allowRetries = false;
          this._maxRetries = 1;
          this._keepAlive = false;
          this._disposed = false;
          this.userAgent = userAgent;
          this.handlers = handlers || [];
          this.requestOptions = requestOptions;
          if (requestOptions) {
              if (requestOptions.ignoreSslError != null) {
                  this._ignoreSslError = requestOptions.ignoreSslError;
              }
              this._socketTimeout = requestOptions.socketTimeout;
              if (requestOptions.allowRedirects != null) {
                  this._allowRedirects = requestOptions.allowRedirects;
              }
              if (requestOptions.allowRedirectDowngrade != null) {
                  this._allowRedirectDowngrade = requestOptions.allowRedirectDowngrade;
              }
              if (requestOptions.maxRedirects != null) {
                  this._maxRedirects = Math.max(requestOptions.maxRedirects, 0);
              }
              if (requestOptions.keepAlive != null) {
                  this._keepAlive = requestOptions.keepAlive;
              }
              if (requestOptions.allowRetries != null) {
                  this._allowRetries = requestOptions.allowRetries;
              }
              if (requestOptions.maxRetries != null) {
                  this._maxRetries = requestOptions.maxRetries;
              }
          }
      }
      options(requestUrl, additionalHeaders) {
          return this.request('OPTIONS', requestUrl, null, additionalHeaders || {});
      }
      get(requestUrl, additionalHeaders) {
          return this.request('GET', requestUrl, null, additionalHeaders || {});
      }
      del(requestUrl, additionalHeaders) {
          return this.request('DELETE', requestUrl, null, additionalHeaders || {});
      }
      post(requestUrl, data, additionalHeaders) {
          return this.request('POST', requestUrl, data, additionalHeaders || {});
      }
      patch(requestUrl, data, additionalHeaders) {
          return this.request('PATCH', requestUrl, data, additionalHeaders || {});
      }
      put(requestUrl, data, additionalHeaders) {
          return this.request('PUT', requestUrl, data, additionalHeaders || {});
      }
      head(requestUrl, additionalHeaders) {
          return this.request('HEAD', requestUrl, null, additionalHeaders || {});
      }
      sendStream(verb, requestUrl, stream, additionalHeaders) {
          return this.request(verb, requestUrl, stream, additionalHeaders);
      }
      /**
       * Gets a typed object from an endpoint
       * Be aware that not found returns a null.  Other errors (4xx, 5xx) reject the promise
       */
      async getJson(requestUrl, additionalHeaders = {}) {
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          let res = await this.get(requestUrl, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async postJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.post(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async putJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.put(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      async patchJson(requestUrl, obj, additionalHeaders = {}) {
          let data = JSON.stringify(obj, null, 2);
          additionalHeaders[Headers.Accept] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.Accept, MediaTypes.ApplicationJson);
          additionalHeaders[Headers.ContentType] = this._getExistingOrDefaultHeader(additionalHeaders, Headers.ContentType, MediaTypes.ApplicationJson);
          let res = await this.patch(requestUrl, data, additionalHeaders);
          return this._processResponse(res, this.requestOptions);
      }
      /**
       * Makes a raw http request.
       * All other methods such as get, post, patch, and request ultimately call this.
       * Prefer get, del, post and patch
       */
      async request(verb, requestUrl, data, headers) {
          if (this._disposed) {
              throw new Error('Client has already been disposed.');
          }
          let parsedUrl = new URL(requestUrl);
          let info = this._prepareRequest(verb, parsedUrl, headers);
          // Only perform retries on reads since writes may not be idempotent.
          let maxTries = this._allowRetries && RetryableHttpVerbs.indexOf(verb) != -1
              ? this._maxRetries + 1
              : 1;
          let numTries = 0;
          let response;
          while (numTries < maxTries) {
              response = await this.requestRaw(info, data);
              // Check if it's an authentication challenge
              if (response &&
                  response.message &&
                  response.message.statusCode === HttpCodes.Unauthorized) {
                  let authenticationHandler;
                  for (let i = 0; i < this.handlers.length; i++) {
                      if (this.handlers[i].canHandleAuthentication(response)) {
                          authenticationHandler = this.handlers[i];
                          break;
                      }
                  }
                  if (authenticationHandler) {
                      return authenticationHandler.handleAuthentication(this, info, data);
                  }
                  else {
                      // We have received an unauthorized response but have no handlers to handle it.
                      // Let the response return to the caller.
                      return response;
                  }
              }
              let redirectsRemaining = this._maxRedirects;
              while (HttpRedirectCodes.indexOf(response.message.statusCode) != -1 &&
                  this._allowRedirects &&
                  redirectsRemaining > 0) {
                  const redirectUrl = response.message.headers['location'];
                  if (!redirectUrl) {
                      // if there's no location to redirect to, we won't
                      break;
                  }
                  let parsedRedirectUrl = new URL(redirectUrl);
                  if (parsedUrl.protocol == 'https:' &&
                      parsedUrl.protocol != parsedRedirectUrl.protocol &&
                      !this._allowRedirectDowngrade) {
                      throw new Error('Redirect from HTTPS to HTTP protocol. This downgrade is not allowed for security reasons. If you want to allow this behavior, set the allowRedirectDowngrade option to true.');
                  }
                  // we need to finish reading the response before reassigning response
                  // which will leak the open socket.
                  await response.readBody();
                  // strip authorization header if redirected to a different hostname
                  if (parsedRedirectUrl.hostname !== parsedUrl.hostname) {
                      for (let header in headers) {
                          // header names are case insensitive
                          if (header.toLowerCase() === 'authorization') {
                              delete headers[header];
                          }
                      }
                  }
                  // let's make the request with the new redirectUrl
                  info = this._prepareRequest(verb, parsedRedirectUrl, headers);
                  response = await this.requestRaw(info, data);
                  redirectsRemaining--;
              }
              if (HttpResponseRetryCodes.indexOf(response.message.statusCode) == -1) {
                  // If not a retry code, return immediately instead of retrying
                  return response;
              }
              numTries += 1;
              if (numTries < maxTries) {
                  await response.readBody();
                  await this._performExponentialBackoff(numTries);
              }
          }
          return response;
      }
      /**
       * Needs to be called if keepAlive is set to true in request options.
       */
      dispose() {
          if (this._agent) {
              this._agent.destroy();
          }
          this._disposed = true;
      }
      /**
       * Raw request.
       * @param info
       * @param data
       */
      requestRaw(info, data) {
          return new Promise((resolve, reject) => {
              let callbackForResult = function (err, res) {
                  if (err) {
                      reject(err);
                  }
                  resolve(res);
              };
              this.requestRawWithCallback(info, data, callbackForResult);
          });
      }
      /**
       * Raw request with callback.
       * @param info
       * @param data
       * @param onResult
       */
      requestRawWithCallback(info, data, onResult) {
          let socket;
          if (typeof data === 'string') {
              info.options.headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
          }
          let callbackCalled = false;
          let handleResult = (err, res) => {
              if (!callbackCalled) {
                  callbackCalled = true;
                  onResult(err, res);
              }
          };
          let req = info.httpModule.request(info.options, (msg) => {
              let res = new HttpClientResponse(msg);
              handleResult(null, res);
          });
          req.on('socket', sock => {
              socket = sock;
          });
          // If we ever get disconnected, we want the socket to timeout eventually
          req.setTimeout(this._socketTimeout || 3 * 60000, () => {
              if (socket) {
                  socket.end();
              }
              handleResult(new Error('Request timeout: ' + info.options.path), null);
          });
          req.on('error', function (err) {
              // err has statusCode property
              // res should have headers
              handleResult(err, null);
          });
          if (data && typeof data === 'string') {
              req.write(data, 'utf8');
          }
          if (data && typeof data !== 'string') {
              data.on('close', function () {
                  req.end();
              });
              data.pipe(req);
          }
          else {
              req.end();
          }
      }
      /**
       * Gets an http agent. This function is useful when you need an http agent that handles
       * routing through a proxy server - depending upon the url and proxy environment variables.
       * @param serverUrl  The server URL where the request will be sent. For example, https://api.github.com
       */
      getAgent(serverUrl) {
          let parsedUrl = new URL(serverUrl);
          return this._getAgent(parsedUrl);
      }
      _prepareRequest(method, requestUrl, headers) {
          const info = {};
          info.parsedUrl = requestUrl;
          const usingSsl = info.parsedUrl.protocol === 'https:';
          info.httpModule = usingSsl ? https : http;
          const defaultPort = usingSsl ? 443 : 80;
          info.options = {};
          info.options.host = info.parsedUrl.hostname;
          info.options.port = info.parsedUrl.port
              ? parseInt(info.parsedUrl.port)
              : defaultPort;
          info.options.path =
              (info.parsedUrl.pathname || '') + (info.parsedUrl.search || '');
          info.options.method = method;
          info.options.headers = this._mergeHeaders(headers);
          if (this.userAgent != null) {
              info.options.headers['user-agent'] = this.userAgent;
          }
          info.options.agent = this._getAgent(info.parsedUrl);
          // gives handlers an opportunity to participate
          if (this.handlers) {
              this.handlers.forEach(handler => {
                  handler.prepareRequest(info.options);
              });
          }
          return info;
      }
      _mergeHeaders(headers) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          if (this.requestOptions && this.requestOptions.headers) {
              return Object.assign({}, lowercaseKeys(this.requestOptions.headers), lowercaseKeys(headers));
          }
          return lowercaseKeys(headers || {});
      }
      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
          const lowercaseKeys = obj => Object.keys(obj).reduce((c, k) => ((c[k.toLowerCase()] = obj[k]), c), {});
          let clientHeader;
          if (this.requestOptions && this.requestOptions.headers) {
              clientHeader = lowercaseKeys(this.requestOptions.headers)[header];
          }
          return additionalHeaders[header] || clientHeader || _default;
      }
      _getAgent(parsedUrl) {
          let agent;
          let proxyUrl = pm.getProxyUrl(parsedUrl);
          let useProxy = proxyUrl && proxyUrl.hostname;
          if (this._keepAlive && useProxy) {
              agent = this._proxyAgent;
          }
          if (this._keepAlive && !useProxy) {
              agent = this._agent;
          }
          // if agent is already assigned use that agent.
          if (!!agent) {
              return agent;
          }
          const usingSsl = parsedUrl.protocol === 'https:';
          let maxSockets = 100;
          if (!!this.requestOptions) {
              maxSockets = this.requestOptions.maxSockets || http.globalAgent.maxSockets;
          }
          if (useProxy) {
              // If using proxy, need tunnel
              if (!tunnel) {
                  tunnel = __webpack_require__(413);
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      ...((proxyUrl.username || proxyUrl.password) && {
                          proxyAuth: `${proxyUrl.username}:${proxyUrl.password}`
                      }),
                      host: proxyUrl.hostname,
                      port: proxyUrl.port
                  }
              };
              let tunnelAgent;
              const overHttps = proxyUrl.protocol === 'https:';
              if (usingSsl) {
                  tunnelAgent = overHttps ? tunnel.httpsOverHttps : tunnel.httpsOverHttp;
              }
              else {
                  tunnelAgent = overHttps ? tunnel.httpOverHttps : tunnel.httpOverHttp;
              }
              agent = tunnelAgent(agentOptions);
              this._proxyAgent = agent;
          }
          // if reusing agent across request and tunneling agent isn't assigned create a new agent
          if (this._keepAlive && !agent) {
              const options = { keepAlive: this._keepAlive, maxSockets: maxSockets };
              agent = usingSsl ? new https.Agent(options) : new http.Agent(options);
              this._agent = agent;
          }
          // if not using private agent and tunnel agent isn't setup then use global agent
          if (!agent) {
              agent = usingSsl ? https.globalAgent : http.globalAgent;
          }
          if (usingSsl && this._ignoreSslError) {
              // we don't want to set NODE_TLS_REJECT_UNAUTHORIZED=0 since that will affect request for entire process
              // http.RequestOptions doesn't expose a way to modify RequestOptions.agent.options
              // we have to cast it to any and change it directly
              agent.options = Object.assign(agent.options || {}, {
                  rejectUnauthorized: false
              });
          }
          return agent;
      }
      _performExponentialBackoff(retryNumber) {
          retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
          const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
          return new Promise(resolve => setTimeout(() => resolve(), ms));
      }
      static dateTimeDeserializer(key, value) {
          if (typeof value === 'string') {
              let a = new Date(value);
              if (!isNaN(a.valueOf())) {
                  return a;
              }
          }
          return value;
      }
      async _processResponse(res, options) {
          return new Promise(async (resolve, reject) => {
              const statusCode = res.message.statusCode;
              const response = {
                  statusCode: statusCode,
                  result: null,
                  headers: {}
              };
              // not found leads to null obj returned
              if (statusCode == HttpCodes.NotFound) {
                  resolve(response);
              }
              let obj;
              let contents;
              // get the result from the body
              try {
                  contents = await res.readBody();
                  if (contents && contents.length > 0) {
                      if (options && options.deserializeDates) {
                          obj = JSON.parse(contents, HttpClient.dateTimeDeserializer);
                      }
                      else {
                          obj = JSON.parse(contents);
                      }
                      response.result = obj;
                  }
                  response.headers = res.message.headers;
              }
              catch (err) {
                  // Invalid resource (contents not json);  leaving result obj null
              }
              // note that 3xx redirects are handled by the http layer.
              if (statusCode > 299) {
                  let msg;
                  // if exception/error in body, attempt to get better error
                  if (obj && obj.message) {
                      msg = obj.message;
                  }
                  else if (contents && contents.length > 0) {
                      // it may be the case that the exception is in the body message as string
                      msg = contents;
                  }
                  else {
                      msg = 'Failed request: (' + statusCode + ')';
                  }
                  let err = new HttpClientError(msg, statusCode);
                  err.result = response.result;
                  reject(err);
              }
              else {
                  resolve(response);
              }
          });
      }
  }
  exports.HttpClient = HttpClient;
  
  
  /***/ }),
  /* 218 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var add =
  /*#__PURE__*/
  __webpack_require__(792);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Adds together all the elements of a list.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig [Number] -> Number
   * @param {Array} list An array of numbers
   * @return {Number} The sum of all the numbers in the list.
   * @see R.reduce
   * @example
   *
   *      R.sum([2,4,6,8,100,1]); //=> 121
   */
  
  
  var sum =
  /*#__PURE__*/
  reduce(add, 0);
  module.exports = sum;
  
  /***/ }),
  /* 219 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned
   * function evaluates the `tryer`; if it does not throw, it simply returns the
   * result. If the `tryer` *does* throw, the returned function evaluates the
   * `catcher` function and returns its result. Note that for effective
   * composition with this function, both the `tryer` and `catcher` functions
   * must return the same type of results.
   *
   * @func
   * @memberOf R
   * @since v0.20.0
   * @category Function
   * @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a)
   * @param {Function} tryer The function that may throw.
   * @param {Function} catcher The function that will be evaluated if `tryer` throws.
   * @return {Function} A new function that will catch exceptions and send then to the catcher.
   * @example
   *
   *      R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true
   *      R.tryCatch(() => { throw 'foo'}, R.always('catched'))('bar') // => 'catched'
   *      R.tryCatch(R.times(R.identity), R.always([]))('s') // => []
   *      R.tryCatch(() => { throw 'this is not a valid value'}, (err, value)=>({error : err,  value }))('bar') // => {'error': 'this is not a valid value', 'value': 'bar'}
   */
  
  
  var tryCatch =
  /*#__PURE__*/
  _curry2(function _tryCatch(tryer, catcher) {
    return _arity(tryer.length, function () {
      try {
        return tryer.apply(this, arguments);
      } catch (e) {
        return catcher.apply(this, _concat([e], arguments));
      }
    });
  });
  
  module.exports = tryCatch;
  
  /***/ }),
  /* 220 */,
  /* 221 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Takes a list and a predicate and returns a pair of lists with the following properties:
   *
   *  - the result of concatenating the two output lists is equivalent to the input list;
   *  - none of the elements of the first output list satisfies the predicate; and
   *  - if the second output list is non-empty, its first element satisfies the predicate.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> [[a], [a]]
   * @param {Function} pred The predicate that determines where the array is split.
   * @param {Array} list The array to be split.
   * @return {Array}
   * @example
   *
   *      R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]);   //=> [[1], [2, 3, 1, 2, 3]]
   */
  
  
  var splitWhen =
  /*#__PURE__*/
  _curry2(function splitWhen(pred, list) {
    var idx = 0;
    var len = list.length;
    var prefix = [];
  
    while (idx < len && !pred(list[idx])) {
      prefix.push(list[idx]);
      idx += 1;
    }
  
    return [prefix, Array.prototype.slice.call(list, idx)];
  });
  
  module.exports = splitWhen;
  
  /***/ }),
  /* 222 */,
  /* 223 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var mean =
  /*#__PURE__*/
  __webpack_require__(460);
  /**
   * Returns the median of the given list of numbers.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Math
   * @sig [Number] -> Number
   * @param {Array} list
   * @return {Number}
   * @see R.mean
   * @example
   *
   *      R.median([2, 9, 7]); //=> 7
   *      R.median([7, 2, 10, 9]); //=> 8
   *      R.median([]); //=> NaN
   */
  
  
  var median =
  /*#__PURE__*/
  _curry1(function median(list) {
    var len = list.length;
  
    if (len === 0) {
      return NaN;
    }
  
    var width = 2 - len % 2;
    var idx = (len - width) / 2;
    return mean(Array.prototype.slice.call(list, 0).sort(function (a, b) {
      return a < b ? -1 : a > b ? 1 : 0;
    }).slice(idx, idx + width));
  });
  
  module.exports = median;
  
  /***/ }),
  /* 224 */,
  /* 225 */,
  /* 226 */,
  /* 227 */,
  /* 228 */,
  /* 229 */,
  /* 230 */,
  /* 231 */,
  /* 232 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _checkForMethod =
  /*#__PURE__*/
  __webpack_require__(417);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Returns the elements of the given list or string (or object with a `slice`
   * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
   *
   * Dispatches to the `slice` method of the third argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.4
   * @category List
   * @sig Number -> Number -> [a] -> [a]
   * @sig Number -> Number -> String -> String
   * @param {Number} fromIndex The start index (inclusive).
   * @param {Number} toIndex The end index (exclusive).
   * @param {*} list
   * @return {*}
   * @example
   *
   *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']
   *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
   *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']
   *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']
   *      R.slice(0, 3, 'ramda');                     //=> 'ram'
   */
  
  
  var slice =
  /*#__PURE__*/
  _curry3(
  /*#__PURE__*/
  _checkForMethod('slice', function slice(fromIndex, toIndex, list) {
    return Array.prototype.slice.call(list, fromIndex, toIndex);
  }));
  
  module.exports = slice;
  
  /***/ }),
  /* 233 */,
  /* 234 */,
  /* 235 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _isArguments =
  /*#__PURE__*/
  __webpack_require__(960);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var _isObject =
  /*#__PURE__*/
  __webpack_require__(662);
  
  var _isString =
  /*#__PURE__*/
  __webpack_require__(285);
  /**
   * Returns the empty value of its argument's type. Ramda defines the empty
   * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other
   * types are supported if they define `<Type>.empty`,
   * `<Type>.prototype.empty` or implement the
   * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).
   *
   * Dispatches to the `empty` method of the first argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category Function
   * @sig a -> a
   * @param {*} x
   * @return {*}
   * @example
   *
   *      R.empty(Just(42));      //=> Nothing()
   *      R.empty([1, 2, 3]);     //=> []
   *      R.empty('unicorns');    //=> ''
   *      R.empty({x: 1, y: 2});  //=> {}
   */
  
  
  var empty =
  /*#__PURE__*/
  _curry1(function empty(x) {
    return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {
      return arguments;
    }() : void 0 // else
    ;
  });
  
  module.exports = empty;
  
  /***/ }),
  /* 236 */,
  /* 237 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * A function that returns the `!` of its argument. It will return `true` when
   * passed false-y value, and `false` when passed a truth-y one.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Logic
   * @sig * -> Boolean
   * @param {*} a any value
   * @return {Boolean} the logical inverse of passed argument.
   * @see R.complement
   * @example
   *
   *      R.not(true); //=> false
   *      R.not(false); //=> true
   *      R.not(0); //=> true
   *      R.not(1); //=> false
   */
  
  
  var not =
  /*#__PURE__*/
  _curry1(function not(a) {
    return !a;
  });
  
  module.exports = not;
  
  /***/ }),
  /* 238 */,
  /* 239 */,
  /* 240 */,
  /* 241 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Returns a list of all the properties, including prototype properties, of the
   * supplied object.
   * Note that the order of the output array is not guaranteed to be consistent
   * across different JS platforms.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category Object
   * @sig {k: v} -> [v]
   * @param {Object} obj The object to extract values from
   * @return {Array} An array of the values of the object's own and prototype properties.
   * @see R.values, R.keysIn
   * @example
   *
   *      const F = function() { this.x = 'X'; };
   *      F.prototype.y = 'Y';
   *      const f = new F();
   *      R.valuesIn(f); //=> ['X', 'Y']
   */
  
  
  var valuesIn =
  /*#__PURE__*/
  _curry1(function valuesIn(obj) {
    var prop;
    var vs = [];
  
    for (prop in obj) {
      vs[vs.length] = obj[prop];
    }
  
    return vs;
  });
  
  module.exports = valuesIn;
  
  /***/ }),
  /* 242 */,
  /* 243 */,
  /* 244 */,
  /* 245 */,
  /* 246 */,
  /* 247 */,
  /* 248 */,
  /* 249 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns a new list containing the last `n` elements of a given list, passing
   * each value to the supplied predicate function, and terminating when the
   * predicate function returns `false`. Excludes the element that caused the
   * predicate function to fail. The predicate function is passed one argument:
   * *(value)*.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> [a]
   * @sig (a -> Boolean) -> String -> String
   * @param {Function} fn The function called per iteration.
   * @param {Array} xs The collection to iterate over.
   * @return {Array} A new array.
   * @see R.dropLastWhile, R.addIndex
   * @example
   *
   *      const isNotOne = x => x !== 1;
   *
   *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
   *
   *      R.takeLastWhile(x => x !== 'R' , 'Ramda'); //=> 'amda'
   */
  
  
  var takeLastWhile =
  /*#__PURE__*/
  _curry2(function takeLastWhile(fn, xs) {
    var idx = xs.length - 1;
  
    while (idx >= 0 && fn(xs[idx])) {
      idx -= 1;
    }
  
    return slice(idx + 1, Infinity, xs);
  });
  
  module.exports = takeLastWhile;
  
  /***/ }),
  /* 250 */,
  /* 251 */,
  /* 252 */,
  /* 253 */,
  /* 254 */,
  /* 255 */,
  /* 256 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Returns a list of all the enumerable own properties of the supplied object.
   * Note that the order of the output array is not guaranteed across different
   * JS platforms.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig {k: v} -> [v]
   * @param {Object} obj The object to extract values from
   * @return {Array} An array of the values of the object's own properties.
   * @see R.valuesIn, R.keys
   * @example
   *
   *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
   */
  
  
  var values =
  /*#__PURE__*/
  _curry1(function values(obj) {
    var props = keys(obj);
    var len = props.length;
    var vals = [];
    var idx = 0;
  
    while (idx < len) {
      vals[idx] = obj[props[idx]];
      idx += 1;
    }
  
    return vals;
  });
  
  module.exports = values;
  
  /***/ }),
  /* 257 */,
  /* 258 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var always =
  /*#__PURE__*/
  __webpack_require__(657);
  
  var times =
  /*#__PURE__*/
  __webpack_require__(54);
  /**
   * Returns a fixed list of size `n` containing a specified identical value.
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category List
   * @sig a -> n -> [a]
   * @param {*} value The value to repeat.
   * @param {Number} n The desired size of the output list.
   * @return {Array} A new array containing `n` `value`s.
   * @see R.times
   * @example
   *
   *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']
   *
   *      const obj = {};
   *      const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
   *      repeatedObjs[0] === repeatedObjs[1]; //=> true
   * @symb R.repeat(a, 0) = []
   * @symb R.repeat(a, 1) = [a]
   * @symb R.repeat(a, 2) = [a, a]
   */
  
  
  var repeat =
  /*#__PURE__*/
  _curry2(function repeat(value, n) {
    return times(always(value), n);
  });
  
  module.exports = repeat;
  
  /***/ }),
  /* 259 */,
  /* 260 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var _isString =
  /*#__PURE__*/
  __webpack_require__(285);
  /**
   * Tests whether or not an object is similar to an array.
   *
   * @private
   * @category Type
   * @category List
   * @sig * -> Boolean
   * @param {*} x The object to test.
   * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
   * @example
   *
   *      _isArrayLike([]); //=> true
   *      _isArrayLike(true); //=> false
   *      _isArrayLike({}); //=> false
   *      _isArrayLike({length: 10}); //=> false
   *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
   */
  
  
  var _isArrayLike =
  /*#__PURE__*/
  _curry1(function isArrayLike(x) {
    if (_isArray(x)) {
      return true;
    }
  
    if (!x) {
      return false;
    }
  
    if (typeof x !== 'object') {
      return false;
    }
  
    if (_isString(x)) {
      return false;
    }
  
    if (x.nodeType === 1) {
      return !!x.length;
    }
  
    if (x.length === 0) {
      return true;
    }
  
    if (x.length > 0) {
      return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
    }
  
    return false;
  });
  
  module.exports = _isArrayLike;
  
  /***/ }),
  /* 261 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var is =
  /*#__PURE__*/
  __webpack_require__(452);
  /**
   * Returns `true` if the specified object property is of the given type;
   * `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Type
   * @sig Type -> String -> Object -> Boolean
   * @param {Function} type
   * @param {String} name
   * @param {*} obj
   * @return {Boolean}
   * @see R.is, R.propSatisfies
   * @example
   *
   *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true
   *      R.propIs(Number, 'x', {x: 'foo'});    //=> false
   *      R.propIs(Number, 'x', {});            //=> false
   */
  
  
  var propIs =
  /*#__PURE__*/
  _curry3(function propIs(type, name, obj) {
    return is(type, obj[name]);
  });
  
  module.exports = propIs;
  
  /***/ }),
  /* 262 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _isNumber =
  /*#__PURE__*/
  __webpack_require__(571);
  /**
   * Returns the number of elements in the array by returning `list.length`.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category List
   * @sig [a] -> Number
   * @param {Array} list The array to inspect.
   * @return {Number} The length of the array.
   * @example
   *
   *      R.length([]); //=> 0
   *      R.length([1, 2, 3]); //=> 3
   */
  
  
  var length =
  /*#__PURE__*/
  _curry1(function length(list) {
    return list != null && _isNumber(list.length) ? list.length : NaN;
  });
  
  module.exports = length;
  
  /***/ }),
  /* 263 */,
  /* 264 */,
  /* 265 */,
  /* 266 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Negates its argument.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Math
   * @sig Number -> Number
   * @param {Number} n
   * @return {Number}
   * @example
   *
   *      R.negate(42); //=> -42
   */
  
  
  var negate =
  /*#__PURE__*/
  _curry1(function negate(n) {
    return -n;
  });
  
  module.exports = negate;
  
  /***/ }),
  /* 267 */,
  /* 268 */
  /***/ (function(module) {
  
  // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
  function _objectIs(a, b) {
    // SameValue algorithm
    if (a === b) {
      // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return a !== 0 || 1 / a === 1 / b;
    } else {
      // Step 6.a: NaN == NaN
      return a !== a && b !== b;
    }
  }
  
  module.exports = typeof Object.is === 'function' ? Object.is : _objectIs;
  
  /***/ }),
  /* 269 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a function that is bound to a context.
   * Note: `R.bind` does not provide the additional argument-binding capabilities of
   * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
   *
   * @func
   * @memberOf R
   * @since v0.6.0
   * @category Function
   * @category Object
   * @sig (* -> *) -> {*} -> (* -> *)
   * @param {Function} fn The function to bind to context
   * @param {Object} thisObj The context to bind `fn` to
   * @return {Function} A function that will execute in the context of `thisObj`.
   * @see R.partial
   * @example
   *
   *      const log = R.bind(console.log, console);
   *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
   *      // logs {a: 2}
   * @symb R.bind(f, o)(a, b) = f.call(o, a, b)
   */
  
  
  var bind =
  /*#__PURE__*/
  _curry2(function bind(fn, thisObj) {
    return _arity(fn.length, function () {
      return fn.apply(thisObj, arguments);
    });
  });
  
  module.exports = bind;
  
  /***/ }),
  /* 270 */,
  /* 271 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XMap =
  /*#__PURE__*/
  function () {
    function XMap(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XMap.prototype['@@transducer/init'] = _xfBase.init;
    XMap.prototype['@@transducer/result'] = _xfBase.result;
  
    XMap.prototype['@@transducer/step'] = function (result, input) {
      return this.xf['@@transducer/step'](result, this.f(input));
    };
  
    return XMap;
  }();
  
  var _xmap =
  /*#__PURE__*/
  _curry2(function _xmap(f, xf) {
    return new XMap(f, xf);
  });
  
  module.exports = _xmap;
  
  /***/ }),
  /* 272 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var assocPath =
  /*#__PURE__*/
  __webpack_require__(194);
  
  var lens =
  /*#__PURE__*/
  __webpack_require__(596);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * Returns a lens whose focus is the specified path.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Object
   * @typedefn Idx = String | Int
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig [Idx] -> Lens s a
   * @param {Array} path The path to use.
   * @return {Lens}
   * @see R.view, R.set, R.over
   * @example
   *
   *      const xHeadYLens = R.lensPath(['x', 0, 'y']);
   *
   *      R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
   *      //=> 2
   *      R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
   *      //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
   *      R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
   *      //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
   */
  
  
  var lensPath =
  /*#__PURE__*/
  _curry1(function lensPath(p) {
    return lens(path(p), assocPath(p));
  });
  
  module.exports = lensPath;
  
  /***/ }),
  /* 273 */,
  /* 274 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  var shebangRegex = __webpack_require__(816);
  
  module.exports = function (str) {
  	var match = str.match(shebangRegex);
  
  	if (!match) {
  		return null;
  	}
  
  	var arr = match[0].replace(/#! ?/, '').split(' ');
  	var bin = arr[0].split('/').pop();
  	var arg = arr[1];
  
  	return (bin === 'env' ?
  		arg :
  		bin + (arg ? ' ' + arg : '')
  	);
  };
  
  
  /***/ }),
  /* 275 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _Set =
  /*#__PURE__*/
  __webpack_require__(161);
  /**
   * Finds the set (i.e. no duplicates) of all elements in the first list not
   * contained in the second list. Objects and Arrays are compared in terms of
   * value equality, not reference equality.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig [*] -> [*] -> [*]
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The elements in `list1` that are not in `list2`.
   * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without
   * @example
   *
   *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
   *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
   *      R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]
   */
  
  
  var difference =
  /*#__PURE__*/
  _curry2(function difference(first, second) {
    var out = [];
    var idx = 0;
    var firstLen = first.length;
    var secondLen = second.length;
    var toFilterOut = new _Set();
  
    for (var i = 0; i < secondLen; i += 1) {
      toFilterOut.add(second[i]);
    }
  
    while (idx < firstLen) {
      if (toFilterOut.add(first[idx])) {
        out[out.length] = first[idx];
      }
  
      idx += 1;
    }
  
    return out;
  });
  
  module.exports = difference;
  
  /***/ }),
  /* 276 */,
  /* 277 */,
  /* 278 */,
  /* 279 */,
  /* 280 */
  /***/ (function(module) {
  
  module.exports = register;
  
  function register(state, name, method, options) {
    if (typeof method !== "function") {
      throw new Error("method for before hook must be a function");
    }
  
    if (!options) {
      options = {};
    }
  
    if (Array.isArray(name)) {
      return name.reverse().reduce(function (callback, name) {
        return register.bind(null, state, name, callback, options);
      }, method)();
    }
  
    return Promise.resolve().then(function () {
      if (!state.registry[name]) {
        return method(options);
      }
  
      return state.registry[name].reduce(function (method, registered) {
        return registered.hook.bind(null, method, options);
      }, method)();
    });
  }
  
  
  /***/ }),
  /* 281 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.create = void 0;
  const internal_globber_1 = __webpack_require__(297);
  /**
   * Constructs a globber
   *
   * @param patterns  Patterns separated by newlines
   * @param options   Glob options
   */
  function create(patterns, options) {
      return __awaiter(this, void 0, void 0, function* () {
          return yield internal_globber_1.DefaultGlobber.create(patterns, options);
      });
  }
  exports.create = create;
  //# sourceMappingURL=glob.js.map
  
  /***/ }),
  /* 282 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  const macosRelease = __webpack_require__(118);
  const winRelease = __webpack_require__(494);
  
  const osName = (platform, release) => {
  	if (!platform && release) {
  		throw new Error('You can\'t specify a `release` without specifying `platform`');
  	}
  
  	platform = platform || os.platform();
  
  	let id;
  
  	if (platform === 'darwin') {
  		if (!release && os.platform() === 'darwin') {
  			release = os.release();
  		}
  
  		const prefix = release ? (Number(release.split('.')[0]) > 15 ? 'macOS' : 'OS X') : 'macOS';
  		id = release ? macosRelease(release).name : '';
  		return prefix + (id ? ' ' + id : '');
  	}
  
  	if (platform === 'linux') {
  		if (!release && os.platform() === 'linux') {
  			release = os.release();
  		}
  
  		id = release ? release.replace(/^(\d+\.\d+).*/, '$1') : '';
  		return 'Linux' + (id ? ' ' + id : '');
  	}
  
  	if (platform === 'win32') {
  		if (!release && os.platform() === 'win32') {
  			release = os.release();
  		}
  
  		id = release ? winRelease(release) : '';
  		return 'Windows' + (id ? ' ' + id : '');
  	}
  
  	return platform;
  };
  
  module.exports = osName;
  
  
  /***/ }),
  /* 283 */,
  /* 284 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * An Object-specific version of [`map`](#map). The function is applied to three
   * arguments: *(value, key, obj)*. If only the value is significant, use
   * [`map`](#map) instead.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Object
   * @sig ((*, String, Object) -> *) -> Object -> Object
   * @param {Function} fn
   * @param {Object} obj
   * @return {Object}
   * @see R.map
   * @example
   *
   *      const xyz = { x: 1, y: 2, z: 3 };
   *      const prependKeyAndDouble = (num, key, obj) => key + (num * 2);
   *
   *      R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: 'x2', y: 'y4', z: 'z6' }
   */
  
  
  var mapObjIndexed =
  /*#__PURE__*/
  _curry2(function mapObjIndexed(fn, obj) {
    return _reduce(function (acc, key) {
      acc[key] = fn(obj[key], key, obj);
      return acc;
    }, {}, keys(obj));
  });
  
  module.exports = mapObjIndexed;
  
  /***/ }),
  /* 285 */
  /***/ (function(module) {
  
  function _isString(x) {
    return Object.prototype.toString.call(x) === '[object String]';
  }
  
  module.exports = _isString;
  
  /***/ }),
  /* 286 */,
  /* 287 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the specified value is equal, in [`R.equals`](#equals)
   * terms, to at least one element of the given list; `false` otherwise.
   * Works also with strings.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category List
   * @sig a -> [a] -> Boolean
   * @param {Object} a The item to compare against.
   * @param {Array} list The array to consider.
   * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.
   * @see R.any
   * @example
   *
   *      R.includes(3, [1, 2, 3]); //=> true
   *      R.includes(4, [1, 2, 3]); //=> false
   *      R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true
   *      R.includes([42], [[42]]); //=> true
   *      R.includes('ba', 'banana'); //=>true
   */
  
  
  var includes =
  /*#__PURE__*/
  _curry2(_includes);
  
  module.exports = includes;
  
  /***/ }),
  /* 288 */,
  /* 289 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390); // Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
  
  
  function _objectAssign(target) {
    if (target == null) {
      throw new TypeError('Cannot convert undefined or null to object');
    }
  
    var output = Object(target);
    var idx = 1;
    var length = arguments.length;
  
    while (idx < length) {
      var source = arguments[idx];
  
      if (source != null) {
        for (var nextKey in source) {
          if (_has(nextKey, source)) {
            output[nextKey] = source[nextKey];
          }
        }
      }
  
      idx += 1;
    }
  
    return output;
  }
  
  module.exports = typeof Object.assign === 'function' ? Object.assign : _objectAssign;
  
  /***/ }),
  /* 290 */,
  /* 291 */
  /***/ (function(module) {
  
  /**
   * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.
   */
  var pad = function pad(n) {
    return (n < 10 ? '0' : '') + n;
  };
  
  var _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {
    return d.toISOString();
  } : function _toISOString(d) {
    return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';
  };
  
  module.exports = _toISOString;
  
  /***/ }),
  /* 292 */,
  /* 293 */,
  /* 294 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Iterate over an input `object`, calling a provided function `fn` for each
   * key and value in the object.
   *
   * `fn` receives three argument: *(value, key, obj)*.
   *
   * @func
   * @memberOf R
   * @since v0.23.0
   * @category Object
   * @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a
   * @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`.
   * @param {Object} obj The object to iterate over.
   * @return {Object} The original object.
   * @example
   *
   *      const printKeyConcatValue = (value, key) => console.log(key + ':' + value);
   *      R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}
   *      // logs x:1
   *      // logs y:2
   * @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b}
   */
  
  
  var forEachObjIndexed =
  /*#__PURE__*/
  _curry2(function forEachObjIndexed(fn, obj) {
    var keyList = keys(obj);
    var idx = 0;
  
    while (idx < keyList.length) {
      var key = keyList[idx];
      fn(obj[key], key, obj);
      idx += 1;
    }
  
    return obj;
  });
  
  module.exports = forEachObjIndexed;
  
  /***/ }),
  /* 295 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Accepts a function `fn` and returns a function that guards invocation of
   * `fn` such that `fn` can only ever be called once, no matter how many times
   * the returned function is invoked. The first value calculated is returned in
   * subsequent invocations.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig (a... -> b) -> (a... -> b)
   * @param {Function} fn The function to wrap in a call-only-once wrapper.
   * @return {Function} The wrapped function.
   * @example
   *
   *      const addOneOnce = R.once(x => x + 1);
   *      addOneOnce(10); //=> 11
   *      addOneOnce(addOneOnce(50)); //=> 11
   */
  
  
  var once =
  /*#__PURE__*/
  _curry1(function once(fn) {
    var called = false;
    var result;
    return _arity(fn.length, function () {
      if (called) {
        return result;
      }
  
      called = true;
      result = fn.apply(this, arguments);
      return result;
    });
  });
  
  module.exports = once;
  
  /***/ }),
  /* 296 */,
  /* 297 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  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 __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]); }
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.DefaultGlobber = void 0;
  const core = __importStar(__webpack_require__(470));
  const fs = __importStar(__webpack_require__(747));
  const globOptionsHelper = __importStar(__webpack_require__(601));
  const path = __importStar(__webpack_require__(622));
  const patternHelper = __importStar(__webpack_require__(597));
  const internal_match_kind_1 = __webpack_require__(327);
  const internal_pattern_1 = __webpack_require__(923);
  const internal_search_state_1 = __webpack_require__(728);
  const IS_WINDOWS = process.platform === 'win32';
  class DefaultGlobber {
      constructor(options) {
          this.patterns = [];
          this.searchPaths = [];
          this.options = globOptionsHelper.getOptions(options);
      }
      getSearchPaths() {
          // Return a copy
          return this.searchPaths.slice();
      }
      glob() {
          var e_1, _a;
          return __awaiter(this, void 0, void 0, function* () {
              const result = [];
              try {
                  for (var _b = __asyncValues(this.globGenerator()), _c; _c = yield _b.next(), !_c.done;) {
                      const itemPath = _c.value;
                      result.push(itemPath);
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
                  }
                  finally { if (e_1) throw e_1.error; }
              }
              return result;
          });
      }
      globGenerator() {
          return __asyncGenerator(this, arguments, function* globGenerator_1() {
              // Fill in defaults options
              const options = globOptionsHelper.getOptions(this.options);
              // Implicit descendants?
              const patterns = [];
              for (const pattern of this.patterns) {
                  patterns.push(pattern);
                  if (options.implicitDescendants &&
                      (pattern.trailingSeparator ||
                          pattern.segments[pattern.segments.length - 1] !== '**')) {
                      patterns.push(new internal_pattern_1.Pattern(pattern.negate, true, pattern.segments.concat('**')));
                  }
              }
              // Push the search paths
              const stack = [];
              for (const searchPath of patternHelper.getSearchPaths(patterns)) {
                  core.debug(`Search path '${searchPath}'`);
                  // Exists?
                  try {
                      // Intentionally using lstat. Detection for broken symlink
                      // will be performed later (if following symlinks).
                      yield __await(fs.promises.lstat(searchPath));
                  }
                  catch (err) {
                      if (err.code === 'ENOENT') {
                          continue;
                      }
                      throw err;
                  }
                  stack.unshift(new internal_search_state_1.SearchState(searchPath, 1));
              }
              // Search
              const traversalChain = []; // used to detect cycles
              while (stack.length) {
                  // Pop
                  const item = stack.pop();
                  // Match?
                  const match = patternHelper.match(patterns, item.path);
                  const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
                  if (!match && !partialMatch) {
                      continue;
                  }
                  // Stat
                  const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain)
                  // Broken symlink, or symlink cycle detected, or no longer exists
                  );
                  // Broken symlink, or symlink cycle detected, or no longer exists
                  if (!stats) {
                      continue;
                  }
                  // Directory
                  if (stats.isDirectory()) {
                      // Matched
                      if (match & internal_match_kind_1.MatchKind.Directory) {
                          yield yield __await(item.path);
                      }
                      // Descend?
                      else if (!partialMatch) {
                          continue;
                      }
                      // Push the child items in reverse
                      const childLevel = item.level + 1;
                      const childItems = (yield __await(fs.promises.readdir(item.path))).map(x => new internal_search_state_1.SearchState(path.join(item.path, x), childLevel));
                      stack.push(...childItems.reverse());
                  }
                  // File
                  else if (match & internal_match_kind_1.MatchKind.File) {
                      yield yield __await(item.path);
                  }
              }
          });
      }
      /**
       * Constructs a DefaultGlobber
       */
      static create(patterns, options) {
          return __awaiter(this, void 0, void 0, function* () {
              const result = new DefaultGlobber(options);
              if (IS_WINDOWS) {
                  patterns = patterns.replace(/\r\n/g, '\n');
                  patterns = patterns.replace(/\r/g, '\n');
              }
              const lines = patterns.split('\n').map(x => x.trim());
              for (const line of lines) {
                  // Empty or comment
                  if (!line || line.startsWith('#')) {
                      continue;
                  }
                  // Pattern
                  else {
                      result.patterns.push(new internal_pattern_1.Pattern(line));
                  }
              }
              result.searchPaths.push(...patternHelper.getSearchPaths(result.patterns));
              return result;
          });
      }
      static stat(item, options, traversalChain) {
          return __awaiter(this, void 0, void 0, function* () {
              // Note:
              // `stat` returns info about the target of a symlink (or symlink chain)
              // `lstat` returns info about a symlink itself
              let stats;
              if (options.followSymbolicLinks) {
                  try {
                      // Use `stat` (following symlinks)
                      stats = yield fs.promises.stat(item.path);
                  }
                  catch (err) {
                      if (err.code === 'ENOENT') {
                          if (options.omitBrokenSymbolicLinks) {
                              core.debug(`Broken symlink '${item.path}'`);
                              return undefined;
                          }
                          throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
                      }
                      throw err;
                  }
              }
              else {
                  // Use `lstat` (not following symlinks)
                  stats = yield fs.promises.lstat(item.path);
              }
              // Note, isDirectory() returns false for the lstat of a symlink
              if (stats.isDirectory() && options.followSymbolicLinks) {
                  // Get the realpath
                  const realPath = yield fs.promises.realpath(item.path);
                  // Fixup the traversal chain to match the item level
                  while (traversalChain.length >= item.level) {
                      traversalChain.pop();
                  }
                  // Test for a cycle
                  if (traversalChain.some((x) => x === realPath)) {
                      core.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
                      return undefined;
                  }
                  // Update the traversal chain
                  traversalChain.push(realPath);
              }
              return stats;
          });
      }
  }
  exports.DefaultGlobber = DefaultGlobber;
  //# sourceMappingURL=internal-globber.js.map
  
  /***/ }),
  /* 298 */,
  /* 299 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  const VERSION = "2.14.0";
  
  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
  
    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
  
      if (enumerableOnly) {
        symbols = symbols.filter(function (sym) {
          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
        });
      }
  
      keys.push.apply(keys, symbols);
    }
  
    return keys;
  }
  
  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
  
      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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;
  }
  
  /**
   * Some “list” response that can be paginated have a different response structure
   *
   * They have a `total_count` key in the response (search also has `incomplete_results`,
   * /installation/repositories also has `repository_selection`), as well as a key with
   * the list of the items which name varies from endpoint to endpoint.
   *
   * Octokit normalizes these responses so that paginated results are always returned following
   * the same structure. One challenge is that if the list response has only one page, no Link
   * header is provided, so this header alone is not sufficient to check wether a response is
   * paginated or not.
   *
   * We check if a "total_count" key is present in the response data, but also make sure that
   * a "url" property is not, as the "Get the combined status for a specific ref" endpoint would
   * otherwise match: https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
   */
  function normalizePaginatedListResponse(response) {
    // endpoints can respond with 204 if repository is empty
    if (!response.data) {
      return _objectSpread2(_objectSpread2({}, response), {}, {
        data: []
      });
    }
  
    const responseNeedsNormalization = "total_count" in response.data && !("url" in response.data);
    if (!responseNeedsNormalization) return response; // keep the additional properties intact as there is currently no other way
    // to retrieve the same information.
  
    const incompleteResults = response.data.incomplete_results;
    const repositorySelection = response.data.repository_selection;
    const totalCount = response.data.total_count;
    delete response.data.incomplete_results;
    delete response.data.repository_selection;
    delete response.data.total_count;
    const namespaceKey = Object.keys(response.data)[0];
    const data = response.data[namespaceKey];
    response.data = data;
  
    if (typeof incompleteResults !== "undefined") {
      response.data.incomplete_results = incompleteResults;
    }
  
    if (typeof repositorySelection !== "undefined") {
      response.data.repository_selection = repositorySelection;
    }
  
    response.data.total_count = totalCount;
    return response;
  }
  
  function iterator(octokit, route, parameters) {
    const options = typeof route === "function" ? route.endpoint(parameters) : octokit.request.endpoint(route, parameters);
    const requestMethod = typeof route === "function" ? route : octokit.request;
    const method = options.method;
    const headers = options.headers;
    let url = options.url;
    return {
      [Symbol.asyncIterator]: () => ({
        async next() {
          if (!url) return {
            done: true
          };
  
          try {
            const response = await requestMethod({
              method,
              url,
              headers
            });
            const normalizedResponse = normalizePaginatedListResponse(response); // `response.headers.link` format:
            // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
            // sets `url` to undefined if "next" URL is not present or `link` header is not set
  
            url = ((normalizedResponse.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
            return {
              value: normalizedResponse
            };
          } catch (error) {
            if (error.status !== 409) throw error;
            url = "";
            return {
              value: {
                status: 200,
                headers: {},
                data: []
              }
            };
          }
        }
  
      })
    };
  }
  
  function paginate(octokit, route, parameters, mapFn) {
    if (typeof parameters === "function") {
      mapFn = parameters;
      parameters = undefined;
    }
  
    return gather(octokit, [], iterator(octokit, route, parameters)[Symbol.asyncIterator](), mapFn);
  }
  
  function gather(octokit, results, iterator, mapFn) {
    return iterator.next().then(result => {
      if (result.done) {
        return results;
      }
  
      let earlyExit = false;
  
      function done() {
        earlyExit = true;
      }
  
      results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data);
  
      if (earlyExit) {
        return results;
      }
  
      return gather(octokit, results, iterator, mapFn);
    });
  }
  
  const composePaginateRest = Object.assign(paginate, {
    iterator
  });
  
  const paginatingEndpoints = ["GET /app/hook/deliveries", "GET /app/installations", "GET /applications/grants", "GET /authorizations", "GET /enterprises/{enterprise}/actions/permissions/organizations", "GET /enterprises/{enterprise}/actions/runner-groups", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations", "GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners", "GET /enterprises/{enterprise}/actions/runners", "GET /enterprises/{enterprise}/actions/runners/downloads", "GET /events", "GET /gists", "GET /gists/public", "GET /gists/starred", "GET /gists/{gist_id}/comments", "GET /gists/{gist_id}/commits", "GET /gists/{gist_id}/forks", "GET /installation/repositories", "GET /issues", "GET /marketplace_listing/plans", "GET /marketplace_listing/plans/{plan_id}/accounts", "GET /marketplace_listing/stubbed/plans", "GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", "GET /networks/{owner}/{repo}/events", "GET /notifications", "GET /organizations", "GET /orgs/{org}/actions/permissions/repositories", "GET /orgs/{org}/actions/runner-groups", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories", "GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners", "GET /orgs/{org}/actions/runners", "GET /orgs/{org}/actions/runners/downloads", "GET /orgs/{org}/actions/secrets", "GET /orgs/{org}/actions/secrets/{secret_name}/repositories", "GET /orgs/{org}/blocks", "GET /orgs/{org}/credential-authorizations", "GET /orgs/{org}/events", "GET /orgs/{org}/failed_invitations", "GET /orgs/{org}/hooks", "GET /orgs/{org}/hooks/{hook_id}/deliveries", "GET /orgs/{org}/installations", "GET /orgs/{org}/invitations", "GET /orgs/{org}/invitations/{invitation_id}/teams", "GET /orgs/{org}/issues", "GET /orgs/{org}/members", "GET /orgs/{org}/migrations", "GET /orgs/{org}/migrations/{migration_id}/repositories", "GET /orgs/{org}/outside_collaborators", "GET /orgs/{org}/projects", "GET /orgs/{org}/public_members", "GET /orgs/{org}/repos", "GET /orgs/{org}/team-sync/groups", "GET /orgs/{org}/teams", "GET /orgs/{org}/teams/{team_slug}/discussions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", "GET /orgs/{org}/teams/{team_slug}/invitations", "GET /orgs/{org}/teams/{team_slug}/members", "GET /orgs/{org}/teams/{team_slug}/projects", "GET /orgs/{org}/teams/{team_slug}/repos", "GET /orgs/{org}/teams/{team_slug}/team-sync/group-mappings", "GET /orgs/{org}/teams/{team_slug}/teams", "GET /projects/columns/{column_id}/cards", "GET /projects/{project_id}/collaborators", "GET /projects/{project_id}/columns", "GET /repos/{owner}/{repo}/actions/artifacts", "GET /repos/{owner}/{repo}/actions/runners", "GET /repos/{owner}/{repo}/actions/runners/downloads", "GET /repos/{owner}/{repo}/actions/runs", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts", "GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs", "GET /repos/{owner}/{repo}/actions/secrets", "GET /repos/{owner}/{repo}/actions/workflows", "GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs", "GET /repos/{owner}/{repo}/assignees", "GET /repos/{owner}/{repo}/branches", "GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", "GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", "GET /repos/{owner}/{repo}/code-scanning/alerts", "GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances", "GET /repos/{owner}/{repo}/code-scanning/analyses", "GET /repos/{owner}/{repo}/collaborators", "GET /repos/{owner}/{repo}/comments", "GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/commits", "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", "GET /repos/{owner}/{repo}/commits/{commit_sha}/comments", "GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", "GET /repos/{owner}/{repo}/commits/{ref}/check-runs", "GET /repos/{owner}/{repo}/commits/{ref}/check-suites", "GET /repos/{owner}/{repo}/commits/{ref}/statuses", "GET /repos/{owner}/{repo}/contributors", "GET /repos/{owner}/{repo}/deployments", "GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses", "GET /repos/{owner}/{repo}/events", "GET /repos/{owner}/{repo}/forks", "GET /repos/{owner}/{repo}/git/matching-refs/{ref}", "GET /repos/{owner}/{repo}/hooks", "GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries", "GET /repos/{owner}/{repo}/invitations", "GET /repos/{owner}/{repo}/issues", "GET /repos/{owner}/{repo}/issues/comments", "GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/issues/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/comments", "GET /repos/{owner}/{repo}/issues/{issue_number}/events", "GET /repos/{owner}/{repo}/issues/{issue_number}/labels", "GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", "GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", "GET /repos/{owner}/{repo}/keys", "GET /repos/{owner}/{repo}/labels", "GET /repos/{owner}/{repo}/milestones", "GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels", "GET /repos/{owner}/{repo}/notifications", "GET /repos/{owner}/{repo}/pages/builds", "GET /repos/{owner}/{repo}/projects", "GET /repos/{owner}/{repo}/pulls", "GET /repos/{owner}/{repo}/pulls/comments", "GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", "GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", "GET /repos/{owner}/{repo}/pulls/{pull_number}/commits", "GET /repos/{owner}/{repo}/pulls/{pull_number}/files", "GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews", "GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", "GET /repos/{owner}/{repo}/releases", "GET /repos/{owner}/{repo}/releases/{release_id}/assets", "GET /repos/{owner}/{repo}/secret-scanning/alerts", "GET /repos/{owner}/{repo}/stargazers", "GET /repos/{owner}/{repo}/subscribers", "GET /repos/{owner}/{repo}/tags", "GET /repos/{owner}/{repo}/teams", "GET /repositories", "GET /repositories/{repository_id}/environments/{environment_name}/secrets", "GET /scim/v2/enterprises/{enterprise}/Groups", "GET /scim/v2/enterprises/{enterprise}/Users", "GET /scim/v2/organizations/{org}/Users", "GET /search/code", "GET /search/commits", "GET /search/issues", "GET /search/labels", "GET /search/repositories", "GET /search/topics", "GET /search/users", "GET /teams/{team_id}/discussions", "GET /teams/{team_id}/discussions/{discussion_number}/comments", "GET /teams/{team_id}/discussions/{discussion_number}/comments/{comment_number}/reactions", "GET /teams/{team_id}/discussions/{discussion_number}/reactions", "GET /teams/{team_id}/invitations", "GET /teams/{team_id}/members", "GET /teams/{team_id}/projects", "GET /teams/{team_id}/repos", "GET /teams/{team_id}/team-sync/group-mappings", "GET /teams/{team_id}/teams", "GET /user/blocks", "GET /user/emails", "GET /user/followers", "GET /user/following", "GET /user/gpg_keys", "GET /user/installations", "GET /user/installations/{installation_id}/repositories", "GET /user/issues", "GET /user/keys", "GET /user/marketplace_purchases", "GET /user/marketplace_purchases/stubbed", "GET /user/memberships/orgs", "GET /user/migrations", "GET /user/migrations/{migration_id}/repositories", "GET /user/orgs", "GET /user/public_emails", "GET /user/repos", "GET /user/repository_invitations", "GET /user/starred", "GET /user/subscriptions", "GET /user/teams", "GET /users", "GET /users/{username}/events", "GET /users/{username}/events/orgs/{org}", "GET /users/{username}/events/public", "GET /users/{username}/followers", "GET /users/{username}/following", "GET /users/{username}/gists", "GET /users/{username}/gpg_keys", "GET /users/{username}/keys", "GET /users/{username}/orgs", "GET /users/{username}/projects", "GET /users/{username}/received_events", "GET /users/{username}/received_events/public", "GET /users/{username}/repos", "GET /users/{username}/starred", "GET /users/{username}/subscriptions"];
  
  function isPaginatingEndpoint(arg) {
    if (typeof arg === "string") {
      return paginatingEndpoints.includes(arg);
    } else {
      return false;
    }
  }
  
  /**
   * @param octokit Octokit instance
   * @param options Options passed to Octokit constructor
   */
  
  function paginateRest(octokit) {
    return {
      paginate: Object.assign(paginate.bind(null, octokit), {
        iterator: iterator.bind(null, octokit)
      })
    };
  }
  paginateRest.VERSION = VERSION;
  
  exports.composePaginateRest = composePaginateRest;
  exports.isPaginatingEndpoint = isPaginatingEndpoint;
  exports.paginateRest = paginateRest;
  exports.paginatingEndpoints = paginatingEndpoints;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 300 */,
  /* 301 */,
  /* 302 */,
  /* 303 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var isNil =
  /*#__PURE__*/
  __webpack_require__(317);
  /**
   * Returns whether or not a path exists in an object. Only the object's
   * own properties are checked.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig [Idx] -> {a} -> Boolean
   * @param {Array} path The path to use.
   * @param {Object} obj The object to check the path in.
   * @return {Boolean} Whether the path exists.
   * @see R.has
   * @example
   *
   *      R.hasPath(['a', 'b'], {a: {b: 2}});         // => true
   *      R.hasPath(['a', 'b'], {a: {b: undefined}}); // => true
   *      R.hasPath(['a', 'b'], {a: {c: 2}});         // => false
   *      R.hasPath(['a', 'b'], {});                  // => false
   */
  
  
  var hasPath =
  /*#__PURE__*/
  _curry2(function hasPath(_path, obj) {
    if (_path.length === 0 || isNil(obj)) {
      return false;
    }
  
    var val = obj;
    var idx = 0;
  
    while (idx < _path.length) {
      if (!isNil(val) && _has(_path[idx], val)) {
        val = val[_path[idx]];
        idx += 1;
      } else {
        return false;
      }
    }
  
    return true;
  });
  
  module.exports = hasPath;
  
  /***/ }),
  /* 304 */,
  /* 305 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XFindIndex =
  /*#__PURE__*/
  function () {
    function XFindIndex(f, xf) {
      this.xf = xf;
      this.f = f;
      this.idx = -1;
      this.found = false;
    }
  
    XFindIndex.prototype['@@transducer/init'] = _xfBase.init;
  
    XFindIndex.prototype['@@transducer/result'] = function (result) {
      if (!this.found) {
        result = this.xf['@@transducer/step'](result, -1);
      }
  
      return this.xf['@@transducer/result'](result);
    };
  
    XFindIndex.prototype['@@transducer/step'] = function (result, input) {
      this.idx += 1;
  
      if (this.f(input)) {
        this.found = true;
        result = _reduced(this.xf['@@transducer/step'](result, this.idx));
      }
  
      return result;
    };
  
    return XFindIndex;
  }();
  
  var _xfindIndex =
  /*#__PURE__*/
  _curry2(function _xfindIndex(f, xf) {
    return new XFindIndex(f, xf);
  });
  
  module.exports = _xfindIndex;
  
  /***/ }),
  /* 306 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var concatMap = __webpack_require__(896);
  var balanced = __webpack_require__(621);
  
  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;
  }
  
  
  
  /***/ }),
  /* 307 */,
  /* 308 */,
  /* 309 */,
  /* 310 */,
  /* 311 */,
  /* 312 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a partial copy of an object containing only the keys specified. If
   * the key does not exist, the property is ignored.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig [k] -> {k: v} -> {k: v}
   * @param {Array} names an array of String property names to copy onto a new object
   * @param {Object} obj The object to copy from
   * @return {Object} A new object with only properties from `names` on it.
   * @see R.omit, R.props
   * @example
   *
   *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
   *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
   */
  
  
  var pick =
  /*#__PURE__*/
  _curry2(function pick(names, obj) {
    var result = {};
    var idx = 0;
  
    while (idx < names.length) {
      if (names[idx] in obj) {
        result[names[idx]] = obj[names[idx]];
      }
  
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = pick;
  
  /***/ }),
  /* 313 */
  /***/ (function(module) {
  
  function _pipe(f, g) {
    return function () {
      return g.call(this, f.apply(this, arguments));
    };
  }
  
  module.exports = _pipe;
  
  /***/ }),
  /* 314 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var converge =
  /*#__PURE__*/
  __webpack_require__(886);
  /**
   * juxt applies a list of functions to a list of values.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Function
   * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])
   * @param {Array} fns An array of functions
   * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.
   * @see R.applySpec
   * @example
   *
   *      const getRange = R.juxt([Math.min, Math.max]);
   *      getRange(3, 4, 9, -3); //=> [-3, 9]
   * @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)]
   */
  
  
  var juxt =
  /*#__PURE__*/
  _curry1(function juxt(fns) {
    return converge(function () {
      return Array.prototype.slice.call(arguments, 0);
    }, fns);
  });
  
  module.exports = juxt;
  
  /***/ }),
  /* 315 */,
  /* 316 */,
  /* 317 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Checks if the input value is `null` or `undefined`.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Type
   * @sig * -> Boolean
   * @param {*} x The value to test.
   * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.
   * @example
   *
   *      R.isNil(null); //=> true
   *      R.isNil(undefined); //=> true
   *      R.isNil(0); //=> false
   *      R.isNil([]); //=> false
   */
  
  
  var isNil =
  /*#__PURE__*/
  _curry1(function isNil(x) {
    return x == null;
  });
  
  module.exports = isNil;
  
  /***/ }),
  /* 318 */,
  /* 319 */,
  /* 320 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xall =
  /*#__PURE__*/
  __webpack_require__(588);
  /**
   * Returns `true` if all elements of the list match the predicate, `false` if
   * there are any that don't.
   *
   * Dispatches to the `all` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> Boolean
   * @param {Function} fn The predicate function.
   * @param {Array} list The array to consider.
   * @return {Boolean} `true` if the predicate is satisfied by every element, `false`
   *         otherwise.
   * @see R.any, R.none, R.transduce
   * @example
   *
   *      const equals3 = R.equals(3);
   *      R.all(equals3)([3, 3, 3, 3]); //=> true
   *      R.all(equals3)([3, 3, 1, 3]); //=> false
   */
  
  
  var all =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['all'], _xall, function all(fn, list) {
    var idx = 0;
  
    while (idx < list.length) {
      if (!fn(list[idx])) {
        return false;
      }
  
      idx += 1;
    }
  
    return true;
  }));
  
  module.exports = all;
  
  /***/ }),
  /* 321 */,
  /* 322 */,
  /* 323 */
  /***/ (function(module) {
  
  "use strict";
  
  
  var isStream = module.exports = function (stream) {
  	return stream !== null && typeof stream === 'object' && typeof stream.pipe === 'function';
  };
  
  isStream.writable = function (stream) {
  	return isStream(stream) && stream.writable !== false && typeof stream._write === 'function' && typeof stream._writableState === 'object';
  };
  
  isStream.readable = function (stream) {
  	return isStream(stream) && stream.readable !== false && typeof stream._read === 'function' && typeof stream._readableState === 'object';
  };
  
  isStream.duplex = function (stream) {
  	return isStream.writable(stream) && isStream.readable(stream);
  };
  
  isStream.transform = function (stream) {
  	return isStream.duplex(stream) && typeof stream._transform === 'function' && typeof stream._transformState === 'object';
  };
  
  
  /***/ }),
  /* 324 */,
  /* 325 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arrayFromIterator =
  /*#__PURE__*/
  __webpack_require__(798);
  
  var _includesWith =
  /*#__PURE__*/
  __webpack_require__(680);
  
  var _functionName =
  /*#__PURE__*/
  __webpack_require__(885);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var _objectIs =
  /*#__PURE__*/
  __webpack_require__(268);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  
  var type =
  /*#__PURE__*/
  __webpack_require__(552);
  /**
   * private _uniqContentEquals function.
   * That function is checking equality of 2 iterator contents with 2 assumptions
   * - iterators lengths are the same
   * - iterators values are unique
   *
   * false-positive result will be returned for comparision of, e.g.
   * - [1,2,3] and [1,2,3,4]
   * - [1,1,1] and [1,2,3]
   * */
  
  
  function _uniqContentEquals(aIterator, bIterator, stackA, stackB) {
    var a = _arrayFromIterator(aIterator);
  
    var b = _arrayFromIterator(bIterator);
  
    function eq(_a, _b) {
      return _equals(_a, _b, stackA.slice(), stackB.slice());
    } // if *a* array contains any element that is not included in *b*
  
  
    return !_includesWith(function (b, aItem) {
      return !_includesWith(eq, aItem, b);
    }, b, a);
  }
  
  function _equals(a, b, stackA, stackB) {
    if (_objectIs(a, b)) {
      return true;
    }
  
    var typeA = type(a);
  
    if (typeA !== type(b)) {
      return false;
    }
  
    if (a == null || b == null) {
      return false;
    }
  
    if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {
      return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);
    }
  
    if (typeof a.equals === 'function' || typeof b.equals === 'function') {
      return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);
    }
  
    switch (typeA) {
      case 'Arguments':
      case 'Array':
      case 'Object':
        if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {
          return a === b;
        }
  
        break;
  
      case 'Boolean':
      case 'Number':
      case 'String':
        if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {
          return false;
        }
  
        break;
  
      case 'Date':
        if (!_objectIs(a.valueOf(), b.valueOf())) {
          return false;
        }
  
        break;
  
      case 'Error':
        return a.name === b.name && a.message === b.message;
  
      case 'RegExp':
        if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {
          return false;
        }
  
        break;
    }
  
    var idx = stackA.length - 1;
  
    while (idx >= 0) {
      if (stackA[idx] === a) {
        return stackB[idx] === b;
      }
  
      idx -= 1;
    }
  
    switch (typeA) {
      case 'Map':
        if (a.size !== b.size) {
          return false;
        }
  
        return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));
  
      case 'Set':
        if (a.size !== b.size) {
          return false;
        }
  
        return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));
  
      case 'Arguments':
      case 'Array':
      case 'Object':
      case 'Boolean':
      case 'Number':
      case 'String':
      case 'Date':
      case 'Error':
      case 'RegExp':
      case 'Int8Array':
      case 'Uint8Array':
      case 'Uint8ClampedArray':
      case 'Int16Array':
      case 'Uint16Array':
      case 'Int32Array':
      case 'Uint32Array':
      case 'Float32Array':
      case 'Float64Array':
      case 'ArrayBuffer':
        break;
  
      default:
        // Values of other types are only equal if identical.
        return false;
    }
  
    var keysA = keys(a);
  
    if (keysA.length !== keys(b).length) {
      return false;
    }
  
    var extendedStackA = stackA.concat([a]);
    var extendedStackB = stackB.concat([b]);
    idx = keysA.length - 1;
  
    while (idx >= 0) {
      var key = keysA[idx];
  
      if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {
        return false;
      }
  
      idx -= 1;
    }
  
    return true;
  }
  
  module.exports = _equals;
  
  /***/ }),
  /* 326 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var head =
  /*#__PURE__*/
  __webpack_require__(678);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var tail =
  /*#__PURE__*/
  __webpack_require__(193);
  
  var identity =
  /*#__PURE__*/
  __webpack_require__(534);
  /**
   * Performs left-to-right function composition using transforming function. The first argument may have
   * any arity; the remaining arguments must be unary.
   *
   * **Note:** The result of pipeWith is not automatically curried. Transforming function is not used on the
   * first argument.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Function
   * @sig ((* -> *), [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)]) -> ((a, b, ..., n) -> z)
   * @param {...Function} functions
   * @return {Function}
   * @see R.composeWith, R.pipe
   * @example
   *
   *      const pipeWhileNotNil = R.pipeWith((f, res) => R.isNil(res) ? res : f(res));
   *      const f = pipeWhileNotNil([Math.pow, R.negate, R.inc])
   *
   *      f(3, 4); // -(3^4) + 1
   * @symb R.pipeWith(f)([g, h, i])(...args) = f(i, f(h, g(...args)))
   */
  
  
  var pipeWith =
  /*#__PURE__*/
  _curry2(function pipeWith(xf, list) {
    if (list.length <= 0) {
      return identity;
    }
  
    var headList = head(list);
    var tailList = tail(list);
    return _arity(headList.length, function () {
      return _reduce(function (result, f) {
        return xf.call(this, f, result);
      }, headList.apply(this, arguments), tailList);
    });
  });
  
  module.exports = pipeWith;
  
  /***/ }),
  /* 327 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.MatchKind = void 0;
  /**
   * Indicates whether a pattern matches a path
   */
  var MatchKind;
  (function (MatchKind) {
      /** Not matched */
      MatchKind[MatchKind["None"] = 0] = "None";
      /** Matched if the path is a directory */
      MatchKind[MatchKind["Directory"] = 1] = "Directory";
      /** Matched if the path is a regular file */
      MatchKind[MatchKind["File"] = 2] = "File";
      /** Matched */
      MatchKind[MatchKind["All"] = 3] = "All";
  })(MatchKind = exports.MatchKind || (exports.MatchKind = {}));
  //# sourceMappingURL=internal-match-kind.js.map
  
  /***/ }),
  /* 328 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Returns a new function much like the supplied one, except that the first two
   * arguments' order is reversed.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z)
   * @param {Function} fn The function to invoke with its first two parameters reversed.
   * @return {*} The result of invoking `fn` with its first two parameters' order reversed.
   * @example
   *
   *      const mergeThree = (a, b, c) => [].concat(a, b, c);
   *
   *      mergeThree(1, 2, 3); //=> [1, 2, 3]
   *
   *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]
   * @symb R.flip(f)(a, b, c) = f(b, a, c)
   */
  
  
  var flip =
  /*#__PURE__*/
  _curry1(function flip(fn) {
    return curryN(fn.length, function (a, b) {
      var args = Array.prototype.slice.call(arguments, 0);
      args[0] = b;
      args[1] = a;
      return fn.apply(this, args);
    });
  });
  
  module.exports = flip;
  
  /***/ }),
  /* 329 */,
  /* 330 */,
  /* 331 */,
  /* 332 */,
  /* 333 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var reduceBy =
  /*#__PURE__*/
  __webpack_require__(729);
  /**
   * Counts the elements of a list according to how many match each value of a
   * key generated by the supplied function. Returns an object mapping the keys
   * produced by `fn` to the number of occurrences in the list. Note that all
   * keys are coerced to strings because of how JavaScript objects work.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig (a -> String) -> [a] -> {*}
   * @param {Function} fn The function used to map values to keys.
   * @param {Array} list The list to count elements from.
   * @return {Object} An object mapping keys to number of occurrences in the list.
   * @example
   *
   *      const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
   *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}
   *
   *      const letters = ['a', 'b', 'A', 'a', 'B', 'c'];
   *      R.countBy(R.toLower)(letters);   //=> {'a': 3, 'b': 2, 'c': 1}
   */
  
  
  var countBy =
  /*#__PURE__*/
  reduceBy(function (acc, elem) {
    return acc + 1;
  }, 0);
  module.exports = countBy;
  
  /***/ }),
  /* 334 */,
  /* 335 */,
  /* 336 */,
  /* 337 */,
  /* 338 */,
  /* 339 */,
  /* 340 */
  /***/ (function(module) {
  
  /**
   * Private `concat` function to merge two array-like objects.
   *
   * @private
   * @param {Array|Arguments} [set1=[]] An array-like object.
   * @param {Array|Arguments} [set2=[]] An array-like object.
   * @return {Array} A new, merged array.
   * @example
   *
   *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
   */
  function _concat(set1, set2) {
    set1 = set1 || [];
    set2 = set2 || [];
    var idx;
    var len1 = set1.length;
    var len2 = set2.length;
    var result = [];
    idx = 0;
  
    while (idx < len1) {
      result[result.length] = set1[idx];
      idx += 1;
    }
  
    idx = 0;
  
    while (idx < len2) {
      result[result.length] = set2[idx];
      idx += 1;
    }
  
    return result;
  }
  
  module.exports = _concat;
  
  /***/ }),
  /* 341 */,
  /* 342 */,
  /* 343 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  const nameStartChar = ':A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
  const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
  const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*'
  const regexName = new RegExp('^' + nameRegexp + '$');
  
  const getAllMatches = function(string, regex) {
    const matches = [];
    let match = regex.exec(string);
    while (match) {
      const allmatches = [];
      const len = match.length;
      for (let index = 0; index < len; index++) {
        allmatches.push(match[index]);
      }
      matches.push(allmatches);
      match = regex.exec(string);
    }
    return matches;
  };
  
  const isName = function(string) {
    const match = regexName.exec(string);
    return !(match === null || typeof match === 'undefined');
  };
  
  exports.isExist = function(v) {
    return typeof v !== 'undefined';
  };
  
  exports.isEmptyObject = function(obj) {
    return Object.keys(obj).length === 0;
  };
  
  /**
   * Copy all the properties of a into b.
   * @param {*} target
   * @param {*} a
   */
  exports.merge = function(target, a, arrayMode) {
    if (a) {
      const keys = Object.keys(a); // will return an array of own properties
      const len = keys.length; //don't make it inline
      for (let i = 0; i < len; i++) {
        if (arrayMode === 'strict') {
          target[keys[i]] = [ a[keys[i]] ];
        } else {
          target[keys[i]] = a[keys[i]];
        }
      }
    }
  };
  /* exports.merge =function (b,a){
    return Object.assign(b,a);
  } */
  
  exports.getValue = function(v) {
    if (exports.isExist(v)) {
      return v;
    } else {
      return '';
    }
  };
  
  // const fakeCall = function(a) {return a;};
  // const fakeCallNoReturn = function() {};
  
  exports.buildOptions = function(options, defaultOptions, props) {
    var newOptions = {};
    if (!options) {
      return defaultOptions; //if there are not options
    }
  
    for (let i = 0; i < props.length; i++) {
      if (options[props[i]] !== undefined) {
        newOptions[props[i]] = options[props[i]];
      } else {
        newOptions[props[i]] = defaultOptions[props[i]];
      }
    }
    return newOptions;
  };
  
  /**
   * Check if a tag name should be treated as array
   *
   * @param tagName the node tagname
   * @param arrayMode the array mode option
   * @param parentTagName the parent tag name
   * @returns {boolean} true if node should be parsed as array
   */
  exports.isTagNameInArrayMode = function (tagName, arrayMode, parentTagName) {
    if (arrayMode === false) {
      return false;
    } else if (arrayMode instanceof RegExp) {
      return arrayMode.test(tagName);
    } else if (typeof arrayMode === 'function') {
      return !!arrayMode(tagName, parentTagName);
    }
  
    return arrayMode === "strict";
  }
  
  exports.isName = isName;
  exports.getAllMatches = getAllMatches;
  exports.nameRegexp = nameRegexp;
  
  
  /***/ }),
  /* 344 */,
  /* 345 */,
  /* 346 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var empty =
  /*#__PURE__*/
  __webpack_require__(235);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Returns `true` if the given value is its type's empty value; `false`
   * otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Logic
   * @sig a -> Boolean
   * @param {*} x
   * @return {Boolean}
   * @see R.empty
   * @example
   *
   *      R.isEmpty([1, 2, 3]);   //=> false
   *      R.isEmpty([]);          //=> true
   *      R.isEmpty('');          //=> true
   *      R.isEmpty(null);        //=> false
   *      R.isEmpty({});          //=> true
   *      R.isEmpty({length: 0}); //=> false
   */
  
  
  var isEmpty =
  /*#__PURE__*/
  _curry1(function isEmpty(x) {
    return x != null && equals(x, empty(x));
  });
  
  module.exports = isEmpty;
  
  /***/ }),
  /* 347 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _forceReduced =
  /*#__PURE__*/
  __webpack_require__(49);
  
  var _isArrayLike =
  /*#__PURE__*/
  __webpack_require__(260);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var preservingReduced = function (xf) {
    return {
      '@@transducer/init': _xfBase.init,
      '@@transducer/result': function (result) {
        return xf['@@transducer/result'](result);
      },
      '@@transducer/step': function (result, input) {
        var ret = xf['@@transducer/step'](result, input);
        return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;
      }
    };
  };
  
  var _flatCat = function _xcat(xf) {
    var rxf = preservingReduced(xf);
    return {
      '@@transducer/init': _xfBase.init,
      '@@transducer/result': function (result) {
        return rxf['@@transducer/result'](result);
      },
      '@@transducer/step': function (result, input) {
        return !_isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);
      }
    };
  };
  
  module.exports = _flatCat;
  
  /***/ }),
  /* 348 */,
  /* 349 */,
  /* 350 */,
  /* 351 */,
  /* 352 */,
  /* 353 */,
  /* 354 */,
  /* 355 */,
  /* 356 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + '\u2029\uFEFF';
  var zeroWidth = '\u200b';
  var hasProtoTrim = typeof String.prototype.trim === 'function';
  /**
   * Removes (strips) whitespace from both ends of the string.
   *
   * @func
   * @memberOf R
   * @since v0.6.0
   * @category String
   * @sig String -> String
   * @param {String} str The string to trim.
   * @return {String} Trimmed version of `str`.
   * @example
   *
   *      R.trim('   xyz  '); //=> 'xyz'
   *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']
   */
  
  var trim = !hasProtoTrim ||
  /*#__PURE__*/
  ws.trim() || !
  /*#__PURE__*/
  zeroWidth.trim() ?
  /*#__PURE__*/
  _curry1(function trim(str) {
    var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');
    var endRx = new RegExp('[' + ws + '][' + ws + ']*$');
    return str.replace(beginRx, '').replace(endRx, '');
  }) :
  /*#__PURE__*/
  _curry1(function trim(str) {
    return str.trim();
  });
  module.exports = trim;
  
  /***/ }),
  /* 357 */
  /***/ (function(module) {
  
  module.exports = require("assert");
  
  /***/ }),
  /* 358 */,
  /* 359 */
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = opts => {
  	opts = opts || {};
  
  	const env = opts.env || process.env;
  	const platform = opts.platform || process.platform;
  
  	if (platform !== 'win32') {
  		return 'PATH';
  	}
  
  	return Object.keys(env).find(x => x.toUpperCase() === 'PATH') || 'Path';
  };
  
  
  /***/ }),
  /* 360 */,
  /* 361 */,
  /* 362 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Similar to `pick` except that this one includes a `key: undefined` pair for
   * properties that don't exist.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig [k] -> {k: v} -> {k: v}
   * @param {Array} names an array of String property names to copy onto a new object
   * @param {Object} obj The object to copy from
   * @return {Object} A new object with only properties from `names` on it.
   * @see R.pick
   * @example
   *
   *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
   *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
   */
  
  
  var pickAll =
  /*#__PURE__*/
  _curry2(function pickAll(names, obj) {
    var result = {};
    var idx = 0;
    var len = names.length;
  
    while (idx < len) {
      var name = names[idx];
      result[name] = obj[name];
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = pickAll;
  
  /***/ }),
  /* 363 */,
  /* 364 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var length =
  /*#__PURE__*/
  __webpack_require__(262);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Splits a given list or string at a given index.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig Number -> [a] -> [[a], [a]]
   * @sig Number -> String -> [String, String]
   * @param {Number} index The index where the array/string is split.
   * @param {Array|String} array The array/string to be split.
   * @return {Array}
   * @example
   *
   *      R.splitAt(1, [1, 2, 3]);          //=> [[1], [2, 3]]
   *      R.splitAt(5, 'hello world');      //=> ['hello', ' world']
   *      R.splitAt(-1, 'foobar');          //=> ['fooba', 'r']
   */
  
  
  var splitAt =
  /*#__PURE__*/
  _curry2(function splitAt(index, array) {
    return [slice(0, index, array), slice(index, length(array), array)];
  });
  
  module.exports = splitAt;
  
  /***/ }),
  /* 365 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _dropLast =
  /*#__PURE__*/
  __webpack_require__(603);
  
  var _xdropLast =
  /*#__PURE__*/
  __webpack_require__(560);
  /**
   * Returns a list containing all but the last `n` elements of the given `list`.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig Number -> [a] -> [a]
   * @sig Number -> String -> String
   * @param {Number} n The number of elements of `list` to skip.
   * @param {Array} list The list of elements to consider.
   * @return {Array} A copy of the list with only the first `list.length - n` elements
   * @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile
   * @example
   *
   *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
   *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']
   *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []
   *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []
   *      R.dropLast(3, 'ramda');               //=> 'ra'
   */
  
  
  var dropLast =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xdropLast, _dropLast));
  
  module.exports = dropLast;
  
  /***/ }),
  /* 366 */,
  /* 367 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includesWith =
  /*#__PURE__*/
  __webpack_require__(680);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _filter =
  /*#__PURE__*/
  __webpack_require__(695);
  /**
   * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list
   * `xs'` comprising each of the elements of `xs` which is equal to one or more
   * elements of `ys` according to `pred`.
   *
   * `pred` must be a binary function expecting an element from each list.
   *
   * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should
   * not be significant, but since `xs'` is ordered the implementation guarantees
   * that its values are in the same order as they appear in `xs`. Duplicates are
   * not removed, so `xs'` may contain duplicates if `xs` contains duplicates.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Relation
   * @sig ((a, b) -> Boolean) -> [a] -> [b] -> [a]
   * @param {Function} pred
   * @param {Array} xs
   * @param {Array} ys
   * @return {Array}
   * @see R.intersection
   * @example
   *
   *      R.innerJoin(
   *        (record, id) => record.id === id,
   *        [{id: 824, name: 'Richie Furay'},
   *         {id: 956, name: 'Dewey Martin'},
   *         {id: 313, name: 'Bruce Palmer'},
   *         {id: 456, name: 'Stephen Stills'},
   *         {id: 177, name: 'Neil Young'}],
   *        [177, 456, 999]
   *      );
   *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]
   */
  
  
  var innerJoin =
  /*#__PURE__*/
  _curry3(function innerJoin(pred, xs, ys) {
    return _filter(function (x) {
      return _includesWith(pred, x, ys);
    }, xs);
  });
  
  module.exports = innerJoin;
  
  /***/ }),
  /* 368 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var filter =
  /*#__PURE__*/
  __webpack_require__(80);
  
  var juxt =
  /*#__PURE__*/
  __webpack_require__(314);
  
  var reject =
  /*#__PURE__*/
  __webpack_require__(92);
  /**
   * Takes a predicate and a list or other `Filterable` object and returns the
   * pair of filterable objects of the same type of elements which do and do not
   * satisfy, the predicate, respectively. Filterable objects include plain objects or any object
   * that has a filter method such as `Array`.
   *
   * @func
   * @memberOf R
   * @since v0.1.4
   * @category List
   * @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a]
   * @param {Function} pred A predicate to determine which side the element belongs to.
   * @param {Array} filterable the list (or other filterable) to partition.
   * @return {Array} An array, containing first the subset of elements that satisfy the
   *         predicate, and second the subset of elements that do not satisfy.
   * @see R.filter, R.reject
   * @example
   *
   *      R.partition(R.includes('s'), ['sss', 'ttt', 'foo', 'bars']);
   *      // => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]
   *
   *      R.partition(R.includes('s'), { a: 'sss', b: 'ttt', foo: 'bars' });
   *      // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]
   */
  
  
  var partition =
  /*#__PURE__*/
  juxt([filter, reject]);
  module.exports = partition;
  
  /***/ }),
  /* 369 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var Stream = _interopDefault(__webpack_require__(418));
  var http = _interopDefault(__webpack_require__(605));
  var Url = _interopDefault(__webpack_require__(835));
  var https = _interopDefault(__webpack_require__(34));
  var zlib = _interopDefault(__webpack_require__(761));
  
  // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
  
  // fix for "Readable" isn't a named export issue
  const Readable = Stream.Readable;
  
  const BUFFER = Symbol('buffer');
  const TYPE = Symbol('type');
  
  class Blob {
  	constructor() {
  		this[TYPE] = '';
  
  		const blobParts = arguments[0];
  		const options = arguments[1];
  
  		const buffers = [];
  		let size = 0;
  
  		if (blobParts) {
  			const a = blobParts;
  			const length = Number(a.length);
  			for (let i = 0; i < length; i++) {
  				const element = a[i];
  				let buffer;
  				if (element instanceof Buffer) {
  					buffer = element;
  				} else if (ArrayBuffer.isView(element)) {
  					buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
  				} else if (element instanceof ArrayBuffer) {
  					buffer = Buffer.from(element);
  				} else if (element instanceof Blob) {
  					buffer = element[BUFFER];
  				} else {
  					buffer = Buffer.from(typeof element === 'string' ? element : String(element));
  				}
  				size += buffer.length;
  				buffers.push(buffer);
  			}
  		}
  
  		this[BUFFER] = Buffer.concat(buffers);
  
  		let type = options && options.type !== undefined && String(options.type).toLowerCase();
  		if (type && !/[^\u0020-\u007E]/.test(type)) {
  			this[TYPE] = type;
  		}
  	}
  	get size() {
  		return this[BUFFER].length;
  	}
  	get type() {
  		return this[TYPE];
  	}
  	text() {
  		return Promise.resolve(this[BUFFER].toString());
  	}
  	arrayBuffer() {
  		const buf = this[BUFFER];
  		const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		return Promise.resolve(ab);
  	}
  	stream() {
  		const readable = new Readable();
  		readable._read = function () {};
  		readable.push(this[BUFFER]);
  		readable.push(null);
  		return readable;
  	}
  	toString() {
  		return '[object Blob]';
  	}
  	slice() {
  		const size = this.size;
  
  		const start = arguments[0];
  		const end = arguments[1];
  		let relativeStart, relativeEnd;
  		if (start === undefined) {
  			relativeStart = 0;
  		} else if (start < 0) {
  			relativeStart = Math.max(size + start, 0);
  		} else {
  			relativeStart = Math.min(start, size);
  		}
  		if (end === undefined) {
  			relativeEnd = size;
  		} else if (end < 0) {
  			relativeEnd = Math.max(size + end, 0);
  		} else {
  			relativeEnd = Math.min(end, size);
  		}
  		const span = Math.max(relativeEnd - relativeStart, 0);
  
  		const buffer = this[BUFFER];
  		const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
  		const blob = new Blob([], { type: arguments[2] });
  		blob[BUFFER] = slicedBuffer;
  		return blob;
  	}
  }
  
  Object.defineProperties(Blob.prototype, {
  	size: { enumerable: true },
  	type: { enumerable: true },
  	slice: { enumerable: true }
  });
  
  Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
  	value: 'Blob',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * fetch-error.js
   *
   * FetchError interface for operational errors
   */
  
  /**
   * Create FetchError instance
   *
   * @param   String      message      Error message for human
   * @param   String      type         Error type for machine
   * @param   String      systemError  For Node.js system error
   * @return  FetchError
   */
  function FetchError(message, type, systemError) {
    Error.call(this, message);
  
    this.message = message;
    this.type = type;
  
    // when err.type is `system`, err.code contains system error code
    if (systemError) {
      this.code = this.errno = systemError.code;
    }
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  FetchError.prototype = Object.create(Error.prototype);
  FetchError.prototype.constructor = FetchError;
  FetchError.prototype.name = 'FetchError';
  
  let convert;
  try {
  	convert = __webpack_require__(18).convert;
  } catch (e) {}
  
  const INTERNALS = Symbol('Body internals');
  
  // fix an issue where "PassThrough" isn't a named export for node <10
  const PassThrough = Stream.PassThrough;
  
  /**
   * Body mixin
   *
   * Ref: https://fetch.spec.whatwg.org/#body
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  function Body(body) {
  	var _this = this;
  
  	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  	    _ref$size = _ref.size;
  
  	let size = _ref$size === undefined ? 0 : _ref$size;
  	var _ref$timeout = _ref.timeout;
  	let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
  
  	if (body == null) {
  		// body is undefined or null
  		body = null;
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		body = Buffer.from(body.toString());
  	} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		body = Buffer.from(body);
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
  	} else if (body instanceof Stream) ; else {
  		// none of the above
  		// coerce to string then buffer
  		body = Buffer.from(String(body));
  	}
  	this[INTERNALS] = {
  		body,
  		disturbed: false,
  		error: null
  	};
  	this.size = size;
  	this.timeout = timeout;
  
  	if (body instanceof Stream) {
  		body.on('error', function (err) {
  			const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
  			_this[INTERNALS].error = error;
  		});
  	}
  }
  
  Body.prototype = {
  	get body() {
  		return this[INTERNALS].body;
  	},
  
  	get bodyUsed() {
  		return this[INTERNALS].disturbed;
  	},
  
  	/**
    * Decode response as ArrayBuffer
    *
    * @return  Promise
    */
  	arrayBuffer() {
  		return consumeBody.call(this).then(function (buf) {
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		});
  	},
  
  	/**
    * Return raw response as Blob
    *
    * @return Promise
    */
  	blob() {
  		let ct = this.headers && this.headers.get('content-type') || '';
  		return consumeBody.call(this).then(function (buf) {
  			return Object.assign(
  			// Prevent copying
  			new Blob([], {
  				type: ct.toLowerCase()
  			}), {
  				[BUFFER]: buf
  			});
  		});
  	},
  
  	/**
    * Decode response as json
    *
    * @return  Promise
    */
  	json() {
  		var _this2 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			try {
  				return JSON.parse(buffer.toString());
  			} catch (err) {
  				return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
  			}
  		});
  	},
  
  	/**
    * Decode response as text
    *
    * @return  Promise
    */
  	text() {
  		return consumeBody.call(this).then(function (buffer) {
  			return buffer.toString();
  		});
  	},
  
  	/**
    * Decode response as buffer (non-spec api)
    *
    * @return  Promise
    */
  	buffer() {
  		return consumeBody.call(this);
  	},
  
  	/**
    * Decode response as text, while automatically detecting the encoding and
    * trying to decode to UTF-8 (non-spec api)
    *
    * @return  Promise
    */
  	textConverted() {
  		var _this3 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			return convertBody(buffer, _this3.headers);
  		});
  	}
  };
  
  // In browsers, all properties are enumerable.
  Object.defineProperties(Body.prototype, {
  	body: { enumerable: true },
  	bodyUsed: { enumerable: true },
  	arrayBuffer: { enumerable: true },
  	blob: { enumerable: true },
  	json: { enumerable: true },
  	text: { enumerable: true }
  });
  
  Body.mixIn = function (proto) {
  	for (const name of Object.getOwnPropertyNames(Body.prototype)) {
  		// istanbul ignore else: future proof
  		if (!(name in proto)) {
  			const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
  			Object.defineProperty(proto, name, desc);
  		}
  	}
  };
  
  /**
   * Consume and convert an entire Body to a Buffer.
   *
   * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
   *
   * @return  Promise
   */
  function consumeBody() {
  	var _this4 = this;
  
  	if (this[INTERNALS].disturbed) {
  		return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
  	}
  
  	this[INTERNALS].disturbed = true;
  
  	if (this[INTERNALS].error) {
  		return Body.Promise.reject(this[INTERNALS].error);
  	}
  
  	let body = this.body;
  
  	// body is null
  	if (body === null) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is blob
  	if (isBlob(body)) {
  		body = body.stream();
  	}
  
  	// body is buffer
  	if (Buffer.isBuffer(body)) {
  		return Body.Promise.resolve(body);
  	}
  
  	// istanbul ignore if: should never happen
  	if (!(body instanceof Stream)) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is stream
  	// get ready to actually consume the body
  	let accum = [];
  	let accumBytes = 0;
  	let abort = false;
  
  	return new Body.Promise(function (resolve, reject) {
  		let resTimeout;
  
  		// allow timeout on slow response body
  		if (_this4.timeout) {
  			resTimeout = setTimeout(function () {
  				abort = true;
  				reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
  			}, _this4.timeout);
  		}
  
  		// handle stream errors
  		body.on('error', function (err) {
  			if (err.name === 'AbortError') {
  				// if the request was aborted, reject with this Error
  				abort = true;
  				reject(err);
  			} else {
  				// other errors, such as incorrect content-encoding
  				reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  
  		body.on('data', function (chunk) {
  			if (abort || chunk === null) {
  				return;
  			}
  
  			if (_this4.size && accumBytes + chunk.length > _this4.size) {
  				abort = true;
  				reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
  				return;
  			}
  
  			accumBytes += chunk.length;
  			accum.push(chunk);
  		});
  
  		body.on('end', function () {
  			if (abort) {
  				return;
  			}
  
  			clearTimeout(resTimeout);
  
  			try {
  				resolve(Buffer.concat(accum, accumBytes));
  			} catch (err) {
  				// handle streams that have accumulated too much data (issue #414)
  				reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  	});
  }
  
  /**
   * Detect buffer encoding and convert to target encoding
   * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
   *
   * @param   Buffer  buffer    Incoming buffer
   * @param   String  encoding  Target encoding
   * @return  String
   */
  function convertBody(buffer, headers) {
  	if (typeof convert !== 'function') {
  		throw new Error('The package `encoding` must be installed to use the textConverted() function');
  	}
  
  	const ct = headers.get('content-type');
  	let charset = 'utf-8';
  	let res, str;
  
  	// header
  	if (ct) {
  		res = /charset=([^;]*)/i.exec(ct);
  	}
  
  	// no charset in content type, peek at response body for at most 1024 bytes
  	str = buffer.slice(0, 1024).toString();
  
  	// html5
  	if (!res && str) {
  		res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// html4
  	if (!res && str) {
  		res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
  		if (!res) {
  			res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
  			if (res) {
  				res.pop(); // drop last quote
  			}
  		}
  
  		if (res) {
  			res = /charset=(.*)/i.exec(res.pop());
  		}
  	}
  
  	// xml
  	if (!res && str) {
  		res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// found charset
  	if (res) {
  		charset = res.pop();
  
  		// prevent decode issues when sites use incorrect encoding
  		// ref: https://hsivonen.fi/encoding-menu/
  		if (charset === 'gb2312' || charset === 'gbk') {
  			charset = 'gb18030';
  		}
  	}
  
  	// turn raw buffers into a single utf-8 buffer
  	return convert(buffer, 'UTF-8', charset).toString();
  }
  
  /**
   * Detect a URLSearchParams object
   * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
   *
   * @param   Object  obj     Object to detect by type or brand
   * @return  String
   */
  function isURLSearchParams(obj) {
  	// Duck-typing as a necessary condition.
  	if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
  		return false;
  	}
  
  	// Brand-checking and more duck-typing as optional condition.
  	return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
  }
  
  /**
   * Check if `obj` is a W3C `Blob` object (which `File` inherits from)
   * @param  {*} obj
   * @return {boolean}
   */
  function isBlob(obj) {
  	return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
  }
  
  /**
   * Clone body given Res/Req instance
   *
   * @param   Mixed  instance  Response or Request instance
   * @return  Mixed
   */
  function clone(instance) {
  	let p1, p2;
  	let body = instance.body;
  
  	// don't allow cloning a used body
  	if (instance.bodyUsed) {
  		throw new Error('cannot clone body after it is used');
  	}
  
  	// check that body is a stream and not form-data object
  	// note: we can't clone the form-data object without having it as a dependency
  	if (body instanceof Stream && typeof body.getBoundary !== 'function') {
  		// tee instance body
  		p1 = new PassThrough();
  		p2 = new PassThrough();
  		body.pipe(p1);
  		body.pipe(p2);
  		// set instance body to teed body and return the other teed body
  		instance[INTERNALS].body = p1;
  		body = p2;
  	}
  
  	return body;
  }
  
  /**
   * Performs the operation "extract a `Content-Type` value from |object|" as
   * specified in the specification:
   * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
   *
   * This function assumes that instance.body is present.
   *
   * @param   Mixed  instance  Any options.body input
   */
  function extractContentType(body) {
  	if (body === null) {
  		// body is null
  		return null;
  	} else if (typeof body === 'string') {
  		// body is string
  		return 'text/plain;charset=UTF-8';
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		return 'application/x-www-form-urlencoded;charset=UTF-8';
  	} else if (isBlob(body)) {
  		// body is blob
  		return body.type || null;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return null;
  	} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		return null;
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		return null;
  	} else if (typeof body.getBoundary === 'function') {
  		// detect form data input from form-data module
  		return `multipart/form-data;boundary=${body.getBoundary()}`;
  	} else if (body instanceof Stream) {
  		// body is stream
  		// can't really do much about this
  		return null;
  	} else {
  		// Body constructor defaults other things to string
  		return 'text/plain;charset=UTF-8';
  	}
  }
  
  /**
   * The Fetch Standard treats this as if "total bytes" is a property on the body.
   * For us, we have to explicitly get it with a function.
   *
   * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
   *
   * @param   Body    instance   Instance of Body
   * @return  Number?            Number of bytes, or null if not possible
   */
  function getTotalBytes(instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		return 0;
  	} else if (isBlob(body)) {
  		return body.size;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return body.length;
  	} else if (body && typeof body.getLengthSync === 'function') {
  		// detect form data input from form-data module
  		if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
  		body.hasKnownLength && body.hasKnownLength()) {
  			// 2.x
  			return body.getLengthSync();
  		}
  		return null;
  	} else {
  		// body is stream
  		return null;
  	}
  }
  
  /**
   * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
   *
   * @param   Body    instance   Instance of Body
   * @return  Void
   */
  function writeToStream(dest, instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		dest.end();
  	} else if (isBlob(body)) {
  		body.stream().pipe(dest);
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		dest.write(body);
  		dest.end();
  	} else {
  		// body is stream
  		body.pipe(dest);
  	}
  }
  
  // expose Promise
  Body.Promise = global.Promise;
  
  /**
   * headers.js
   *
   * Headers class offers convenient helpers
   */
  
  const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
  const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
  
  function validateName(name) {
  	name = `${name}`;
  	if (invalidTokenRegex.test(name) || name === '') {
  		throw new TypeError(`${name} is not a legal HTTP header name`);
  	}
  }
  
  function validateValue(value) {
  	value = `${value}`;
  	if (invalidHeaderCharRegex.test(value)) {
  		throw new TypeError(`${value} is not a legal HTTP header value`);
  	}
  }
  
  /**
   * Find the key in the map object given a header name.
   *
   * Returns undefined if not found.
   *
   * @param   String  name  Header name
   * @return  String|Undefined
   */
  function find(map, name) {
  	name = name.toLowerCase();
  	for (const key in map) {
  		if (key.toLowerCase() === name) {
  			return key;
  		}
  	}
  	return undefined;
  }
  
  const MAP = Symbol('map');
  class Headers {
  	/**
    * Headers class
    *
    * @param   Object  headers  Response headers
    * @return  Void
    */
  	constructor() {
  		let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
  		this[MAP] = Object.create(null);
  
  		if (init instanceof Headers) {
  			const rawHeaders = init.raw();
  			const headerNames = Object.keys(rawHeaders);
  
  			for (const headerName of headerNames) {
  				for (const value of rawHeaders[headerName]) {
  					this.append(headerName, value);
  				}
  			}
  
  			return;
  		}
  
  		// We don't worry about converting prop to ByteString here as append()
  		// will handle it.
  		if (init == null) ; else if (typeof init === 'object') {
  			const method = init[Symbol.iterator];
  			if (method != null) {
  				if (typeof method !== 'function') {
  					throw new TypeError('Header pairs must be iterable');
  				}
  
  				// sequence<sequence<ByteString>>
  				// Note: per spec we have to first exhaust the lists then process them
  				const pairs = [];
  				for (const pair of init) {
  					if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
  						throw new TypeError('Each header pair must be iterable');
  					}
  					pairs.push(Array.from(pair));
  				}
  
  				for (const pair of pairs) {
  					if (pair.length !== 2) {
  						throw new TypeError('Each header pair must be a name/value tuple');
  					}
  					this.append(pair[0], pair[1]);
  				}
  			} else {
  				// record<ByteString, ByteString>
  				for (const key of Object.keys(init)) {
  					const value = init[key];
  					this.append(key, value);
  				}
  			}
  		} else {
  			throw new TypeError('Provided initializer must be an object');
  		}
  	}
  
  	/**
    * Return combined header value given name
    *
    * @param   String  name  Header name
    * @return  Mixed
    */
  	get(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key === undefined) {
  			return null;
  		}
  
  		return this[MAP][key].join(', ');
  	}
  
  	/**
    * Iterate over all headers
    *
    * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
    * @param   Boolean   thisArg   `this` context for callback function
    * @return  Void
    */
  	forEach(callback) {
  		let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
  		let pairs = getHeaders(this);
  		let i = 0;
  		while (i < pairs.length) {
  			var _pairs$i = pairs[i];
  			const name = _pairs$i[0],
  			      value = _pairs$i[1];
  
  			callback.call(thisArg, value, name, this);
  			pairs = getHeaders(this);
  			i++;
  		}
  	}
  
  	/**
    * Overwrite header values given name
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	set(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		this[MAP][key !== undefined ? key : name] = [value];
  	}
  
  	/**
    * Append a value onto existing header
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	append(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			this[MAP][key].push(value);
  		} else {
  			this[MAP][name] = [value];
  		}
  	}
  
  	/**
    * Check for header name existence
    *
    * @param   String   name  Header name
    * @return  Boolean
    */
  	has(name) {
  		name = `${name}`;
  		validateName(name);
  		return find(this[MAP], name) !== undefined;
  	}
  
  	/**
    * Delete all header values given name
    *
    * @param   String  name  Header name
    * @return  Void
    */
  	delete(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			delete this[MAP][key];
  		}
  	}
  
  	/**
    * Return raw headers (non-spec api)
    *
    * @return  Object
    */
  	raw() {
  		return this[MAP];
  	}
  
  	/**
    * Get an iterator on keys.
    *
    * @return  Iterator
    */
  	keys() {
  		return createHeadersIterator(this, 'key');
  	}
  
  	/**
    * Get an iterator on values.
    *
    * @return  Iterator
    */
  	values() {
  		return createHeadersIterator(this, 'value');
  	}
  
  	/**
    * Get an iterator on entries.
    *
    * This is the default iterator of the Headers object.
    *
    * @return  Iterator
    */
  	[Symbol.iterator]() {
  		return createHeadersIterator(this, 'key+value');
  	}
  }
  Headers.prototype.entries = Headers.prototype[Symbol.iterator];
  
  Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
  	value: 'Headers',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Headers.prototype, {
  	get: { enumerable: true },
  	forEach: { enumerable: true },
  	set: { enumerable: true },
  	append: { enumerable: true },
  	has: { enumerable: true },
  	delete: { enumerable: true },
  	keys: { enumerable: true },
  	values: { enumerable: true },
  	entries: { enumerable: true }
  });
  
  function getHeaders(headers) {
  	let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
  
  	const keys = Object.keys(headers[MAP]).sort();
  	return keys.map(kind === 'key' ? function (k) {
  		return k.toLowerCase();
  	} : kind === 'value' ? function (k) {
  		return headers[MAP][k].join(', ');
  	} : function (k) {
  		return [k.toLowerCase(), headers[MAP][k].join(', ')];
  	});
  }
  
  const INTERNAL = Symbol('internal');
  
  function createHeadersIterator(target, kind) {
  	const iterator = Object.create(HeadersIteratorPrototype);
  	iterator[INTERNAL] = {
  		target,
  		kind,
  		index: 0
  	};
  	return iterator;
  }
  
  const HeadersIteratorPrototype = Object.setPrototypeOf({
  	next() {
  		// istanbul ignore if
  		if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
  			throw new TypeError('Value of `this` is not a HeadersIterator');
  		}
  
  		var _INTERNAL = this[INTERNAL];
  		const target = _INTERNAL.target,
  		      kind = _INTERNAL.kind,
  		      index = _INTERNAL.index;
  
  		const values = getHeaders(target, kind);
  		const len = values.length;
  		if (index >= len) {
  			return {
  				value: undefined,
  				done: true
  			};
  		}
  
  		this[INTERNAL].index = index + 1;
  
  		return {
  			value: values[index],
  			done: false
  		};
  	}
  }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
  
  Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
  	value: 'HeadersIterator',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * Export the Headers object in a form that Node.js can consume.
   *
   * @param   Headers  headers
   * @return  Object
   */
  function exportNodeCompatibleHeaders(headers) {
  	const obj = Object.assign({ __proto__: null }, headers[MAP]);
  
  	// http.request() only supports string as Host header. This hack makes
  	// specifying custom Host header possible.
  	const hostHeaderKey = find(headers[MAP], 'Host');
  	if (hostHeaderKey !== undefined) {
  		obj[hostHeaderKey] = obj[hostHeaderKey][0];
  	}
  
  	return obj;
  }
  
  /**
   * Create a Headers object from an object of headers, ignoring those that do
   * not conform to HTTP grammar productions.
   *
   * @param   Object  obj  Object of headers
   * @return  Headers
   */
  function createHeadersLenient(obj) {
  	const headers = new Headers();
  	for (const name of Object.keys(obj)) {
  		if (invalidTokenRegex.test(name)) {
  			continue;
  		}
  		if (Array.isArray(obj[name])) {
  			for (const val of obj[name]) {
  				if (invalidHeaderCharRegex.test(val)) {
  					continue;
  				}
  				if (headers[MAP][name] === undefined) {
  					headers[MAP][name] = [val];
  				} else {
  					headers[MAP][name].push(val);
  				}
  			}
  		} else if (!invalidHeaderCharRegex.test(obj[name])) {
  			headers[MAP][name] = [obj[name]];
  		}
  	}
  	return headers;
  }
  
  const INTERNALS$1 = Symbol('Response internals');
  
  // fix an issue where "STATUS_CODES" aren't a named export for node <10
  const STATUS_CODES = http.STATUS_CODES;
  
  /**
   * Response class
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  class Response {
  	constructor() {
  		let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
  		let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		Body.call(this, body, opts);
  
  		const status = opts.status || 200;
  		const headers = new Headers(opts.headers);
  
  		if (body != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(body);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		this[INTERNALS$1] = {
  			url: opts.url,
  			status,
  			statusText: opts.statusText || STATUS_CODES[status],
  			headers,
  			counter: opts.counter
  		};
  	}
  
  	get url() {
  		return this[INTERNALS$1].url || '';
  	}
  
  	get status() {
  		return this[INTERNALS$1].status;
  	}
  
  	/**
    * Convenience property representing if the request ended normally
    */
  	get ok() {
  		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
  	}
  
  	get redirected() {
  		return this[INTERNALS$1].counter > 0;
  	}
  
  	get statusText() {
  		return this[INTERNALS$1].statusText;
  	}
  
  	get headers() {
  		return this[INTERNALS$1].headers;
  	}
  
  	/**
    * Clone this response
    *
    * @return  Response
    */
  	clone() {
  		return new Response(clone(this), {
  			url: this.url,
  			status: this.status,
  			statusText: this.statusText,
  			headers: this.headers,
  			ok: this.ok,
  			redirected: this.redirected
  		});
  	}
  }
  
  Body.mixIn(Response.prototype);
  
  Object.defineProperties(Response.prototype, {
  	url: { enumerable: true },
  	status: { enumerable: true },
  	ok: { enumerable: true },
  	redirected: { enumerable: true },
  	statusText: { enumerable: true },
  	headers: { enumerable: true },
  	clone: { enumerable: true }
  });
  
  Object.defineProperty(Response.prototype, Symbol.toStringTag, {
  	value: 'Response',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  const INTERNALS$2 = Symbol('Request internals');
  
  // fix an issue where "format", "parse" aren't a named export for node <10
  const parse_url = Url.parse;
  const format_url = Url.format;
  
  const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
  
  /**
   * Check if a value is an instance of Request.
   *
   * @param   Mixed   input
   * @return  Boolean
   */
  function isRequest(input) {
  	return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
  }
  
  function isAbortSignal(signal) {
  	const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
  	return !!(proto && proto.constructor.name === 'AbortSignal');
  }
  
  /**
   * Request class
   *
   * @param   Mixed   input  Url or Request instance
   * @param   Object  init   Custom options
   * @return  Void
   */
  class Request {
  	constructor(input) {
  		let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		let parsedURL;
  
  		// normalize input
  		if (!isRequest(input)) {
  			if (input && input.href) {
  				// in order to support Node.js' Url objects; though WHATWG's URL objects
  				// will fall into this branch also (since their `toString()` will return
  				// `href` property anyway)
  				parsedURL = parse_url(input.href);
  			} else {
  				// coerce input to a string before attempting to parse
  				parsedURL = parse_url(`${input}`);
  			}
  			input = {};
  		} else {
  			parsedURL = parse_url(input.url);
  		}
  
  		let method = init.method || input.method || 'GET';
  		method = method.toUpperCase();
  
  		if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
  			throw new TypeError('Request with GET/HEAD method cannot have body');
  		}
  
  		let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
  
  		Body.call(this, inputBody, {
  			timeout: init.timeout || input.timeout || 0,
  			size: init.size || input.size || 0
  		});
  
  		const headers = new Headers(init.headers || input.headers || {});
  
  		if (inputBody != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(inputBody);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		let signal = isRequest(input) ? input.signal : null;
  		if ('signal' in init) signal = init.signal;
  
  		if (signal != null && !isAbortSignal(signal)) {
  			throw new TypeError('Expected signal to be an instanceof AbortSignal');
  		}
  
  		this[INTERNALS$2] = {
  			method,
  			redirect: init.redirect || input.redirect || 'follow',
  			headers,
  			parsedURL,
  			signal
  		};
  
  		// node-fetch-only options
  		this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
  		this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
  		this.counter = init.counter || input.counter || 0;
  		this.agent = init.agent || input.agent;
  	}
  
  	get method() {
  		return this[INTERNALS$2].method;
  	}
  
  	get url() {
  		return format_url(this[INTERNALS$2].parsedURL);
  	}
  
  	get headers() {
  		return this[INTERNALS$2].headers;
  	}
  
  	get redirect() {
  		return this[INTERNALS$2].redirect;
  	}
  
  	get signal() {
  		return this[INTERNALS$2].signal;
  	}
  
  	/**
    * Clone this request
    *
    * @return  Request
    */
  	clone() {
  		return new Request(this);
  	}
  }
  
  Body.mixIn(Request.prototype);
  
  Object.defineProperty(Request.prototype, Symbol.toStringTag, {
  	value: 'Request',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Request.prototype, {
  	method: { enumerable: true },
  	url: { enumerable: true },
  	headers: { enumerable: true },
  	redirect: { enumerable: true },
  	clone: { enumerable: true },
  	signal: { enumerable: true }
  });
  
  /**
   * Convert a Request to Node.js http request options.
   *
   * @param   Request  A Request instance
   * @return  Object   The options object to be passed to http.request
   */
  function getNodeRequestOptions(request) {
  	const parsedURL = request[INTERNALS$2].parsedURL;
  	const headers = new Headers(request[INTERNALS$2].headers);
  
  	// fetch step 1.3
  	if (!headers.has('Accept')) {
  		headers.set('Accept', '*/*');
  	}
  
  	// Basic fetch
  	if (!parsedURL.protocol || !parsedURL.hostname) {
  		throw new TypeError('Only absolute URLs are supported');
  	}
  
  	if (!/^https?:$/.test(parsedURL.protocol)) {
  		throw new TypeError('Only HTTP(S) protocols are supported');
  	}
  
  	if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
  		throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
  	}
  
  	// HTTP-network-or-cache fetch steps 2.4-2.7
  	let contentLengthValue = null;
  	if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
  		contentLengthValue = '0';
  	}
  	if (request.body != null) {
  		const totalBytes = getTotalBytes(request);
  		if (typeof totalBytes === 'number') {
  			contentLengthValue = String(totalBytes);
  		}
  	}
  	if (contentLengthValue) {
  		headers.set('Content-Length', contentLengthValue);
  	}
  
  	// HTTP-network-or-cache fetch step 2.11
  	if (!headers.has('User-Agent')) {
  		headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
  	}
  
  	// HTTP-network-or-cache fetch step 2.15
  	if (request.compress && !headers.has('Accept-Encoding')) {
  		headers.set('Accept-Encoding', 'gzip,deflate');
  	}
  
  	let agent = request.agent;
  	if (typeof agent === 'function') {
  		agent = agent(parsedURL);
  	}
  
  	if (!headers.has('Connection') && !agent) {
  		headers.set('Connection', 'close');
  	}
  
  	// HTTP-network fetch step 4.2
  	// chunked encoding is handled by Node.js
  
  	return Object.assign({}, parsedURL, {
  		method: request.method,
  		headers: exportNodeCompatibleHeaders(headers),
  		agent
  	});
  }
  
  /**
   * abort-error.js
   *
   * AbortError interface for cancelled requests
   */
  
  /**
   * Create AbortError instance
   *
   * @param   String      message      Error message for human
   * @return  AbortError
   */
  function AbortError(message) {
    Error.call(this, message);
  
    this.type = 'aborted';
    this.message = message;
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  AbortError.prototype = Object.create(Error.prototype);
  AbortError.prototype.constructor = AbortError;
  AbortError.prototype.name = 'AbortError';
  
  // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
  const PassThrough$1 = Stream.PassThrough;
  const resolve_url = Url.resolve;
  
  /**
   * Fetch function
   *
   * @param   Mixed    url   Absolute url or Request instance
   * @param   Object   opts  Fetch options
   * @return  Promise
   */
  function fetch(url, opts) {
  
  	// allow custom promise
  	if (!fetch.Promise) {
  		throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
  	}
  
  	Body.Promise = fetch.Promise;
  
  	// wrap http.request into fetch
  	return new fetch.Promise(function (resolve, reject) {
  		// build request object
  		const request = new Request(url, opts);
  		const options = getNodeRequestOptions(request);
  
  		const send = (options.protocol === 'https:' ? https : http).request;
  		const signal = request.signal;
  
  		let response = null;
  
  		const abort = function abort() {
  			let error = new AbortError('The user aborted a request.');
  			reject(error);
  			if (request.body && request.body instanceof Stream.Readable) {
  				request.body.destroy(error);
  			}
  			if (!response || !response.body) return;
  			response.body.emit('error', error);
  		};
  
  		if (signal && signal.aborted) {
  			abort();
  			return;
  		}
  
  		const abortAndFinalize = function abortAndFinalize() {
  			abort();
  			finalize();
  		};
  
  		// send request
  		const req = send(options);
  		let reqTimeout;
  
  		if (signal) {
  			signal.addEventListener('abort', abortAndFinalize);
  		}
  
  		function finalize() {
  			req.abort();
  			if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			clearTimeout(reqTimeout);
  		}
  
  		if (request.timeout) {
  			req.once('socket', function (socket) {
  				reqTimeout = setTimeout(function () {
  					reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
  					finalize();
  				}, request.timeout);
  			});
  		}
  
  		req.on('error', function (err) {
  			reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
  			finalize();
  		});
  
  		req.on('response', function (res) {
  			clearTimeout(reqTimeout);
  
  			const headers = createHeadersLenient(res.headers);
  
  			// HTTP fetch step 5
  			if (fetch.isRedirect(res.statusCode)) {
  				// HTTP fetch step 5.2
  				const location = headers.get('Location');
  
  				// HTTP fetch step 5.3
  				const locationURL = location === null ? null : resolve_url(request.url, location);
  
  				// HTTP fetch step 5.5
  				switch (request.redirect) {
  					case 'error':
  						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
  						finalize();
  						return;
  					case 'manual':
  						// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
  						if (locationURL !== null) {
  							// handle corrupted header
  							try {
  								headers.set('Location', locationURL);
  							} catch (err) {
  								// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
  								reject(err);
  							}
  						}
  						break;
  					case 'follow':
  						// HTTP-redirect fetch step 2
  						if (locationURL === null) {
  							break;
  						}
  
  						// HTTP-redirect fetch step 5
  						if (request.counter >= request.follow) {
  							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 6 (counter increment)
  						// Create a new Request object.
  						const requestOpts = {
  							headers: new Headers(request.headers),
  							follow: request.follow,
  							counter: request.counter + 1,
  							agent: request.agent,
  							compress: request.compress,
  							method: request.method,
  							body: request.body,
  							signal: request.signal,
  							timeout: request.timeout,
  							size: request.size
  						};
  
  						// HTTP-redirect fetch step 9
  						if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
  							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 11
  						if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
  							requestOpts.method = 'GET';
  							requestOpts.body = undefined;
  							requestOpts.headers.delete('content-length');
  						}
  
  						// HTTP-redirect fetch step 15
  						resolve(fetch(new Request(locationURL, requestOpts)));
  						finalize();
  						return;
  				}
  			}
  
  			// prepare response
  			res.once('end', function () {
  				if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			});
  			let body = res.pipe(new PassThrough$1());
  
  			const response_options = {
  				url: request.url,
  				status: res.statusCode,
  				statusText: res.statusMessage,
  				headers: headers,
  				size: request.size,
  				timeout: request.timeout,
  				counter: request.counter
  			};
  
  			// HTTP-network fetch step 12.1.1.3
  			const codings = headers.get('Content-Encoding');
  
  			// HTTP-network fetch step 12.1.1.4: handle content codings
  
  			// in following scenarios we ignore compression support
  			// 1. compression support is disabled
  			// 2. HEAD request
  			// 3. no Content-Encoding header
  			// 4. no content response (204)
  			// 5. content not modified response (304)
  			if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// For Node v6+
  			// Be less strict when decoding compressed responses, since sometimes
  			// servers send slightly invalid responses that are still accepted
  			// by common browsers.
  			// Always using Z_SYNC_FLUSH is what cURL does.
  			const zlibOptions = {
  				flush: zlib.Z_SYNC_FLUSH,
  				finishFlush: zlib.Z_SYNC_FLUSH
  			};
  
  			// for gzip
  			if (codings == 'gzip' || codings == 'x-gzip') {
  				body = body.pipe(zlib.createGunzip(zlibOptions));
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// for deflate
  			if (codings == 'deflate' || codings == 'x-deflate') {
  				// handle the infamous raw deflate response from old servers
  				// a hack for old IIS and Apache servers
  				const raw = res.pipe(new PassThrough$1());
  				raw.once('data', function (chunk) {
  					// see http://stackoverflow.com/questions/37519828
  					if ((chunk[0] & 0x0F) === 0x08) {
  						body = body.pipe(zlib.createInflate());
  					} else {
  						body = body.pipe(zlib.createInflateRaw());
  					}
  					response = new Response(body, response_options);
  					resolve(response);
  				});
  				return;
  			}
  
  			// for br
  			if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
  				body = body.pipe(zlib.createBrotliDecompress());
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// otherwise, use response as-is
  			response = new Response(body, response_options);
  			resolve(response);
  		});
  
  		writeToStream(req, request);
  	});
  }
  /**
   * Redirect code matching
   *
   * @param   Number   code  Status code
   * @return  Boolean
   */
  fetch.isRedirect = function (code) {
  	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
  };
  
  // expose Promise
  fetch.Promise = global.Promise;
  
  module.exports = exports = fetch;
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.default = exports;
  exports.Headers = Headers;
  exports.Request = Request;
  exports.Response = Response;
  exports.FetchError = FetchError;
  
  
  /***/ }),
  /* 370 */,
  /* 371 */,
  /* 372 */,
  /* 373 */,
  /* 374 */,
  /* 375 */,
  /* 376 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _map =
  /*#__PURE__*/
  __webpack_require__(626);
  
  var identity =
  /*#__PURE__*/
  __webpack_require__(534);
  
  var pickAll =
  /*#__PURE__*/
  __webpack_require__(362);
  
  var useWith =
  /*#__PURE__*/
  __webpack_require__(467);
  /**
   * Reasonable analog to SQL `select` statement.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @category Relation
   * @sig [k] -> [{k: v}] -> [{k: v}]
   * @param {Array} props The property names to project
   * @param {Array} objs The objects to query
   * @return {Array} An array of objects with just the `props` properties.
   * @example
   *
   *      const abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
   *      const fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
   *      const kids = [abby, fred];
   *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]
   */
  
  
  var project =
  /*#__PURE__*/
  useWith(_map, [pickAll, identity]); // passing `identity` gives correct arity
  
  module.exports = project;
  
  /***/ }),
  /* 377 */,
  /* 378 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var register = __webpack_require__(280)
  var addHook = __webpack_require__(510)
  var removeHook = __webpack_require__(763)
  
  // bind with array of arguments: https://stackoverflow.com/a/21792913
  var bind = Function.bind
  var bindable = bind.bind(bind)
  
  function bindApi (hook, state, name) {
    var removeHookRef = bindable(removeHook, null).apply(null, name ? [state, name] : [state])
    hook.api = { remove: removeHookRef }
    hook.remove = removeHookRef
  
    ;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
      var args = name ? [state, kind, name] : [state, kind]
      hook[kind] = hook.api[kind] = bindable(addHook, null).apply(null, args)
    })
  }
  
  function HookSingular () {
    var singularHookName = 'h'
    var singularHookState = {
      registry: {}
    }
    var singularHook = register.bind(null, singularHookState, singularHookName)
    bindApi(singularHook, singularHookState, singularHookName)
    return singularHook
  }
  
  function HookCollection () {
    var state = {
      registry: {}
    }
  
    var hook = register.bind(null, state)
    bindApi(hook, state)
  
    return hook
  }
  
  var collectionHookDeprecationMessageDisplayed = false
  function Hook () {
    if (!collectionHookDeprecationMessageDisplayed) {
      console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4')
      collectionHookDeprecationMessageDisplayed = true
    }
    return HookCollection()
  }
  
  Hook.Singular = HookSingular.bind()
  Hook.Collection = HookCollection.bind()
  
  module.exports = Hook
  // expose constructors as a named property for TypeScript
  module.exports.Hook = Hook
  module.exports.Singular = Hook.Singular
  module.exports.Collection = Hook.Collection
  
  
  /***/ }),
  /* 379 */,
  /* 380 */,
  /* 381 */,
  /* 382 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Returns a single item by iterating through the list, successively calling
   * the iterator function and passing it an accumulator value and the current
   * value from the array, and then passing the result to the next call.
   *
   * Similar to [`reduce`](#reduce), except moves through the input list from the
   * right to the left.
   *
   * The iterator function receives two values: *(value, acc)*, while the arguments'
   * order of `reduce`'s iterator function is *(acc, value)*.
   *
   * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse
   * arrays), unlike the native `Array.prototype.reduceRight` method. For more details
   * on this behavior, see:
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig ((a, b) -> b) -> b -> [a] -> b
   * @param {Function} fn The iterator function. Receives two values, the current element from the array
   *        and the accumulator.
   * @param {*} acc The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.reduce, R.addIndex
   * @example
   *
   *      R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2
   *      //    -               -2
   *      //   / \              / \
   *      //  1   -            1   3
   *      //     / \              / \
   *      //    2   -     ==>    2  -1
   *      //       / \              / \
   *      //      3   -            3   4
   *      //         / \              / \
   *      //        4   0            4   0
   *
   * @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))
   */
  
  
  var reduceRight =
  /*#__PURE__*/
  _curry3(function reduceRight(fn, acc, list) {
    var idx = list.length - 1;
  
    while (idx >= 0) {
      acc = fn(list[idx], acc);
      idx -= 1;
    }
  
    return acc;
  });
  
  module.exports = reduceRight;
  
  /***/ }),
  /* 383 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Path = void 0;
  const path = __importStar(__webpack_require__(622));
  const pathHelper = __importStar(__webpack_require__(972));
  const assert_1 = __importDefault(__webpack_require__(357));
  const IS_WINDOWS = process.platform === 'win32';
  /**
   * Helper class for parsing paths into segments
   */
  class Path {
      /**
       * Constructs a Path
       * @param itemPath Path or array of segments
       */
      constructor(itemPath) {
          this.segments = [];
          // String
          if (typeof itemPath === 'string') {
              assert_1.default(itemPath, `Parameter 'itemPath' must not be empty`);
              // Normalize slashes and trim unnecessary trailing slash
              itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
              // Not rooted
              if (!pathHelper.hasRoot(itemPath)) {
                  this.segments = itemPath.split(path.sep);
              }
              // Rooted
              else {
                  // Add all segments, while not at the root
                  let remaining = itemPath;
                  let dir = pathHelper.dirname(remaining);
                  while (dir !== remaining) {
                      // Add the segment
                      const basename = path.basename(remaining);
                      this.segments.unshift(basename);
                      // Truncate the last segment
                      remaining = dir;
                      dir = pathHelper.dirname(remaining);
                  }
                  // Remainder is the root
                  this.segments.unshift(remaining);
              }
          }
          // Array
          else {
              // Must not be empty
              assert_1.default(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
              // Each segment
              for (let i = 0; i < itemPath.length; i++) {
                  let segment = itemPath[i];
                  // Must not be empty
                  assert_1.default(segment, `Parameter 'itemPath' must not contain any empty segments`);
                  // Normalize slashes
                  segment = pathHelper.normalizeSeparators(itemPath[i]);
                  // Root segment
                  if (i === 0 && pathHelper.hasRoot(segment)) {
                      segment = pathHelper.safeTrimTrailingSeparator(segment);
                      assert_1.default(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
                      this.segments.push(segment);
                  }
                  // All other segments
                  else {
                      // Must not contain slash
                      assert_1.default(!segment.includes(path.sep), `Parameter 'itemPath' contains unexpected path separators`);
                      this.segments.push(segment);
                  }
              }
          }
      }
      /**
       * Converts the path to it's string representation
       */
      toString() {
          // First segment
          let result = this.segments[0];
          // All others
          let skipSlash = result.endsWith(path.sep) || (IS_WINDOWS && /^[A-Z]:$/i.test(result));
          for (let i = 1; i < this.segments.length; i++) {
              if (skipSlash) {
                  skipSlash = false;
              }
              else {
                  result += path.sep;
              }
              result += this.segments[i];
          }
          return result;
      }
  }
  exports.Path = Path;
  //# sourceMappingURL=internal-path.js.map
  
  /***/ }),
  /* 384 */,
  /* 385 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isFunction =
  /*#__PURE__*/
  __webpack_require__(504);
  
  var _toString =
  /*#__PURE__*/
  __webpack_require__(203);
  
  function _assertPromise(name, p) {
    if (p == null || !_isFunction(p.then)) {
      throw new TypeError('`' + name + '` expected a Promise, received ' + _toString(p, []));
    }
  }
  
  module.exports = _assertPromise;
  
  /***/ }),
  /* 386 */,
  /* 387 */,
  /* 388 */,
  /* 389 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(747);
  const shebangCommand = __webpack_require__(274);
  
  function readShebang(command) {
      // Read the first 150 bytes from the file
      const size = 150;
      let buffer;
  
      if (Buffer.alloc) {
          // Node.js v4.5+ / v5.10+
          buffer = Buffer.alloc(size);
      } else {
          // Old Node.js API
          buffer = new Buffer(size);
          buffer.fill(0); // zero-fill
      }
  
      let fd;
  
      try {
          fd = fs.openSync(command, 'r');
          fs.readSync(fd, buffer, 0, size, 0);
          fs.closeSync(fd);
      } catch (e) { /* Empty */ }
  
      // Attempt to extract shebang (null is returned if not a shebang)
      return shebangCommand(buffer.toString());
  }
  
  module.exports = readShebang;
  
  
  /***/ }),
  /* 390 */
  /***/ (function(module) {
  
  function _has(prop, obj) {
    return Object.prototype.hasOwnProperty.call(obj, prop);
  }
  
  module.exports = _has;
  
  /***/ }),
  /* 391 */,
  /* 392 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function getUserAgent() {
    if (typeof navigator === "object" && "userAgent" in navigator) {
      return navigator.userAgent;
    }
  
    if (typeof process === "object" && "version" in process) {
      return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
    }
  
    return "<environment undetectable>";
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 393 */,
  /* 394 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isInteger =
  /*#__PURE__*/
  __webpack_require__(802);
  
  var nth =
  /*#__PURE__*/
  __webpack_require__(653);
  /**
   * Retrieves the values at given paths of an object.
   *
   * @func
   * @memberOf R
   * @since v0.27.1
   * @category Object
   * @typedefn Idx = [String | Int]
   * @sig [Idx] -> {a} -> [a | Undefined]
   * @param {Array} pathsArray The array of paths to be fetched.
   * @param {Object} obj The object to retrieve the nested properties from.
   * @return {Array} A list consisting of values at paths specified by "pathsArray".
   * @see R.path
   * @example
   *
   *      R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]
   *      R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]
   */
  
  
  var paths =
  /*#__PURE__*/
  _curry2(function paths(pathsArray, obj) {
    return pathsArray.map(function (paths) {
      var val = obj;
      var idx = 0;
      var p;
  
      while (idx < paths.length) {
        if (val == null) {
          return;
        }
  
        p = paths[idx];
        val = _isInteger(p) ? nth(p, val) : val[p];
        idx += 1;
      }
  
      return val;
    });
  });
  
  module.exports = paths;
  
  /***/ }),
  /* 395 */,
  /* 396 */,
  /* 397 */,
  /* 398 */,
  /* 399 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var nth =
  /*#__PURE__*/
  __webpack_require__(653);
  /**
   * Returns a function which returns its nth argument.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Function
   * @sig Number -> *... -> *
   * @param {Number} n
   * @return {Function}
   * @example
   *
   *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'
   *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'
   * @symb R.nthArg(-1)(a, b, c) = c
   * @symb R.nthArg(0)(a, b, c) = a
   * @symb R.nthArg(1)(a, b, c) = b
   */
  
  
  var nthArg =
  /*#__PURE__*/
  _curry1(function nthArg(n) {
    var arity = n < 0 ? 1 : n + 1;
    return curryN(arity, function () {
      return nth(n, arguments);
    });
  });
  
  module.exports = nthArg;
  
  /***/ }),
  /* 400 */,
  /* 401 */,
  /* 402 */,
  /* 403 */,
  /* 404 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _isPlaceholder =
  /*#__PURE__*/
  __webpack_require__(953);
  /**
   * Internal curryN function.
   *
   * @private
   * @category Function
   * @param {Number} length The arity of the curried function.
   * @param {Array} received An array of arguments received thus far.
   * @param {Function} fn The function to curry.
   * @return {Function} The curried function.
   */
  
  
  function _curryN(length, received, fn) {
    return function () {
      var combined = [];
      var argsIdx = 0;
      var left = length;
      var combinedIdx = 0;
  
      while (combinedIdx < received.length || argsIdx < arguments.length) {
        var result;
  
        if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {
          result = received[combinedIdx];
        } else {
          result = arguments[argsIdx];
          argsIdx += 1;
        }
  
        combined[combinedIdx] = result;
  
        if (!_isPlaceholder(result)) {
          left -= 1;
        }
  
        combinedIdx += 1;
      }
  
      return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));
    };
  }
  
  module.exports = _curryN;
  
  /***/ }),
  /* 405 */,
  /* 406 */,
  /* 407 */,
  /* 408 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Splits a collection into slices of the specified length.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig Number -> [a] -> [[a]]
   * @sig Number -> String -> [String]
   * @param {Number} n
   * @param {Array} list
   * @return {Array}
   * @example
   *
   *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]
   *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']
   */
  
  
  var splitEvery =
  /*#__PURE__*/
  _curry2(function splitEvery(n, list) {
    if (n <= 0) {
      throw new Error('First argument to splitEvery must be a positive integer');
    }
  
    var result = [];
    var idx = 0;
  
    while (idx < list.length) {
      result.push(slice(idx, idx += n, list));
    }
  
    return result;
  });
  
  module.exports = splitEvery;
  
  /***/ }),
  /* 409 */,
  /* 410 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var compose =
  /*#__PURE__*/
  __webpack_require__(944);
  
  var uniq =
  /*#__PURE__*/
  __webpack_require__(732);
  /**
   * Combines two lists into a set (i.e. no duplicates) composed of the elements
   * of each list.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig [*] -> [*] -> [*]
   * @param {Array} as The first list.
   * @param {Array} bs The second list.
   * @return {Array} The first and second lists concatenated, with
   *         duplicates removed.
   * @example
   *
   *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]
   */
  
  
  var union =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  compose(uniq, _concat));
  
  module.exports = union;
  
  /***/ }),
  /* 411 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(622);
  const which = __webpack_require__(142);
  const pathKey = __webpack_require__(359)();
  
  function resolveCommandAttempt(parsed, withoutPathExt) {
      const cwd = process.cwd();
      const hasCustomCwd = parsed.options.cwd != null;
  
      // If a custom `cwd` was specified, we need to change the process cwd
      // because `which` will do stat calls but does not support a custom cwd
      if (hasCustomCwd) {
          try {
              process.chdir(parsed.options.cwd);
          } catch (err) {
              /* Empty */
          }
      }
  
      let resolved;
  
      try {
          resolved = which.sync(parsed.command, {
              path: (parsed.options.env || process.env)[pathKey],
              pathExt: withoutPathExt ? path.delimiter : undefined,
          });
      } catch (e) {
          /* Empty */
      } finally {
          process.chdir(cwd);
      }
  
      // If we successfully resolved, ensure that an absolute path is returned
      // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
      if (resolved) {
          resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
      }
  
      return resolved;
  }
  
  function resolveCommand(parsed) {
      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
  }
  
  module.exports = resolveCommand;
  
  
  /***/ }),
  /* 412 */,
  /* 413 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = __webpack_require__(141);
  
  
  /***/ }),
  /* 414 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Makes a shallow clone of an object, setting or overriding the specified
   * property with the given value. Note that this copies and flattens prototype
   * properties onto the new object as well. All non-primitive properties are
   * copied by reference.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Object
   * @sig String -> a -> {k: v} -> {k: v}
   * @param {String} prop The property name to set
   * @param {*} val The new value
   * @param {Object} obj The object to clone
   * @return {Object} A new object equivalent to the original except for the changed property.
   * @see R.dissoc, R.pick
   * @example
   *
   *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
   */
  
  
  var assoc =
  /*#__PURE__*/
  _curry3(function assoc(prop, val, obj) {
    var result = {};
  
    for (var p in obj) {
      result[p] = obj[p];
    }
  
    result[prop] = val;
    return result;
  });
  
  module.exports = assoc;
  
  /***/ }),
  /* 415 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isArrayLike =
  /*#__PURE__*/
  __webpack_require__(260);
  /**
   * `_makeFlat` is a helper function that returns a one-level or fully recursive
   * function based on the flag passed in.
   *
   * @private
   */
  
  
  function _makeFlat(recursive) {
    return function flatt(list) {
      var value, jlen, j;
      var result = [];
      var idx = 0;
      var ilen = list.length;
  
      while (idx < ilen) {
        if (_isArrayLike(list[idx])) {
          value = recursive ? flatt(list[idx]) : list[idx];
          j = 0;
          jlen = value.length;
  
          while (j < jlen) {
            result[result.length] = value[j];
            j += 1;
          }
        } else {
          result[result.length] = list[idx];
        }
  
        idx += 1;
      }
  
      return result;
    };
  }
  
  module.exports = _makeFlat;
  
  /***/ }),
  /* 416 */,
  /* 417 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  /**
   * This checks whether a function has a [methodname] function. If it isn't an
   * array it will execute that function otherwise it will default to the ramda
   * implementation.
   *
   * @private
   * @param {Function} fn ramda implemtation
   * @param {String} methodname property to check for a custom implementation
   * @return {Object} Whatever the return value of the method is.
   */
  
  
  function _checkForMethod(methodname, fn) {
    return function () {
      var length = arguments.length;
  
      if (length === 0) {
        return fn();
      }
  
      var obj = arguments[length - 1];
      return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
    };
  }
  
  module.exports = _checkForMethod;
  
  /***/ }),
  /* 418 */
  /***/ (function(module) {
  
  module.exports = require("stream");
  
  /***/ }),
  /* 419 */,
  /* 420 */,
  /* 421 */,
  /* 422 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Applies function `fn` to the argument list `args`. This is useful for
   * creating a fixed-arity function from a variadic function. `fn` should be a
   * bound function if context is significant.
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Function
   * @sig (*... -> a) -> [*] -> a
   * @param {Function} fn The function which will be called with `args`
   * @param {Array} args The arguments to call `fn` with
   * @return {*} result The result, equivalent to `fn(...args)`
   * @see R.call, R.unapply
   * @example
   *
   *      const nums = [1, 2, 3, -99, 42, 6, 7];
   *      R.apply(Math.max, nums); //=> 42
   * @symb R.apply(f, [a, b, c]) = f(a, b, c)
   */
  
  
  var apply =
  /*#__PURE__*/
  _curry2(function apply(fn, args) {
    return fn.apply(this, args);
  });
  
  module.exports = apply;
  
  /***/ }),
  /* 423 */,
  /* 424 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XDropRepeatsWith =
  /*#__PURE__*/
  function () {
    function XDropRepeatsWith(pred, xf) {
      this.xf = xf;
      this.pred = pred;
      this.lastValue = undefined;
      this.seenFirstValue = false;
    }
  
    XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init;
    XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result;
  
    XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {
      var sameAsLast = false;
  
      if (!this.seenFirstValue) {
        this.seenFirstValue = true;
      } else if (this.pred(this.lastValue, input)) {
        sameAsLast = true;
      }
  
      this.lastValue = input;
      return sameAsLast ? result : this.xf['@@transducer/step'](result, input);
    };
  
    return XDropRepeatsWith;
  }();
  
  var _xdropRepeatsWith =
  /*#__PURE__*/
  _curry2(function _xdropRepeatsWith(pred, xf) {
    return new XDropRepeatsWith(pred, xf);
  });
  
  module.exports = _xdropRepeatsWith;
  
  /***/ }),
  /* 425 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Wraps a function of any arity (including nullary) in a function that accepts
   * exactly `n` parameters. Any extraneous parameters will not be passed to the
   * supplied function.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig Number -> (* -> a) -> (* -> a)
   * @param {Number} n The desired arity of the new function.
   * @param {Function} fn The function to wrap.
   * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
   *         arity `n`.
   * @see R.binary, R.unary
   * @example
   *
   *      const takesTwoArgs = (a, b) => [a, b];
   *
   *      takesTwoArgs.length; //=> 2
   *      takesTwoArgs(1, 2); //=> [1, 2]
   *
   *      const takesOneArg = R.nAry(1, takesTwoArgs);
   *      takesOneArg.length; //=> 1
   *      // Only `n` arguments are passed to the wrapped function
   *      takesOneArg(1, 2); //=> [1, undefined]
   * @symb R.nAry(0, f)(a, b) = f()
   * @symb R.nAry(1, f)(a, b) = f(a)
   * @symb R.nAry(2, f)(a, b) = f(a, b)
   */
  
  
  var nAry =
  /*#__PURE__*/
  _curry2(function nAry(n, fn) {
    switch (n) {
      case 0:
        return function () {
          return fn.call(this);
        };
  
      case 1:
        return function (a0) {
          return fn.call(this, a0);
        };
  
      case 2:
        return function (a0, a1) {
          return fn.call(this, a0, a1);
        };
  
      case 3:
        return function (a0, a1, a2) {
          return fn.call(this, a0, a1, a2);
        };
  
      case 4:
        return function (a0, a1, a2, a3) {
          return fn.call(this, a0, a1, a2, a3);
        };
  
      case 5:
        return function (a0, a1, a2, a3, a4) {
          return fn.call(this, a0, a1, a2, a3, a4);
        };
  
      case 6:
        return function (a0, a1, a2, a3, a4, a5) {
          return fn.call(this, a0, a1, a2, a3, a4, a5);
        };
  
      case 7:
        return function (a0, a1, a2, a3, a4, a5, a6) {
          return fn.call(this, a0, a1, a2, a3, a4, a5, a6);
        };
  
      case 8:
        return function (a0, a1, a2, a3, a4, a5, a6, a7) {
          return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);
        };
  
      case 9:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
          return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);
        };
  
      case 10:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
          return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
        };
  
      default:
        throw new Error('First argument to nAry must be a non-negative integer no greater than ten');
    }
  });
  
  module.exports = nAry;
  
  /***/ }),
  /* 426 */,
  /* 427 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  // Older verions of Node.js might not have `util.getSystemErrorName()`.
  // In that case, fall back to a deprecated internal.
  const util = __webpack_require__(853);
  
  let uv;
  
  if (typeof util.getSystemErrorName === 'function') {
  	module.exports = util.getSystemErrorName;
  } else {
  	try {
  		uv = process.binding('uv');
  
  		if (typeof uv.errname !== 'function') {
  			throw new TypeError('uv.errname is not a function');
  		}
  	} catch (err) {
  		console.error('execa/lib/errname: unable to establish process.binding(\'uv\')', err);
  		uv = null;
  	}
  
  	module.exports = code => errname(uv, code);
  }
  
  // Used for testing the fallback behavior
  module.exports.__test__ = errname;
  
  function errname(uv, code) {
  	if (uv) {
  		return uv.errname(code);
  	}
  
  	if (!(code < 0)) {
  		throw new Error('err >= 0');
  	}
  
  	return `Unknown system error ${code}`;
  }
  
  
  
  /***/ }),
  /* 428 */,
  /* 429 */,
  /* 430 */,
  /* 431 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.issue = exports.issueCommand = void 0;
  const os = __importStar(__webpack_require__(87));
  const utils_1 = __webpack_require__(82);
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  function escapeData(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  /* 432 */,
  /* 433 */,
  /* 434 */,
  /* 435 */,
  /* 436 */,
  /* 437 */,
  /* 438 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectAssign =
  /*#__PURE__*/
  __webpack_require__(289);
  
  var _identity =
  /*#__PURE__*/
  __webpack_require__(631);
  
  var _isArrayLike =
  /*#__PURE__*/
  __webpack_require__(260);
  
  var _isTransformer =
  /*#__PURE__*/
  __webpack_require__(700);
  
  var objOf =
  /*#__PURE__*/
  __webpack_require__(110);
  
  var _stepCatArray = {
    '@@transducer/init': Array,
    '@@transducer/step': function (xs, x) {
      xs.push(x);
      return xs;
    },
    '@@transducer/result': _identity
  };
  var _stepCatString = {
    '@@transducer/init': String,
    '@@transducer/step': function (a, b) {
      return a + b;
    },
    '@@transducer/result': _identity
  };
  var _stepCatObject = {
    '@@transducer/init': Object,
    '@@transducer/step': function (result, input) {
      return _objectAssign(result, _isArrayLike(input) ? objOf(input[0], input[1]) : input);
    },
    '@@transducer/result': _identity
  };
  
  function _stepCat(obj) {
    if (_isTransformer(obj)) {
      return obj;
    }
  
    if (_isArrayLike(obj)) {
      return _stepCatArray;
    }
  
    if (typeof obj === 'string') {
      return _stepCatString;
    }
  
    if (typeof obj === 'object') {
      return _stepCatObject;
    }
  
    throw new Error('Cannot create transformer for ' + obj);
  }
  
  module.exports = _stepCat;
  
  /***/ }),
  /* 439 */,
  /* 440 */,
  /* 441 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var chain =
  /*#__PURE__*/
  __webpack_require__(481);
  
  var compose =
  /*#__PURE__*/
  __webpack_require__(944);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  /**
   * Returns the right-to-left Kleisli composition of the provided functions,
   * each of which must return a value of a type supported by [`chain`](#chain).
   *
   * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), f)`.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Function
   * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)
   * @param {...Function} ...functions The functions to compose
   * @return {Function}
   * @see R.pipeK
   * @deprecated since v0.26.0
   * @example
   *
   *       //  get :: String -> Object -> Maybe *
   *       const get = R.curry((propName, obj) => Maybe(obj[propName]))
   *
   *       //  getStateCode :: Maybe String -> Maybe String
   *       const getStateCode = R.composeK(
   *         R.compose(Maybe.of, R.toUpper),
   *         get('state'),
   *         get('address'),
   *         get('user'),
   *       );
   *       getStateCode({"user":{"address":{"state":"ny"}}}); //=> Maybe.Just("NY")
   *       getStateCode({}); //=> Maybe.Nothing()
   * @symb R.composeK(f, g, h)(a) = R.chain(f, R.chain(g, h(a)))
   */
  
  
  function composeK() {
    if (arguments.length === 0) {
      throw new Error('composeK requires at least one argument');
    }
  
    var init = Array.prototype.slice.call(arguments);
    var last = init.pop();
    return compose(compose.apply(this, map(chain, init)), last);
  }
  
  module.exports = composeK;
  
  /***/ }),
  /* 442 */,
  /* 443 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if one or both of its arguments are `true`. Returns `false`
   * if both arguments are `false`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Logic
   * @sig a -> b -> a | b
   * @param {Any} a
   * @param {Any} b
   * @return {Any} the first argument if truthy, otherwise the second argument.
   * @see R.either, R.xor
   * @example
   *
   *      R.or(true, true); //=> true
   *      R.or(true, false); //=> true
   *      R.or(false, true); //=> true
   *      R.or(false, false); //=> false
   */
  
  
  var or =
  /*#__PURE__*/
  _curry2(function or(a, b) {
    return a || b;
  });
  
  module.exports = or;
  
  /***/ }),
  /* 444 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  var extend = __webpack_require__(707);
  var regexCache = {};
  var all;
  
  var charSets = {
    default: {
      '&quot;': '"',
      '&#34;': '"',
  
      '&apos;': '\'',
      '&#39;': '\'',
  
      '&amp;': '&',
      '&#38;': '&',
  
      '&gt;': '>',
      '&#62;': '>',
  
      '&lt;': '<',
      '&#60;': '<'
    },
    extras: {
      '&cent;': '¢',
      '&#162;': '¢',
  
      '&copy;': '©',
      '&#169;': '©',
  
      '&euro;': '€',
      '&#8364;': '€',
  
      '&pound;': '£',
      '&#163;': '£',
  
      '&reg;': '®',
      '&#174;': '®',
  
      '&yen;': '¥',
      '&#165;': '¥'
    }
  };
  
  // don't merge char sets unless "all" is explicitly called
  Object.defineProperty(charSets, 'all', {
    get: function() {
      return all || (all = extend({}, charSets.default, charSets.extras));
    }
  });
  
  /**
   * Convert HTML entities to HTML characters.
   *
   * @param  {String} `str` String with HTML entities to un-escape.
   * @return {String}
   */
  
  function unescape(str, type) {
    if (!isString(str)) return '';
    var chars = charSets[type || 'default'];
    var regex = toRegex(type, chars);
    return str.replace(regex, function(m) {
      return chars[m];
    });
  }
  
  function toRegex(type, chars) {
    if (regexCache[type]) {
      return regexCache[type];
    }
    var keys = Object.keys(chars).join('|');
    var regex = new RegExp('(?=(' + keys + '))\\1', 'g');
    regexCache[type] = regex;
    return regex;
  }
  
  /**
   * Returns true if str is a non-empty string
   */
  
  function isString(str) {
    return str && typeof str === 'string';
  }
  
  /**
   * Expose charSets
   */
  
  unescape.chars = charSets.default;
  unescape.extras = charSets.extras;
  // don't trip the "charSets" getter unless it's explicitly called
  Object.defineProperty(unescape, 'all', {
    get: function() {
      return charSets.all;
    }
  });
  
  /**
   * Expose `unescape`
   */
  
  module.exports = unescape;
  
  
  /***/ }),
  /* 445 */,
  /* 446 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isFunction =
  /*#__PURE__*/
  __webpack_require__(504);
  
  var lift =
  /*#__PURE__*/
  __webpack_require__(127);
  
  var or =
  /*#__PURE__*/
  __webpack_require__(443);
  /**
   * A function wrapping calls to the two functions in an `||` operation,
   * returning the result of the first function if it is truth-y and the result
   * of the second function otherwise. Note that this is short-circuited,
   * meaning that the second function will not be invoked if the first returns a
   * truth-y value.
   *
   * In addition to functions, `R.either` also accepts any fantasy-land compatible
   * applicative functor.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category Logic
   * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
   * @param {Function} f a predicate
   * @param {Function} g another predicate
   * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.
   * @see R.or
   * @example
   *
   *      const gt10 = x => x > 10;
   *      const even = x => x % 2 === 0;
   *      const f = R.either(gt10, even);
   *      f(101); //=> true
   *      f(8); //=> true
   *
   *      R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)
   *      R.either([false, false, 'a'], [11]) // => [11, 11, "a"]
   */
  
  
  var either =
  /*#__PURE__*/
  _curry2(function either(f, g) {
    return _isFunction(f) ? function _either() {
      return f.apply(this, arguments) || g.apply(this, arguments);
    } : lift(or)(f, g);
  });
  
  module.exports = either;
  
  /***/ }),
  /* 447 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Returns a curried equivalent of the provided function. The curried function
   * has two unusual capabilities. First, its arguments needn't be provided one
   * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the
   * following are equivalent:
   *
   *   - `g(1)(2)(3)`
   *   - `g(1)(2, 3)`
   *   - `g(1, 2)(3)`
   *   - `g(1, 2, 3)`
   *
   * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
   * "gaps", allowing partial application of any combination of arguments,
   * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
   * the following are equivalent:
   *
   *   - `g(1, 2, 3)`
   *   - `g(_, 2, 3)(1)`
   *   - `g(_, _, 3)(1)(2)`
   *   - `g(_, _, 3)(1, 2)`
   *   - `g(_, 2)(1)(3)`
   *   - `g(_, 2)(1, 3)`
   *   - `g(_, 2)(_, 3)(1)`
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig (* -> a) -> (* -> a)
   * @param {Function} fn The function to curry.
   * @return {Function} A new, curried function.
   * @see R.curryN, R.partial
   * @example
   *
   *      const addFourNumbers = (a, b, c, d) => a + b + c + d;
   *
   *      const curriedAddFourNumbers = R.curry(addFourNumbers);
   *      const f = curriedAddFourNumbers(1, 2);
   *      const g = f(3);
   *      g(4); //=> 10
   */
  
  
  var curry =
  /*#__PURE__*/
  _curry1(function curry(fn) {
    return curryN(fn.length, fn);
  });
  
  module.exports = curry;
  
  /***/ }),
  /* 448 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var universalUserAgent = __webpack_require__(796);
  var beforeAfterHook = __webpack_require__(378);
  var request = __webpack_require__(753);
  var graphql = __webpack_require__(192);
  var authToken = __webpack_require__(68);
  
  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;
  }
  
  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
  
    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }
  
    return keys;
  }
  
  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};
  
      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }
  
    return target;
  }
  
  const VERSION = "2.5.4";
  
  class Octokit {
    constructor(options = {}) {
      const hook = new beforeAfterHook.Collection();
      const requestDefaults = {
        baseUrl: request.request.endpoint.DEFAULTS.baseUrl,
        headers: {},
        request: Object.assign({}, options.request, {
          hook: hook.bind(null, "request")
        }),
        mediaType: {
          previews: [],
          format: ""
        }
      }; // prepend default user agent with `options.userAgent` if set
  
      requestDefaults.headers["user-agent"] = [options.userAgent, `octokit-core.js/${VERSION} ${universalUserAgent.getUserAgent()}`].filter(Boolean).join(" ");
  
      if (options.baseUrl) {
        requestDefaults.baseUrl = options.baseUrl;
      }
  
      if (options.previews) {
        requestDefaults.mediaType.previews = options.previews;
      }
  
      if (options.timeZone) {
        requestDefaults.headers["time-zone"] = options.timeZone;
      }
  
      this.request = request.request.defaults(requestDefaults);
      this.graphql = graphql.withCustomRequest(this.request).defaults(_objectSpread2(_objectSpread2({}, requestDefaults), {}, {
        baseUrl: requestDefaults.baseUrl.replace(/\/api\/v3$/, "/api")
      }));
      this.log = Object.assign({
        debug: () => {},
        info: () => {},
        warn: console.warn.bind(console),
        error: console.error.bind(console)
      }, options.log);
      this.hook = hook; // (1) If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
      //     is unauthenticated. The `this.auth()` method is a no-op and no request hook is registred.
      // (2) If only `options.auth` is set, use the default token authentication strategy.
      // (3) If `options.authStrategy` is set then use it and pass in `options.auth`. Always pass own request as many strategies accept a custom request instance.
      // TODO: type `options.auth` based on `options.authStrategy`.
  
      if (!options.authStrategy) {
        if (!options.auth) {
          // (1)
          this.auth = async () => ({
            type: "unauthenticated"
          });
        } else {
          // (2)
          const auth = authToken.createTokenAuth(options.auth); // @ts-ignore  ¯\_(ツ)_/¯
  
          hook.wrap("request", auth.hook);
          this.auth = auth;
        }
      } else {
        const auth = options.authStrategy(Object.assign({
          request: this.request
        }, options.auth)); // @ts-ignore  ¯\_(ツ)_/¯
  
        hook.wrap("request", auth.hook);
        this.auth = auth;
      } // apply plugins
      // https://stackoverflow.com/a/16345172
  
  
      const classConstructor = this.constructor;
      classConstructor.plugins.forEach(plugin => {
        Object.assign(this, plugin(this, options));
      });
    }
  
    static defaults(defaults) {
      const OctokitWithDefaults = class extends this {
        constructor(...args) {
          const options = args[0] || {};
          super(Object.assign({}, defaults, options, options.userAgent && defaults.userAgent ? {
            userAgent: `${options.userAgent} ${defaults.userAgent}`
          } : null));
        }
  
      };
      return OctokitWithDefaults;
    }
    /**
     * Attach a plugin (or many) to your Octokit instance.
     *
     * @example
     * const API = Octokit.plugin(plugin1, plugin2, plugin3, ...)
     */
  
  
    static plugin(p1, ...p2) {
      var _a;
  
      if (p1 instanceof Array) {
        console.warn(["Passing an array of plugins to Octokit.plugin() has been deprecated.", "Instead of:", "  Octokit.plugin([plugin1, plugin2, ...])", "Use:", "  Octokit.plugin(plugin1, plugin2, ...)"].join("\n"));
      }
  
      const currentPlugins = this.plugins;
      let newPlugins = [...(p1 instanceof Array ? p1 : [p1]), ...p2];
      const NewOctokit = (_a = class extends this {}, _a.plugins = currentPlugins.concat(newPlugins.filter(plugin => !currentPlugins.includes(plugin))), _a);
      return NewOctokit;
    }
  
  }
  Octokit.VERSION = VERSION;
  Octokit.plugins = [];
  
  exports.Octokit = Octokit;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 449 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  
  var path =
  /*#__PURE__*/
  __webpack_require__(756);
  /**
   * Determines whether a nested path on an object has a specific value, in
   * [`R.equals`](#equals) terms. Most likely used to filter a list.
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Relation
   * @typedefn Idx = String | Int
   * @sig [Idx] -> a -> {a} -> Boolean
   * @param {Array} path The path of the nested property to use
   * @param {*} val The value to compare the nested property with
   * @param {Object} obj The object to check the nested property in
   * @return {Boolean} `true` if the value equals the nested object property,
   *         `false` otherwise.
   * @example
   *
   *      const user1 = { address: { zipCode: 90210 } };
   *      const user2 = { address: { zipCode: 55555 } };
   *      const user3 = { name: 'Bob' };
   *      const users = [ user1, user2, user3 ];
   *      const isFamous = R.pathEq(['address', 'zipCode'], 90210);
   *      R.filter(isFamous, users); //=> [ user1 ]
   */
  
  
  var pathEq =
  /*#__PURE__*/
  _curry3(function pathEq(_path, val, obj) {
    return equals(path(_path, obj), val);
  });
  
  module.exports = pathEq;
  
  /***/ }),
  /* 450 */,
  /* 451 */
  /***/ (function(module) {
  
  function _arity(n, fn) {
    /* eslint-disable no-unused-vars */
    switch (n) {
      case 0:
        return function () {
          return fn.apply(this, arguments);
        };
  
      case 1:
        return function (a0) {
          return fn.apply(this, arguments);
        };
  
      case 2:
        return function (a0, a1) {
          return fn.apply(this, arguments);
        };
  
      case 3:
        return function (a0, a1, a2) {
          return fn.apply(this, arguments);
        };
  
      case 4:
        return function (a0, a1, a2, a3) {
          return fn.apply(this, arguments);
        };
  
      case 5:
        return function (a0, a1, a2, a3, a4) {
          return fn.apply(this, arguments);
        };
  
      case 6:
        return function (a0, a1, a2, a3, a4, a5) {
          return fn.apply(this, arguments);
        };
  
      case 7:
        return function (a0, a1, a2, a3, a4, a5, a6) {
          return fn.apply(this, arguments);
        };
  
      case 8:
        return function (a0, a1, a2, a3, a4, a5, a6, a7) {
          return fn.apply(this, arguments);
        };
  
      case 9:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
          return fn.apply(this, arguments);
        };
  
      case 10:
        return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
          return fn.apply(this, arguments);
        };
  
      default:
        throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
    }
  }
  
  module.exports = _arity;
  
  /***/ }),
  /* 452 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * See if an object (`val`) is an instance of the supplied constructor. This
   * function will check up the inheritance chain, if any.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category Type
   * @sig (* -> {*}) -> a -> Boolean
   * @param {Object} ctor A constructor
   * @param {*} val The value to test
   * @return {Boolean}
   * @example
   *
   *      R.is(Object, {}); //=> true
   *      R.is(Number, 1); //=> true
   *      R.is(Object, 1); //=> false
   *      R.is(String, 's'); //=> true
   *      R.is(String, new String('')); //=> true
   *      R.is(Object, new String('')); //=> true
   *      R.is(Object, 's'); //=> false
   *      R.is(Number, {}); //=> false
   */
  
  
  var is =
  /*#__PURE__*/
  _curry2(function is(Ctor, val) {
    return val != null && val.constructor === Ctor || val instanceof Ctor;
  });
  
  module.exports = is;
  
  /***/ }),
  /* 453 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var once = __webpack_require__(969)
  var eos = __webpack_require__(9)
  var fs = __webpack_require__(747) // 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
  
  
  /***/ }),
  /* 454 */,
  /* 455 */,
  /* 456 */,
  /* 457 */,
  /* 458 */,
  /* 459 */,
  /* 460 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var sum =
  /*#__PURE__*/
  __webpack_require__(218);
  /**
   * Returns the mean of the given list of numbers.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Math
   * @sig [Number] -> Number
   * @param {Array} list
   * @return {Number}
   * @see R.median
   * @example
   *
   *      R.mean([2, 7, 9]); //=> 6
   *      R.mean([]); //=> NaN
   */
  
  
  var mean =
  /*#__PURE__*/
  _curry1(function mean(list) {
    return sum(list) / list.length;
  });
  
  module.exports = mean;
  
  /***/ }),
  /* 461 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var assoc =
  /*#__PURE__*/
  __webpack_require__(414);
  
  var lens =
  /*#__PURE__*/
  __webpack_require__(596);
  
  var prop =
  /*#__PURE__*/
  __webpack_require__(196);
  /**
   * Returns a lens whose focus is the specified property.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig String -> Lens s a
   * @param {String} k
   * @return {Lens}
   * @see R.view, R.set, R.over
   * @example
   *
   *      const xLens = R.lensProp('x');
   *
   *      R.view(xLens, {x: 1, y: 2});            //=> 1
   *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
   *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
   */
  
  
  var lensProp =
  /*#__PURE__*/
  _curry1(function lensProp(k) {
    return lens(prop(k), assoc(k));
  });
  
  module.exports = lensProp;
  
  /***/ }),
  /* 462 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Creates a function that will process either the `onTrue` or the `onFalse`
   * function depending upon the result of the `condition` predicate.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Logic
   * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)
   * @param {Function} condition A predicate function
   * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.
   * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.
   * @return {Function} A new function that will process either the `onTrue` or the `onFalse`
   *                    function depending upon the result of the `condition` predicate.
   * @see R.unless, R.when, R.cond
   * @example
   *
   *      const incCount = R.ifElse(
   *        R.has('count'),
   *        R.over(R.lensProp('count'), R.inc),
   *        R.assoc('count', 1)
   *      );
   *      incCount({});           //=> { count: 1 }
   *      incCount({ count: 1 }); //=> { count: 2 }
   */
  
  
  var ifElse =
  /*#__PURE__*/
  _curry3(function ifElse(condition, onTrue, onFalse) {
    return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {
      return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);
    });
  });
  
  module.exports = ifElse;
  
  /***/ }),
  /* 463 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var deprecation = __webpack_require__(692);
  var once = _interopDefault(__webpack_require__(969));
  
  const logOnceCode = once(deprecation => console.warn(deprecation));
  const logOnceHeaders = once(deprecation => console.warn(deprecation));
  /**
   * Error with extra properties to help with debugging
   */
  
  class RequestError extends Error {
    constructor(message, statusCode, options) {
      super(message); // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
  
      this.name = "HttpError";
      this.status = statusCode;
      let headers;
  
      if ("headers" in options && typeof options.headers !== "undefined") {
        headers = options.headers;
      }
  
      if ("response" in options) {
        this.response = options.response;
        headers = options.response.headers;
      } // redact request credentials without mutating original request options
  
  
      const requestCopy = Object.assign({}, options.request);
  
      if (options.request.headers.authorization) {
        requestCopy.headers = Object.assign({}, options.request.headers, {
          authorization: options.request.headers.authorization.replace(/ .*$/, " [REDACTED]")
        });
      }
  
      requestCopy.url = requestCopy.url // client_id & client_secret can be passed as URL query parameters to increase rate limit
      // see https://developer.github.com/v3/#increasing-the-unauthenticated-rate-limit-for-oauth-applications
      .replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]") // OAuth tokens can be passed as URL query parameters, although it is not recommended
      // see https://developer.github.com/v3/#oauth2-token-sent-in-a-header
      .replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
      this.request = requestCopy; // deprecations
  
      Object.defineProperty(this, "code", {
        get() {
          logOnceCode(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
          return statusCode;
        }
  
      });
      Object.defineProperty(this, "headers", {
        get() {
          logOnceHeaders(new deprecation.Deprecation("[@octokit/request-error] `error.headers` is deprecated, use `error.response.headers`."));
          return headers || {};
        }
  
      });
    }
  
  }
  
  exports.RequestError = RequestError;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 464 */,
  /* 465 */,
  /* 466 */,
  /* 467 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Accepts a function `fn` and a list of transformer functions and returns a
   * new curried function. When the new function is invoked, it calls the
   * function `fn` with parameters consisting of the result of calling each
   * supplied handler on successive arguments to the new function.
   *
   * If more arguments are passed to the returned function than transformer
   * functions, those arguments are passed directly to `fn` as additional
   * parameters. If you expect additional arguments that don't need to be
   * transformed, although you can ignore them, it's best to pass an identity
   * function so that the new function reports the correct arity.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig ((x1, x2, ...) -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)
   * @param {Function} fn The function to wrap.
   * @param {Array} transformers A list of transformer functions
   * @return {Function} The wrapped function.
   * @see R.converge
   * @example
   *
   *      R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81
   *      R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81
   *      R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32
   *      R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32
   * @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b))
   */
  
  
  var useWith =
  /*#__PURE__*/
  _curry2(function useWith(fn, transformers) {
    return curryN(transformers.length, function () {
      var args = [];
      var idx = 0;
  
      while (idx < transformers.length) {
        args.push(transformers[idx].call(this, arguments[idx]));
        idx += 1;
      }
  
      return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));
    });
  });
  
  module.exports = useWith;
  
  /***/ }),
  /* 468 */,
  /* 469 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  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)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getOctokit = exports.context = void 0;
  const Context = __importStar(__webpack_require__(174));
  const utils_1 = __webpack_require__(562);
  exports.context = new Context.Context();
  /**
   * Returns a hydrated octokit ready to use for GitHub Actions
   *
   * @param     token    the repo PAT or GITHUB_TOKEN
   * @param     options  other options to set
   */
  function getOctokit(token, options) {
      return new utils_1.GitHub(utils_1.getOctokitOptions(token, options));
  }
  exports.getOctokit = getOctokit;
  //# sourceMappingURL=github.js.map
  
  /***/ }),
  /* 470 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0;
  const command_1 = __webpack_require__(431);
  const file_command_1 = __webpack_require__(102);
  const utils_1 = __webpack_require__(82);
  const os = __importStar(__webpack_require__(87));
  const path = __importStar(__webpack_require__(622));
  /**
   * The code to exit an action
   */
  var ExitCode;
  (function (ExitCode) {
      /**
       * A code indicating that the action was successful
       */
      ExitCode[ExitCode["Success"] = 0] = "Success";
      /**
       * A code indicating that the action was a failure
       */
      ExitCode[ExitCode["Failure"] = 1] = "Failure";
  })(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
  //-----------------------------------------------------------------------
  // Variables
  //-----------------------------------------------------------------------
  /**
   * Sets env variable for this action and future actions in the job
   * @param name the name of the variable to set
   * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function exportVariable(name, val) {
      const convertedVal = utils_1.toCommandValue(val);
      process.env[name] = convertedVal;
      const filePath = process.env['GITHUB_ENV'] || '';
      if (filePath) {
          const delimiter = '_GitHubActionsFileCommandDelimeter_';
          const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
          file_command_1.issueCommand('ENV', commandValue);
      }
      else {
          command_1.issueCommand('set-env', { name }, convertedVal);
      }
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      const filePath = process.env['GITHUB_PATH'] || '';
      if (filePath) {
          file_command_1.issueCommand('PATH', inputPath);
      }
      else {
          command_1.issueCommand('add-path', {}, inputPath);
      }
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.
   * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
   * Returns an empty string if the value is not defined.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      if (options && options.trimWhitespace === false) {
          return val;
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Gets the values of an multiline input.  Each value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string[]
   *
   */
  function getMultilineInput(name, options) {
      const inputs = getInput(name, options)
          .split('\n')
          .filter(x => x !== '');
      return inputs;
  }
  exports.getMultilineInput = getMultilineInput;
  /**
   * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
   * Support boolean input list: `true | True | TRUE | false | False | FALSE` .
   * The return value is also in boolean type.
   * ref: https://yaml.org/spec/1.2/spec.html#id2804923
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   boolean
   */
  function getBooleanInput(name, options) {
      const trueValue = ['true', 'True', 'TRUE'];
      const falseValue = ['false', 'False', 'FALSE'];
      const val = getInput(name, options);
      if (trueValue.includes(val))
          return true;
      if (falseValue.includes(val))
          return false;
      throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` +
          `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
  }
  exports.getBooleanInput = getBooleanInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      process.stdout.write(os.EOL);
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  /* 471 */,
  /* 472 */,
  /* 473 */,
  /* 474 */,
  /* 475 */,
  /* 476 */,
  /* 477 */,
  /* 478 */
  /***/ (function(module) {
  
  "use strict";
  
  
  const isWin = process.platform === 'win32';
  
  function notFoundError(original, syscall) {
      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
          code: 'ENOENT',
          errno: 'ENOENT',
          syscall: `${syscall} ${original.command}`,
          path: original.command,
          spawnargs: original.args,
      });
  }
  
  function hookChildProcess(cp, parsed) {
      if (!isWin) {
          return;
      }
  
      const originalEmit = cp.emit;
  
      cp.emit = function (name, arg1) {
          // If emitting "exit" event and exit code is 1, we need to check if
          // the command exists and emit an "error" instead
          // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
          if (name === 'exit') {
              const err = verifyENOENT(arg1, parsed, 'spawn');
  
              if (err) {
                  return originalEmit.call(cp, 'error', err);
              }
          }
  
          return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
      };
  }
  
  function verifyENOENT(status, parsed) {
      if (isWin && status === 1 && !parsed.file) {
          return notFoundError(parsed.original, 'spawn');
      }
  
      return null;
  }
  
  function verifyENOENTSync(status, parsed) {
      if (isWin && status === 1 && !parsed.file) {
          return notFoundError(parsed.original, 'spawnSync');
      }
  
      return null;
  }
  
  module.exports = {
      hookChildProcess,
      verifyENOENT,
      verifyENOENTSync,
      notFoundError,
  };
  
  
  /***/ }),
  /* 479 */,
  /* 480 */
  /***/ (function(module) {
  
  function _cloneRegExp(pattern) {
    return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));
  }
  
  module.exports = _cloneRegExp;
  
  /***/ }),
  /* 481 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _makeFlat =
  /*#__PURE__*/
  __webpack_require__(415);
  
  var _xchain =
  /*#__PURE__*/
  __webpack_require__(542);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  /**
   * `chain` maps a function over a list and concatenates the results. `chain`
   * is also known as `flatMap` in some libraries.
   *
   * Dispatches to the `chain` method of the second argument, if present,
   * according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain).
   *
   * If second argument is a function, `chain(f, g)(x)` is equivalent to `f(g(x), x)`.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category List
   * @sig Chain m => (a -> m b) -> m a -> m b
   * @param {Function} fn The function to map with
   * @param {Array} list The list to map over
   * @return {Array} The result of flat-mapping `list` with `fn`
   * @example
   *
   *      const duplicate = n => [n, n];
   *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
   *
   *      R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]
   */
  
  
  var chain =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) {
    if (typeof monad === 'function') {
      return function (x) {
        return fn(monad(x))(x);
      };
    }
  
    return _makeFlat(false)(map(fn, monad));
  }));
  
  module.exports = chain;
  
  /***/ }),
  /* 482 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xwrap =
  /*#__PURE__*/
  __webpack_require__(43);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Initializes a transducer using supplied iterator function. Returns a single
   * item by iterating through the list, successively calling the transformed
   * iterator function and passing it an accumulator value and the current value
   * from the array, and then passing the result to the next call.
   *
   * The iterator function receives two values: *(acc, value)*. It will be
   * wrapped as a transformer to initialize the transducer. A transformer can be
   * passed directly in place of an iterator function. In both cases, iteration
   * may be stopped early with the [`R.reduced`](#reduced) function.
   *
   * A transducer is a function that accepts a transformer and returns a
   * transformer and can be composed directly.
   *
   * A transformer is an an object that provides a 2-arity reducing iterator
   * function, step, 0-arity initial value function, init, and 1-arity result
   * extraction function, result. The step function is used as the iterator
   * function in reduce. The result function is used to convert the final
   * accumulator into the return type and in most cases is
   * [`R.identity`](#identity). The init function can be used to provide an
   * initial accumulator, but is ignored by transduce.
   *
   * The iteration is performed with [`R.reduce`](#reduce) after initializing the transducer.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category List
   * @sig (c -> c) -> ((a, b) -> a) -> a -> [b] -> a
   * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
   * @param {Function} fn The iterator function. Receives two values, the accumulator and the
   *        current element from the array. Wrapped as transformer, if necessary, and used to
   *        initialize the transducer
   * @param {*} acc The initial accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.reduce, R.reduced, R.into
   * @example
   *
   *      const numbers = [1, 2, 3, 4];
   *      const transducer = R.compose(R.map(R.add(1)), R.take(2));
   *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]
   *
   *      const isOdd = (x) => x % 2 === 1;
   *      const firstOddTransducer = R.compose(R.filter(isOdd), R.take(1));
   *      R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]
   */
  
  
  var transduce =
  /*#__PURE__*/
  curryN(4, function transduce(xf, fn, acc, list) {
    return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);
  });
  module.exports = transduce;
  
  /***/ }),
  /* 483 */,
  /* 484 */,
  /* 485 */,
  /* 486 */,
  /* 487 */,
  /* 488 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Tests a regular expression against a String. Note that this function will
   * return an empty array when there are no matches. This differs from
   * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
   * which returns `null` when there are no matches.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category String
   * @sig RegExp -> String -> [String | Undefined]
   * @param {RegExp} rx A regular expression.
   * @param {String} str The string to match against
   * @return {Array} The list of matches or empty array.
   * @see R.test
   * @example
   *
   *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']
   *      R.match(/a/, 'b'); //=> []
   *      R.match(/a/, null); //=> TypeError: null does not have a method named "match"
   */
  
  
  var match =
  /*#__PURE__*/
  _curry2(function match(rx, str) {
    return str.match(rx) || [];
  });
  
  module.exports = match;
  
  /***/ }),
  /* 489 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  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)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getApiBaseUrl = exports.getProxyAgent = exports.getAuthString = void 0;
  const httpClient = __importStar(__webpack_require__(217));
  function getAuthString(token, options) {
      if (!token && !options.auth) {
          throw new Error('Parameter token or opts.auth is required');
      }
      else if (token && options.auth) {
          throw new Error('Parameters token and opts.auth may not both be specified');
      }
      return typeof options.auth === 'string' ? options.auth : `token ${token}`;
  }
  exports.getAuthString = getAuthString;
  function getProxyAgent(destinationUrl) {
      const hc = new httpClient.HttpClient();
      return hc.getAgent(destinationUrl);
  }
  exports.getProxyAgent = getProxyAgent;
  function getApiBaseUrl() {
      return process.env['GITHUB_API_URL'] || 'https://api.github.com';
  }
  exports.getApiBaseUrl = getApiBaseUrl;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  /* 490 */,
  /* 491 */,
  /* 492 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _isObject =
  /*#__PURE__*/
  __webpack_require__(662);
  
  var mergeWithKey =
  /*#__PURE__*/
  __webpack_require__(681);
  /**
   * Creates a new object with the own properties of the two provided objects.
   * If a key exists in both objects:
   * - and both associated values are also objects then the values will be
   *   recursively merged.
   * - otherwise the provided function is applied to the key and associated values
   *   using the resulting value as the new value associated with the key.
   * If a key only exists in one object, the value will be associated with the key
   * of the resulting object.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Object
   * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}
   * @param {Function} fn
   * @param {Object} lObj
   * @param {Object} rObj
   * @return {Object}
   * @see R.mergeWithKey, R.mergeDeepWith
   * @example
   *
   *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r
   *      R.mergeDeepWithKey(concatValues,
   *                         { a: true, c: { thing: 'foo', values: [10, 20] }},
   *                         { b: true, c: { thing: 'bar', values: [15, 35] }});
   *      //=> { a: true, b: true, c: { thing: 'bar', values: [10, 20, 15, 35] }}
   */
  
  
  var mergeDeepWithKey =
  /*#__PURE__*/
  _curry3(function mergeDeepWithKey(fn, lObj, rObj) {
    return mergeWithKey(function (k, lVal, rVal) {
      if (_isObject(lVal) && _isObject(rVal)) {
        return mergeDeepWithKey(fn, lVal, rVal);
      } else {
        return fn(k, lVal, rVal);
      }
    }, lObj, rObj);
  });
  
  module.exports = mergeDeepWithKey;
  
  /***/ }),
  /* 493 */,
  /* 494 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  const execa = __webpack_require__(955);
  
  // Reference: https://www.gaijin.at/en/lstwinver.php
  const names = new Map([
  	['10.0', '10'],
  	['6.3', '8.1'],
  	['6.2', '8'],
  	['6.1', '7'],
  	['6.0', 'Vista'],
  	['5.2', 'Server 2003'],
  	['5.1', 'XP'],
  	['5.0', '2000'],
  	['4.9', 'ME'],
  	['4.1', '98'],
  	['4.0', '95']
  ]);
  
  const windowsRelease = release => {
  	const version = /\d+\.\d/.exec(release || os.release());
  
  	if (release && !version) {
  		throw new Error('`release` argument doesn\'t match `n.n`');
  	}
  
  	const ver = (version || [])[0];
  
  	// Server 2008, 2012, 2016, and 2019 versions are ambiguous with desktop versions and must be detected at runtime.
  	// If `release` is omitted or we're on a Windows system, and the version number is an ambiguous version
  	// then use `wmic` to get the OS caption: https://msdn.microsoft.com/en-us/library/aa394531(v=vs.85).aspx
  	// If `wmic` is obsoloete (later versions of Windows 10), use PowerShell instead.
  	// If the resulting caption contains the year 2008, 2012, 2016 or 2019, it is a server version, so return a server OS name.
  	if ((!release || release === os.release()) && ['6.1', '6.2', '6.3', '10.0'].includes(ver)) {
  		let stdout;
  		try {
  			stdout = execa.sync('wmic', ['os', 'get', 'Caption']).stdout || '';
  		} catch (_) {
  			stdout = execa.sync('powershell', ['(Get-CimInstance -ClassName Win32_OperatingSystem).caption']).stdout || '';
  		}
  
  		const year = (stdout.match(/2008|2012|2016|2019/) || [])[0];
  
  		if (year) {
  			return `Server ${year}`;
  		}
  	}
  
  	return names.get(ver);
  };
  
  module.exports = windowsRelease;
  
  
  /***/ }),
  /* 495 */,
  /* 496 */,
  /* 497 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Takes a list and returns a list of lists where each sublist's elements are
   * all satisfied pairwise comparison according to the provided function.
   * Only adjacent elements are passed to the comparison function.
   *
   * @func
   * @memberOf R
   * @since v0.21.0
   * @category List
   * @sig ((a, a) → Boolean) → [a] → [[a]]
   * @param {Function} fn Function for determining whether two given (adjacent)
   *        elements should be in the same group
   * @param {Array} list The array to group. Also accepts a string, which will be
   *        treated as a list of characters.
   * @return {List} A list that contains sublists of elements,
   *         whose concatenations are equal to the original list.
   * @example
   *
   * R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])
   * //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]
   *
   * R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21])
   * //=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]]
   *
   * R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])
   * //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]
   *
   * R.groupWith(R.eqBy(isVowel), 'aestiou')
   * //=> ['ae', 'st', 'iou']
   */
  
  
  var groupWith =
  /*#__PURE__*/
  _curry2(function (fn, list) {
    var res = [];
    var idx = 0;
    var len = list.length;
  
    while (idx < len) {
      var nextidx = idx + 1;
  
      while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {
        nextidx += 1;
      }
  
      res.push(list.slice(idx, nextidx));
      idx = nextidx;
    }
  
    return res;
  });
  
  module.exports = groupWith;
  
  /***/ }),
  /* 498 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xtake =
  /*#__PURE__*/
  __webpack_require__(694);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns the first `n` elements of the given list, string, or
   * transducer/transformer (or object with a `take` method).
   *
   * Dispatches to the `take` method of the second argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Number -> [a] -> [a]
   * @sig Number -> String -> String
   * @param {Number} n
   * @param {*} list
   * @return {*}
   * @see R.drop
   * @example
   *
   *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']
   *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
   *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
   *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
   *      R.take(3, 'ramda');               //=> 'ram'
   *
   *      const personnel = [
   *        'Dave Brubeck',
   *        'Paul Desmond',
   *        'Eugene Wright',
   *        'Joe Morello',
   *        'Gerry Mulligan',
   *        'Bob Bates',
   *        'Joe Dodge',
   *        'Ron Crotty'
   *      ];
   *
   *      const takeFive = R.take(5);
   *      takeFive(personnel);
   *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']
   * @symb R.take(-1, [a, b]) = [a, b]
   * @symb R.take(0, [a, b]) = []
   * @symb R.take(1, [a, b]) = [a]
   * @symb R.take(2, [a, b]) = [a, b]
   */
  
  
  var take =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['take'], _xtake, function take(n, xs) {
    return slice(0, n < 0 ? Infinity : n, xs);
  }));
  
  module.exports = take;
  
  /***/ }),
  /* 499 */,
  /* 500 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var reduceBy =
  /*#__PURE__*/
  __webpack_require__(729);
  /**
   * Given a function that generates a key, turns a list of objects into an
   * object indexing the objects by the given key. Note that if multiple
   * objects generate the same value for the indexing key only the last value
   * will be included in the generated object.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig (a -> String) -> [{k: v}] -> {k: {k: v}}
   * @param {Function} fn Function :: a -> String
   * @param {Array} array The array of objects to index
   * @return {Object} An object indexing each array element by the given property.
   * @example
   *
   *      const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
   *      R.indexBy(R.prop('id'), list);
   *      //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}
   */
  
  
  var indexBy =
  /*#__PURE__*/
  reduceBy(function (acc, elem) {
    return elem;
  }, null);
  module.exports = indexBy;
  
  /***/ }),
  /* 501 */
  /***/ (function(module) {
  
  function _of(x) {
    return [x];
  }
  
  module.exports = _of;
  
  /***/ }),
  /* 502 */,
  /* 503 */,
  /* 504 */
  /***/ (function(module) {
  
  function _isFunction(x) {
    var type = Object.prototype.toString.call(x);
    return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]';
  }
  
  module.exports = _isFunction;
  
  /***/ }),
  /* 505 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var mergeDeepWithKey =
  /*#__PURE__*/
  __webpack_require__(492);
  /**
   * Creates a new object with the own properties of the first object merged with
   * the own properties of the second object. If a key exists in both objects:
   * - and both values are objects, the two values will be recursively merged
   * - otherwise the value from the second object will be used.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Object
   * @sig {a} -> {a} -> {a}
   * @param {Object} lObj
   * @param {Object} rObj
   * @return {Object}
   * @see R.merge, R.mergeDeepLeft, R.mergeDeepWith, R.mergeDeepWithKey
   * @example
   *
   *      R.mergeDeepRight({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},
   *                       { age: 40, contact: { email: 'baa@example.com' }});
   *      //=> { name: 'fred', age: 40, contact: { email: 'baa@example.com' }}
   */
  
  
  var mergeDeepRight =
  /*#__PURE__*/
  _curry2(function mergeDeepRight(lObj, rObj) {
    return mergeDeepWithKey(function (k, lVal, rVal) {
      return rVal;
    }, lObj, rObj);
  });
  
  module.exports = mergeDeepRight;
  
  /***/ }),
  /* 506 */,
  /* 507 */,
  /* 508 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Divides the first parameter by the second and returns the remainder. Note
   * that this function preserves the JavaScript-style behavior for modulo. For
   * mathematical modulo see [`mathMod`](#mathMod).
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} a The value to the divide.
   * @param {Number} b The pseudo-modulus
   * @return {Number} The result of `b % a`.
   * @see R.mathMod
   * @example
   *
   *      R.modulo(17, 3); //=> 2
   *      // JS behavior:
   *      R.modulo(-17, 3); //=> -2
   *      R.modulo(17, -3); //=> 2
   *
   *      const isOdd = R.modulo(R.__, 2);
   *      isOdd(42); //=> 0
   *      isOdd(21); //=> 1
   */
  
  
  var modulo =
  /*#__PURE__*/
  _curry2(function modulo(a, b) {
    return a % b;
  });
  
  module.exports = modulo;
  
  /***/ }),
  /* 509 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Converts an object into an array of key, value arrays. The object's own
   * properties and prototype properties are used. Note that the order of the
   * output array is not guaranteed to be consistent across different JS
   * platforms.
   *
   * @func
   * @memberOf R
   * @since v0.4.0
   * @category Object
   * @sig {String: *} -> [[String,*]]
   * @param {Object} obj The object to extract from
   * @return {Array} An array of key, value arrays from the object's own
   *         and prototype properties.
   * @example
   *
   *      const F = function() { this.x = 'X'; };
   *      F.prototype.y = 'Y';
   *      const f = new F();
   *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]
   */
  
  
  var toPairsIn =
  /*#__PURE__*/
  _curry1(function toPairsIn(obj) {
    var pairs = [];
  
    for (var prop in obj) {
      pairs[pairs.length] = [prop, obj[prop]];
    }
  
    return pairs;
  });
  
  module.exports = toPairsIn;
  
  /***/ }),
  /* 510 */
  /***/ (function(module) {
  
  module.exports = addHook;
  
  function addHook(state, kind, name, hook) {
    var orig = hook;
    if (!state.registry[name]) {
      state.registry[name] = [];
    }
  
    if (kind === "before") {
      hook = function (method, options) {
        return Promise.resolve()
          .then(orig.bind(null, options))
          .then(method.bind(null, options));
      };
    }
  
    if (kind === "after") {
      hook = function (method, options) {
        var result;
        return Promise.resolve()
          .then(method.bind(null, options))
          .then(function (result_) {
            result = result_;
            return orig(result, options);
          })
          .then(function () {
            return result;
          });
      };
    }
  
    if (kind === "error") {
      hook = function (method, options) {
        return Promise.resolve()
          .then(method.bind(null, options))
          .catch(function (error) {
            return orig(error, options);
          });
      };
    }
  
    state.registry[name].push({
      hook: hook,
      orig: orig,
    });
  }
  
  
  /***/ }),
  /* 511 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var hasPath =
  /*#__PURE__*/
  __webpack_require__(303);
  /**
   * Returns whether or not an object has an own property with the specified name
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Object
   * @sig s -> {s: x} -> Boolean
   * @param {String} prop The name of the property to check for.
   * @param {Object} obj The object to query.
   * @return {Boolean} Whether the property exists.
   * @example
   *
   *      const hasName = R.has('name');
   *      hasName({name: 'alice'});   //=> true
   *      hasName({name: 'bob'});     //=> true
   *      hasName({});                //=> false
   *
   *      const point = {x: 0, y: 0};
   *      const pointHas = R.has(R.__, point);
   *      pointHas('x');  //=> true
   *      pointHas('y');  //=> true
   *      pointHas('z');  //=> false
   */
  
  
  var has =
  /*#__PURE__*/
  _curry2(function has(prop, obj) {
    return hasPath([prop], obj);
  });
  
  module.exports = has;
  
  /***/ }),
  /* 512 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const path = __webpack_require__(622);
  const pathKey = __webpack_require__(359);
  
  module.exports = opts => {
  	opts = Object.assign({
  		cwd: process.cwd(),
  		path: process.env[pathKey()]
  	}, opts);
  
  	let prev;
  	let pth = path.resolve(opts.cwd);
  	const ret = [];
  
  	while (prev !== pth) {
  		ret.push(path.join(pth, 'node_modules/.bin'));
  		prev = pth;
  		pth = path.resolve(pth, '..');
  	}
  
  	// ensure the running `node` binary is used
  	ret.push(path.dirname(process.execPath));
  
  	return ret.concat(opts.path).join(path.delimiter);
  };
  
  module.exports.env = opts => {
  	opts = Object.assign({
  		env: process.env
  	}, opts);
  
  	const env = Object.assign({}, opts.env);
  	const path = pathKey({env});
  
  	opts.path = env[path];
  	env[path] = module.exports(opts);
  
  	return env;
  };
  
  
  /***/ }),
  /* 513 */,
  /* 514 */,
  /* 515 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var lens =
  /*#__PURE__*/
  __webpack_require__(596);
  
  var nth =
  /*#__PURE__*/
  __webpack_require__(653);
  
  var update =
  /*#__PURE__*/
  __webpack_require__(881);
  /**
   * Returns a lens whose focus is the specified index.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig Number -> Lens s a
   * @param {Number} n
   * @return {Lens}
   * @see R.view, R.set, R.over, R.nth
   * @example
   *
   *      const headLens = R.lensIndex(0);
   *
   *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'
   *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']
   *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
   */
  
  
  var lensIndex =
  /*#__PURE__*/
  _curry1(function lensIndex(n) {
    return lens(nth(n), update(n));
  });
  
  module.exports = lensIndex;
  
  /***/ }),
  /* 516 */,
  /* 517 */,
  /* 518 */,
  /* 519 */,
  /* 520 */,
  /* 521 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isFunction =
  /*#__PURE__*/
  __webpack_require__(504);
  
  var and =
  /*#__PURE__*/
  __webpack_require__(676);
  
  var lift =
  /*#__PURE__*/
  __webpack_require__(127);
  /**
   * A function which calls the two provided functions and returns the `&&`
   * of the results.
   * It returns the result of the first function if it is false-y and the result
   * of the second function otherwise. Note that this is short-circuited,
   * meaning that the second function will not be invoked if the first returns a
   * false-y value.
   *
   * In addition to functions, `R.both` also accepts any fantasy-land compatible
   * applicative functor.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category Logic
   * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
   * @param {Function} f A predicate
   * @param {Function} g Another predicate
   * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.
   * @see R.and
   * @example
   *
   *      const gt10 = R.gt(R.__, 10)
   *      const lt20 = R.lt(R.__, 20)
   *      const f = R.both(gt10, lt20);
   *      f(15); //=> true
   *      f(30); //=> false
   *
   *      R.both(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(false)
   *      R.both([false, false, 'a'], [11]); //=> [false, false, 11]
   */
  
  
  var both =
  /*#__PURE__*/
  _curry2(function both(f, g) {
    return _isFunction(f) ? function _both() {
      return f.apply(this, arguments) && g.apply(this, arguments);
    } : lift(and)(f, g);
  });
  
  module.exports = both;
  
  /***/ }),
  /* 522 */,
  /* 523 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _map =
  /*#__PURE__*/
  __webpack_require__(626);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xmap =
  /*#__PURE__*/
  __webpack_require__(271);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Takes a function and
   * a [functor](https://github.com/fantasyland/fantasy-land#functor),
   * applies the function to each of the functor's values, and returns
   * a functor of the same shape.
   *
   * Ramda provides suitable `map` implementations for `Array` and `Object`,
   * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
   *
   * Dispatches to the `map` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * Also treats functions as functors and will compose them together.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Functor f => (a -> b) -> f a -> f b
   * @param {Function} fn The function to be called on every element of the input `list`.
   * @param {Array} list The list to be iterated over.
   * @return {Array} The new list.
   * @see R.transduce, R.addIndex
   * @example
   *
   *      const double = x => x * 2;
   *
   *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]
   *
   *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
   * @symb R.map(f, [a, b]) = [f(a), f(b)]
   * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }
   * @symb R.map(f, functor_o) = functor_o.map(f)
   */
  
  
  var map =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {
    switch (Object.prototype.toString.call(functor)) {
      case '[object Function]':
        return curryN(functor.length, function () {
          return fn.call(this, functor.apply(this, arguments));
        });
  
      case '[object Object]':
        return _reduce(function (acc, key) {
          acc[key] = fn(functor[key]);
          return acc;
        }, {}, keys(functor));
  
      default:
        return _map(fn, functor);
    }
  }));
  
  module.exports = map;
  
  /***/ }),
  /* 524 */,
  /* 525 */,
  /* 526 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isInteger =
  /*#__PURE__*/
  __webpack_require__(802);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var assoc =
  /*#__PURE__*/
  __webpack_require__(414);
  
  var dissoc =
  /*#__PURE__*/
  __webpack_require__(799);
  
  var remove =
  /*#__PURE__*/
  __webpack_require__(917);
  
  var update =
  /*#__PURE__*/
  __webpack_require__(881);
  /**
   * Makes a shallow clone of an object, omitting the property at the given path.
   * Note that this copies and flattens prototype properties onto the new object
   * as well. All non-primitive properties are copied by reference.
   *
   * @func
   * @memberOf R
   * @since v0.11.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig [Idx] -> {k: v} -> {k: v}
   * @param {Array} path The path to the value to omit
   * @param {Object} obj The object to clone
   * @return {Object} A new object without the property at path
   * @see R.assocPath
   * @example
   *
   *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
   */
  
  
  var dissocPath =
  /*#__PURE__*/
  _curry2(function dissocPath(path, obj) {
    switch (path.length) {
      case 0:
        return obj;
  
      case 1:
        return _isInteger(path[0]) && _isArray(obj) ? remove(path[0], 1, obj) : dissoc(path[0], obj);
  
      default:
        var head = path[0];
        var tail = Array.prototype.slice.call(path, 1);
  
        if (obj[head] == null) {
          return obj;
        } else if (_isInteger(head) && _isArray(obj)) {
          return update(head, dissocPath(tail, obj[head]), obj);
        } else {
          return assoc(head, dissocPath(tail, obj[head]), obj);
        }
  
    }
  });
  
  module.exports = dissocPath;
  
  /***/ }),
  /* 527 */,
  /* 528 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _isString =
  /*#__PURE__*/
  __webpack_require__(285);
  /**
   * Returns a new list or string with the elements or characters in reverse
   * order.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [a]
   * @sig String -> String
   * @param {Array|String} list
   * @return {Array|String}
   * @example
   *
   *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]
   *      R.reverse([1, 2]);     //=> [2, 1]
   *      R.reverse([1]);        //=> [1]
   *      R.reverse([]);         //=> []
   *
   *      R.reverse('abc');      //=> 'cba'
   *      R.reverse('ab');       //=> 'ba'
   *      R.reverse('a');        //=> 'a'
   *      R.reverse('');         //=> ''
   */
  
  
  var reverse =
  /*#__PURE__*/
  _curry1(function reverse(list) {
    return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();
  });
  
  module.exports = reverse;
  
  /***/ }),
  /* 529 */,
  /* 530 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curryN =
  /*#__PURE__*/
  __webpack_require__(404);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XReduceBy =
  /*#__PURE__*/
  function () {
    function XReduceBy(valueFn, valueAcc, keyFn, xf) {
      this.valueFn = valueFn;
      this.valueAcc = valueAcc;
      this.keyFn = keyFn;
      this.xf = xf;
      this.inputs = {};
    }
  
    XReduceBy.prototype['@@transducer/init'] = _xfBase.init;
  
    XReduceBy.prototype['@@transducer/result'] = function (result) {
      var key;
  
      for (key in this.inputs) {
        if (_has(key, this.inputs)) {
          result = this.xf['@@transducer/step'](result, this.inputs[key]);
  
          if (result['@@transducer/reduced']) {
            result = result['@@transducer/value'];
            break;
          }
        }
      }
  
      this.inputs = null;
      return this.xf['@@transducer/result'](result);
    };
  
    XReduceBy.prototype['@@transducer/step'] = function (result, input) {
      var key = this.keyFn(input);
      this.inputs[key] = this.inputs[key] || [key, this.valueAcc];
      this.inputs[key][1] = this.valueFn(this.inputs[key][1], input);
      return result;
    };
  
    return XReduceBy;
  }();
  
  var _xreduceBy =
  /*#__PURE__*/
  _curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) {
    return new XReduceBy(valueFn, valueAcc, keyFn, xf);
  });
  
  module.exports = _xreduceBy;
  
  /***/ }),
  /* 531 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xdropWhile =
  /*#__PURE__*/
  __webpack_require__(811);
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  /**
   * Returns a new list excluding the leading elements of a given list which
   * satisfy the supplied predicate function. It passes each value to the supplied
   * predicate function, skipping elements while the predicate function returns
   * `true`. The predicate function is applied to one argument: *(value)*.
   *
   * Dispatches to the `dropWhile` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> [a]
   * @sig (a -> Boolean) -> String -> String
   * @param {Function} fn The function called per iteration.
   * @param {Array} xs The collection to iterate over.
   * @return {Array} A new array.
   * @see R.takeWhile, R.transduce, R.addIndex
   * @example
   *
   *      const lteTwo = x => x <= 2;
   *
   *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
   *
   *      R.dropWhile(x => x !== 'd' , 'Ramda'); //=> 'da'
   */
  
  
  var dropWhile =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, xs) {
    var idx = 0;
    var len = xs.length;
  
    while (idx < len && pred(xs[idx])) {
      idx += 1;
    }
  
    return slice(idx, Infinity, xs);
  }));
  
  module.exports = dropWhile;
  
  /***/ }),
  /* 532 */,
  /* 533 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _dropLastWhile =
  /*#__PURE__*/
  __webpack_require__(643);
  
  var _xdropLastWhile =
  /*#__PURE__*/
  __webpack_require__(742);
  /**
   * Returns a new list excluding all the tailing elements of a given list which
   * satisfy the supplied predicate function. It passes each value from the right
   * to the supplied predicate function, skipping elements until the predicate
   * function returns a `falsy` value. The predicate function is applied to one argument:
   * *(value)*.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> [a]
   * @sig (a -> Boolean) -> String -> String
   * @param {Function} predicate The function to be called on each element
   * @param {Array} xs The collection to iterate over.
   * @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`.
   * @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile
   * @example
   *
   *      const lteThree = x => x <= 3;
   *
   *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
   *
   *      R.dropLastWhile(x => x !== 'd' , 'Ramda'); //=> 'Ramd'
   */
  
  
  var dropLastWhile =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xdropLastWhile, _dropLastWhile));
  
  module.exports = dropLastWhile;
  
  /***/ }),
  /* 534 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _identity =
  /*#__PURE__*/
  __webpack_require__(631);
  /**
   * A function that does nothing but return the parameter supplied to it. Good
   * as a default or placeholder function.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig a -> a
   * @param {*} x The value to return.
   * @return {*} The input value, `x`.
   * @example
   *
   *      R.identity(1); //=> 1
   *
   *      const obj = {};
   *      R.identity(obj) === obj; //=> true
   * @symb R.identity(a) = a
   */
  
  
  var identity =
  /*#__PURE__*/
  _curry1(_identity);
  
  module.exports = identity;
  
  /***/ }),
  /* 535 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _curryN =
  /*#__PURE__*/
  __webpack_require__(404);
  /**
   * Returns a curried equivalent of the provided function, with the specified
   * arity. The curried function has two unusual capabilities. First, its
   * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
   * following are equivalent:
   *
   *   - `g(1)(2)(3)`
   *   - `g(1)(2, 3)`
   *   - `g(1, 2)(3)`
   *   - `g(1, 2, 3)`
   *
   * Secondly, the special placeholder value [`R.__`](#__) may be used to specify
   * "gaps", allowing partial application of any combination of arguments,
   * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),
   * the following are equivalent:
   *
   *   - `g(1, 2, 3)`
   *   - `g(_, 2, 3)(1)`
   *   - `g(_, _, 3)(1)(2)`
   *   - `g(_, _, 3)(1, 2)`
   *   - `g(_, 2)(1)(3)`
   *   - `g(_, 2)(1, 3)`
   *   - `g(_, 2)(_, 3)(1)`
   *
   * @func
   * @memberOf R
   * @since v0.5.0
   * @category Function
   * @sig Number -> (* -> a) -> (* -> a)
   * @param {Number} length The arity for the returned function.
   * @param {Function} fn The function to curry.
   * @return {Function} A new, curried function.
   * @see R.curry
   * @example
   *
   *      const sumArgs = (...args) => R.sum(args);
   *
   *      const curriedAddFourNumbers = R.curryN(4, sumArgs);
   *      const f = curriedAddFourNumbers(1, 2);
   *      const g = f(3);
   *      g(4); //=> 10
   */
  
  
  var curryN =
  /*#__PURE__*/
  _curry2(function curryN(length, fn) {
    if (length === 1) {
      return _curry1(fn);
    }
  
    return _arity(length, _curryN(length, [], fn));
  });
  
  module.exports = curryN;
  
  /***/ }),
  /* 536 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Exclusive disjunction logical operation.
   * Returns `true` if one of the arguments is truthy and the other is falsy.
   * Otherwise, it returns `false`.
   *
   * @func
   * @memberOf R
   * @since v0.27.1
   * @category Logic
   * @sig a -> b -> Boolean
   * @param {Any} a
   * @param {Any} b
   * @return {Boolean} true if one of the arguments is truthy and the other is falsy
   * @see R.or, R.and
   * @example
   *
   *      R.xor(true, true); //=> false
   *      R.xor(true, false); //=> true
   *      R.xor(false, true); //=> true
   *      R.xor(false, false); //=> false
   */
  
  
  var xor =
  /*#__PURE__*/
  _curry2(function xor(a, b) {
    return Boolean(!a ^ !b);
  });
  
  module.exports = xor;
  
  /***/ }),
  /* 537 */,
  /* 538 */,
  /* 539 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var where =
  /*#__PURE__*/
  __webpack_require__(113);
  /**
   * Takes a spec object and a test object; returns true if the test satisfies
   * the spec, false otherwise. An object satisfies the spec if, for each of the
   * spec's own properties, accessing that property of the object gives the same
   * value (in [`R.equals`](#equals) terms) as accessing that property of the
   * spec.
   *
   * `whereEq` is a specialization of [`where`](#where).
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Object
   * @sig {String: *} -> {String: *} -> Boolean
   * @param {Object} spec
   * @param {Object} testObj
   * @return {Boolean}
   * @see R.propEq, R.where
   * @example
   *
   *      // pred :: Object -> Boolean
   *      const pred = R.whereEq({a: 1, b: 2});
   *
   *      pred({a: 1});              //=> false
   *      pred({a: 1, b: 2});        //=> true
   *      pred({a: 1, b: 2, c: 3});  //=> true
   *      pred({a: 1, b: 1});        //=> false
   */
  
  
  var whereEq =
  /*#__PURE__*/
  _curry2(function whereEq(spec, testObj) {
    return where(map(equals, spec), testObj);
  });
  
  module.exports = whereEq;
  
  /***/ }),
  /* 540 */,
  /* 541 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var lift =
  /*#__PURE__*/
  __webpack_require__(127);
  
  var not =
  /*#__PURE__*/
  __webpack_require__(237);
  /**
   * Takes a function `f` and returns a function `g` such that if called with the same arguments
   * when `f` returns a "truthy" value, `g` returns `false` and when `f` returns a "falsy" value `g` returns `true`.
   *
   * `R.complement` may be applied to any functor
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category Logic
   * @sig (*... -> *) -> (*... -> Boolean)
   * @param {Function} f
   * @return {Function}
   * @see R.not
   * @example
   *
   *      const isNotNil = R.complement(R.isNil);
   *      isNil(null); //=> true
   *      isNotNil(null); //=> false
   *      isNil(7); //=> false
   *      isNotNil(7); //=> true
   */
  
  
  var complement =
  /*#__PURE__*/
  lift(not);
  module.exports = complement;
  
  /***/ }),
  /* 542 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _flatCat =
  /*#__PURE__*/
  __webpack_require__(347);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var _xchain =
  /*#__PURE__*/
  _curry2(function _xchain(f, xf) {
    return map(f, _flatCat(xf));
  });
  
  module.exports = _xchain;
  
  /***/ }),
  /* 543 */,
  /* 544 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XFindLast =
  /*#__PURE__*/
  function () {
    function XFindLast(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XFindLast.prototype['@@transducer/init'] = _xfBase.init;
  
    XFindLast.prototype['@@transducer/result'] = function (result) {
      return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));
    };
  
    XFindLast.prototype['@@transducer/step'] = function (result, input) {
      if (this.f(input)) {
        this.last = input;
      }
  
      return result;
    };
  
    return XFindLast;
  }();
  
  var _xfindLast =
  /*#__PURE__*/
  _curry2(function _xfindLast(f, xf) {
    return new XFindLast(f, xf);
  });
  
  module.exports = _xfindLast;
  
  /***/ }),
  /* 545 */,
  /* 546 */,
  /* 547 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Restricts a number to be within a range.
   *
   * Also works for other ordered types such as Strings and Dates.
   *
   * @func
   * @memberOf R
   * @since v0.20.0
   * @category Relation
   * @sig Ord a => a -> a -> a -> a
   * @param {Number} minimum The lower limit of the clamp (inclusive)
   * @param {Number} maximum The upper limit of the clamp (inclusive)
   * @param {Number} value Value to be clamped
   * @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise
   * @example
   *
   *      R.clamp(1, 10, -5) // => 1
   *      R.clamp(1, 10, 15) // => 10
   *      R.clamp(1, 10, 4)  // => 4
   */
  
  
  var clamp =
  /*#__PURE__*/
  _curry3(function clamp(min, max, value) {
    if (min > max) {
      throw new Error('min must not be greater than max in clamp(min, max, value)');
    }
  
    return value < min ? min : value > max ? max : value;
  });
  
  module.exports = clamp;
  
  /***/ }),
  /* 548 */,
  /* 549 */,
  /* 550 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XAperture =
  /*#__PURE__*/
  function () {
    function XAperture(n, xf) {
      this.xf = xf;
      this.pos = 0;
      this.full = false;
      this.acc = new Array(n);
    }
  
    XAperture.prototype['@@transducer/init'] = _xfBase.init;
  
    XAperture.prototype['@@transducer/result'] = function (result) {
      this.acc = null;
      return this.xf['@@transducer/result'](result);
    };
  
    XAperture.prototype['@@transducer/step'] = function (result, input) {
      this.store(input);
      return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;
    };
  
    XAperture.prototype.store = function (input) {
      this.acc[this.pos] = input;
      this.pos += 1;
  
      if (this.pos === this.acc.length) {
        this.pos = 0;
        this.full = true;
      }
    };
  
    XAperture.prototype.getCopy = function () {
      return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos));
    };
  
    return XAperture;
  }();
  
  var _xaperture =
  /*#__PURE__*/
  _curry2(function _xaperture(n, xf) {
    return new XAperture(n, xf);
  });
  
  module.exports = _xaperture;
  
  /***/ }),
  /* 551 */,
  /* 552 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Gives a single-word string description of the (native) type of a value,
   * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
   * attempt to distinguish user Object types any further, reporting them all as
   * 'Object'.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Type
   * @sig (* -> {*}) -> String
   * @param {*} val The value to test
   * @return {String}
   * @example
   *
   *      R.type({}); //=> "Object"
   *      R.type(1); //=> "Number"
   *      R.type(false); //=> "Boolean"
   *      R.type('s'); //=> "String"
   *      R.type(null); //=> "Null"
   *      R.type([]); //=> "Array"
   *      R.type(/[A-z]/); //=> "RegExp"
   *      R.type(() => {}); //=> "Function"
   *      R.type(undefined); //=> "Undefined"
   */
  
  
  var type =
  /*#__PURE__*/
  _curry1(function type(val) {
    return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);
  });
  
  module.exports = type;
  
  /***/ }),
  /* 553 */,
  /* 554 */,
  /* 555 */,
  /* 556 */,
  /* 557 */,
  /* 558 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Reports whether two objects have the same value, in [`R.equals`](#equals)
   * terms, for the specified property. Useful as a curried predicate.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig k -> {k: v} -> {k: v} -> Boolean
   * @param {String} prop The name of the property to compare
   * @param {Object} obj1
   * @param {Object} obj2
   * @return {Boolean}
   *
   * @example
   *
   *      const o1 = { a: 1, b: 2, c: 3, d: 4 };
   *      const o2 = { a: 10, b: 20, c: 3, d: 40 };
   *      R.eqProps('a', o1, o2); //=> false
   *      R.eqProps('c', o1, o2); //=> true
   */
  
  
  var eqProps =
  /*#__PURE__*/
  _curry3(function eqProps(prop, obj1, obj2) {
    return equals(obj1[prop], obj2[prop]);
  });
  
  module.exports = eqProps;
  
  /***/ }),
  /* 559 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Scan is similar to [`reduce`](#reduce), but returns a list of successively
   * reduced values from the left
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category List
   * @sig ((a, b) -> a) -> a -> [b] -> [a]
   * @param {Function} fn The iterator function. Receives two values, the accumulator and the
   *        current element from the array
   * @param {*} acc The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {Array} A list of all intermediately reduced values.
   * @see R.reduce, R.mapAccum
   * @example
   *
   *      const numbers = [1, 2, 3, 4];
   *      const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
   * @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)]
   */
  
  
  var scan =
  /*#__PURE__*/
  _curry3(function scan(fn, acc, list) {
    var idx = 0;
    var len = list.length;
    var result = [acc];
  
    while (idx < len) {
      acc = fn(acc, list[idx]);
      result[idx + 1] = acc;
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = scan;
  
  /***/ }),
  /* 560 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XDropLast =
  /*#__PURE__*/
  function () {
    function XDropLast(n, xf) {
      this.xf = xf;
      this.pos = 0;
      this.full = false;
      this.acc = new Array(n);
    }
  
    XDropLast.prototype['@@transducer/init'] = _xfBase.init;
  
    XDropLast.prototype['@@transducer/result'] = function (result) {
      this.acc = null;
      return this.xf['@@transducer/result'](result);
    };
  
    XDropLast.prototype['@@transducer/step'] = function (result, input) {
      if (this.full) {
        result = this.xf['@@transducer/step'](result, this.acc[this.pos]);
      }
  
      this.store(input);
      return result;
    };
  
    XDropLast.prototype.store = function (input) {
      this.acc[this.pos] = input;
      this.pos += 1;
  
      if (this.pos === this.acc.length) {
        this.pos = 0;
        this.full = true;
      }
    };
  
    return XDropLast;
  }();
  
  var _xdropLast =
  /*#__PURE__*/
  _curry2(function _xdropLast(n, xf) {
    return new XDropLast(n, xf);
  });
  
  module.exports = _xdropLast;
  
  /***/ }),
  /* 561 */,
  /* 562 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  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)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getOctokitOptions = exports.GitHub = exports.context = void 0;
  const Context = __importStar(__webpack_require__(174));
  const Utils = __importStar(__webpack_require__(489));
  // octokit + plugins
  const core_1 = __webpack_require__(448);
  const plugin_rest_endpoint_methods_1 = __webpack_require__(842);
  const plugin_paginate_rest_1 = __webpack_require__(299);
  exports.context = new Context.Context();
  const baseUrl = Utils.getApiBaseUrl();
  const defaults = {
      baseUrl,
      request: {
          agent: Utils.getProxyAgent(baseUrl)
      }
  };
  exports.GitHub = core_1.Octokit.plugin(plugin_rest_endpoint_methods_1.restEndpointMethods, plugin_paginate_rest_1.paginateRest).defaults(defaults);
  /**
   * Convience function to correctly format Octokit Options to pass into the constructor.
   *
   * @param     token    the repo PAT or GITHUB_TOKEN
   * @param     options  other options to set
   */
  function getOctokitOptions(token, options) {
      const opts = Object.assign({}, options || {}); // Shallow clone - don't mutate the object provided by the caller
      // Auth
      const auth = Utils.getAuthString(token, opts);
      if (auth) {
          opts.auth = auth;
      }
      return opts;
  }
  exports.getOctokitOptions = getOctokitOptions;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  /* 563 */,
  /* 564 */,
  /* 565 */,
  /* 566 */,
  /* 567 */,
  /* 568 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(622);
  const niceTry = __webpack_require__(948);
  const resolveCommand = __webpack_require__(411);
  const escape = __webpack_require__(981);
  const readShebang = __webpack_require__(389);
  const semver = __webpack_require__(48);
  
  const isWin = process.platform === 'win32';
  const isExecutableRegExp = /\.(?:com|exe)$/i;
  const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
  
  // `options.shell` is supported in Node ^4.8.0, ^5.7.0 and >= 6.0.0
  const supportsShellOption = niceTry(() => semver.satisfies(process.version, '^4.8.0 || ^5.7.0 || >= 6.0.0', true)) || false;
  
  function detectShebang(parsed) {
      parsed.file = resolveCommand(parsed);
  
      const shebang = parsed.file && readShebang(parsed.file);
  
      if (shebang) {
          parsed.args.unshift(parsed.file);
          parsed.command = shebang;
  
          return resolveCommand(parsed);
      }
  
      return parsed.file;
  }
  
  function parseNonShell(parsed) {
      if (!isWin) {
          return parsed;
      }
  
      // Detect & add support for shebangs
      const commandFile = detectShebang(parsed);
  
      // We don't need a shell if the command filename is an executable
      const needsShell = !isExecutableRegExp.test(commandFile);
  
      // If a shell is required, use cmd.exe and take care of escaping everything correctly
      // Note that `forceShell` is an hidden option used only in tests
      if (parsed.options.forceShell || needsShell) {
          // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
          // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
          // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
          // we need to double escape them
          const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
  
          // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
          // This is necessary otherwise it will always fail with ENOENT in those cases
          parsed.command = path.normalize(parsed.command);
  
          // Escape command & arguments
          parsed.command = escape.command(parsed.command);
          parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
  
          const shellCommand = [parsed.command].concat(parsed.args).join(' ');
  
          parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
          parsed.command = process.env.comspec || 'cmd.exe';
          parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
      }
  
      return parsed;
  }
  
  function parseShell(parsed) {
      // If node supports the shell option, there's no need to mimic its behavior
      if (supportsShellOption) {
          return parsed;
      }
  
      // Mimic node shell option
      // See https://github.com/nodejs/node/blob/b9f6a2dc059a1062776133f3d4fd848c4da7d150/lib/child_process.js#L335
      const shellCommand = [parsed.command].concat(parsed.args).join(' ');
  
      if (isWin) {
          parsed.command = typeof parsed.options.shell === 'string' ? parsed.options.shell : process.env.comspec || 'cmd.exe';
          parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
          parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
      } else {
          if (typeof parsed.options.shell === 'string') {
              parsed.command = parsed.options.shell;
          } else if (process.platform === 'android') {
              parsed.command = '/system/bin/sh';
          } else {
              parsed.command = '/bin/sh';
          }
  
          parsed.args = ['-c', shellCommand];
      }
  
      return parsed;
  }
  
  function parse(command, args, options) {
      // Normalize arguments, similar to nodejs
      if (args && !Array.isArray(args)) {
          options = args;
          args = null;
      }
  
      args = args ? args.slice(0) : []; // Clone array to avoid changing the original
      options = Object.assign({}, options); // Clone object to avoid changing the original
  
      // Build our parsed object
      const parsed = {
          command,
          args,
          options,
          file: undefined,
          original: {
              command,
              args,
          },
      };
  
      // Delegate further parsing to shell or non-shell
      return options.shell ? parseShell(parsed) : parseNonShell(parsed);
  }
  
  module.exports = parse;
  
  
  /***/ }),
  /* 569 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Sorts the list according to the supplied function.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord b => (a -> b) -> [a] -> [a]
   * @param {Function} fn
   * @param {Array} list The list to sort.
   * @return {Array} A new list sorted by the keys generated by `fn`.
   * @example
   *
   *      const sortByFirstItem = R.sortBy(R.prop(0));
   *      const pairs = [[-1, 1], [-2, 2], [-3, 3]];
   *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]
   *
   *      const sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));
   *      const alice = {
   *        name: 'ALICE',
   *        age: 101
   *      };
   *      const bob = {
   *        name: 'Bob',
   *        age: -10
   *      };
   *      const clara = {
   *        name: 'clara',
   *        age: 314.159
   *      };
   *      const people = [clara, bob, alice];
   *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]
   */
  
  
  var sortBy =
  /*#__PURE__*/
  _curry2(function sortBy(fn, list) {
    return Array.prototype.slice.call(list, 0).sort(function (a, b) {
      var aa = fn(a);
      var bb = fn(b);
      return aa < bb ? -1 : aa > bb ? 1 : 0;
    });
  });
  
  module.exports = sortBy;
  
  /***/ }),
  /* 570 */,
  /* 571 */
  /***/ (function(module) {
  
  function _isNumber(x) {
    return Object.prototype.toString.call(x) === '[object Number]';
  }
  
  module.exports = _isNumber;
  
  /***/ }),
  /* 572 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _indexOf =
  /*#__PURE__*/
  __webpack_require__(627);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  /**
   * Returns the position of the first occurrence of an item in an array, or -1
   * if the item is not included in the array. [`R.equals`](#equals) is used to
   * determine equality.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig a -> [a] -> Number
   * @param {*} target The item to find.
   * @param {Array} xs The array to search in.
   * @return {Number} the index of the target, or -1 if the target is not found.
   * @see R.lastIndexOf
   * @example
   *
   *      R.indexOf(3, [1,2,3,4]); //=> 2
   *      R.indexOf(10, [1,2,3,4]); //=> -1
   */
  
  
  var indexOf =
  /*#__PURE__*/
  _curry2(function indexOf(target, xs) {
    return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);
  });
  
  module.exports = indexOf;
  
  /***/ }),
  /* 573 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the first argument is greater than the second; `false`
   * otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> Boolean
   * @param {*} a
   * @param {*} b
   * @return {Boolean}
   * @see R.lt
   * @example
   *
   *      R.gt(2, 1); //=> true
   *      R.gt(2, 2); //=> false
   *      R.gt(2, 3); //=> false
   *      R.gt('a', 'z'); //=> false
   *      R.gt('z', 'a'); //=> true
   */
  
  
  var gt =
  /*#__PURE__*/
  _curry2(function gt(a, b) {
    return a > b;
  });
  
  module.exports = gt;
  
  /***/ }),
  /* 574 */,
  /* 575 */,
  /* 576 */,
  /* 577 */,
  /* 578 */,
  /* 579 */,
  /* 580 */,
  /* 581 */,
  /* 582 */,
  /* 583 */,
  /* 584 */,
  /* 585 */,
  /* 586 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Returns a function of arity `n` from a (manually) curried function.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category Function
   * @sig Number -> (a -> b) -> (a -> c)
   * @param {Number} length The arity for the returned function.
   * @param {Function} fn The function to uncurry.
   * @return {Function} A new function.
   * @see R.curry
   * @example
   *
   *      const addFour = a => b => c => d => a + b + c + d;
   *
   *      const uncurriedAddFour = R.uncurryN(4, addFour);
   *      uncurriedAddFour(1, 2, 3, 4); //=> 10
   */
  
  
  var uncurryN =
  /*#__PURE__*/
  _curry2(function uncurryN(depth, fn) {
    return curryN(depth, function () {
      var currentDepth = 1;
      var value = fn;
      var idx = 0;
      var endIdx;
  
      while (currentDepth <= depth && typeof value === 'function') {
        endIdx = currentDepth === depth ? arguments.length : idx + value.length;
        value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx));
        currentDepth += 1;
        idx = endIdx;
      }
  
      return value;
    });
  });
  
  module.exports = uncurryN;
  
  /***/ }),
  /* 587 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = isexe
  isexe.sync = sync
  
  var fs = __webpack_require__(747)
  
  function checkPathExt (path, options) {
    var pathext = options.pathExt !== undefined ?
      options.pathExt : process.env.PATHEXT
  
    if (!pathext) {
      return true
    }
  
    pathext = pathext.split(';')
    if (pathext.indexOf('') !== -1) {
      return true
    }
    for (var i = 0; i < pathext.length; i++) {
      var p = pathext[i].toLowerCase()
      if (p && path.substr(-p.length).toLowerCase() === p) {
        return true
      }
    }
    return false
  }
  
  function checkStat (stat, path, options) {
    if (!stat.isSymbolicLink() && !stat.isFile()) {
      return false
    }
    return checkPathExt(path, options)
  }
  
  function isexe (path, options, cb) {
    fs.stat(path, function (er, stat) {
      cb(er, er ? false : checkStat(stat, path, options))
    })
  }
  
  function sync (path, options) {
    return checkStat(fs.statSync(path), path, options)
  }
  
  
  /***/ }),
  /* 588 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XAll =
  /*#__PURE__*/
  function () {
    function XAll(f, xf) {
      this.xf = xf;
      this.f = f;
      this.all = true;
    }
  
    XAll.prototype['@@transducer/init'] = _xfBase.init;
  
    XAll.prototype['@@transducer/result'] = function (result) {
      if (this.all) {
        result = this.xf['@@transducer/step'](result, true);
      }
  
      return this.xf['@@transducer/result'](result);
    };
  
    XAll.prototype['@@transducer/step'] = function (result, input) {
      if (!this.f(input)) {
        this.all = false;
        result = _reduced(this.xf['@@transducer/step'](result, false));
      }
  
      return result;
    };
  
    return XAll;
  }();
  
  var _xall =
  /*#__PURE__*/
  _curry2(function _xall(f, xf) {
    return new XAll(f, xf);
  });
  
  module.exports = _xall;
  
  /***/ }),
  /* 589 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.findResults = void 0;
  const glob = __importStar(__webpack_require__(281));
  const core_1 = __webpack_require__(470);
  const fs_1 = __webpack_require__(747);
  const path_1 = __webpack_require__(622);
  function getDefaultGlobOptions() {
      return {
          followSymbolicLinks: true,
          implicitDescendants: true,
          omitBrokenSymbolicLinks: true
      };
  }
  function findResults(searchPath, globOptions) {
      return __awaiter(this, void 0, void 0, function* () {
          const searchResults = [];
          const globber = yield glob.create(searchPath, globOptions || getDefaultGlobOptions());
          const rawSearchResults = yield globber.glob();
          /*
              Directories will be rejected if attempted to be uploaded. This includes just empty
              directories so filter any directories out from the raw search results
            */
          for (const searchResult of rawSearchResults) {
              if (!fs_1.lstatSync(searchResult).isDirectory()) {
                  core_1.debug(`File:${searchResult} was found using the provided searchPath`);
                  searchResults.push(searchResult);
              }
              else {
                  core_1.debug(`Removing ${searchResult} from rawSearchResults because it is a directory`);
              }
          }
          /*
              Only a single search pattern is being included so only 1 searchResult is expected. In the future if multiple search patterns are
              simultaneously supported this will change
            */
          const searchPaths = globber.getSearchPaths();
          if (searchPaths.length > 1) {
              throw new Error('Only 1 search path should be returned');
          }
          /*
              Special case for a single file artifact that is uploaded without a directory or wildcard pattern. The directory structure is
              not preserved and the root directory will be the single files parent directory
            */
          if (searchResults.length === 1 && searchPaths[0] === searchResults[0]) {
              return {
                  filesToUpload: searchResults,
                  rootDirectory: path_1.dirname(searchResults[0])
              };
          }
          return {
              filesToUpload: searchResults,
              rootDirectory: searchPaths[0]
          };
      });
  }
  exports.findResults = findResults;
  
  
  /***/ }),
  /* 590 */,
  /* 591 */,
  /* 592 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var pipeP =
  /*#__PURE__*/
  __webpack_require__(984);
  
  var reverse =
  /*#__PURE__*/
  __webpack_require__(528);
  /**
   * Performs right-to-left composition of one or more Promise-returning
   * functions. The last arguments may have any arity; the remaining
   * arguments must be unary.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Function
   * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)
   * @param {...Function} functions The functions to compose
   * @return {Function}
   * @see R.pipeP
   * @deprecated since v0.26.0
   * @example
   *
   *      const db = {
   *        users: {
   *          JOE: {
   *            name: 'Joe',
   *            followers: ['STEVE', 'SUZY']
   *          }
   *        }
   *      }
   *
   *      // We'll pretend to do a db lookup which returns a promise
   *      const lookupUser = (userId) => Promise.resolve(db.users[userId])
   *      const lookupFollowers = (user) => Promise.resolve(user.followers)
   *      lookupUser('JOE').then(lookupFollowers)
   *
   *      //  followersForUser :: String -> Promise [UserId]
   *      const followersForUser = R.composeP(lookupFollowers, lookupUser);
   *      followersForUser('JOE').then(followers => console.log('Followers:', followers))
   *      // Followers: ["STEVE","SUZY"]
   */
  
  
  function composeP() {
    if (arguments.length === 0) {
      throw new Error('composeP requires at least one argument');
    }
  
    return pipeP.apply(this, reverse(arguments));
  }
  
  module.exports = composeP;
  
  /***/ }),
  /* 593 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xfindLastIndex =
  /*#__PURE__*/
  __webpack_require__(982);
  /**
   * Returns the index of the last element of the list which matches the
   * predicate, or `-1` if no element matches.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category List
   * @sig (a -> Boolean) -> [a] -> Number
   * @param {Function} fn The predicate function used to determine if the element is the
   * desired one.
   * @param {Array} list The array to consider.
   * @return {Number} The index of the element found, or `-1`.
   * @see R.transduce
   * @example
   *
   *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];
   *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1
   *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1
   */
  
  
  var findLastIndex =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {
    var idx = list.length - 1;
  
    while (idx >= 0) {
      if (fn(list[idx])) {
        return idx;
      }
  
      idx -= 1;
    }
  
    return -1;
  }));
  
  module.exports = findLastIndex;
  
  /***/ }),
  /* 594 */,
  /* 595 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a copy of the list, sorted according to the comparator function,
   * which should accept two values at a time and return a negative number if the
   * first value is smaller, a positive number if it's larger, and zero if they
   * are equal. Please note that this is a **copy** of the list. It does not
   * modify the original.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig ((a, a) -> Number) -> [a] -> [a]
   * @param {Function} comparator A sorting function :: a -> b -> Int
   * @param {Array} list The list to sort
   * @return {Array} a new array with its elements sorted by the comparator function.
   * @example
   *
   *      const diff = function(a, b) { return a - b; };
   *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]
   */
  
  
  var sort =
  /*#__PURE__*/
  _curry2(function sort(comparator, list) {
    return Array.prototype.slice.call(list, 0).sort(comparator);
  });
  
  module.exports = sort;
  
  /***/ }),
  /* 596 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  /**
   * Returns a lens for the given getter and setter functions. The getter "gets"
   * the value of the focus; the setter "sets" the value of the focus. The setter
   * should not mutate the data structure.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Object
   * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
   * @sig (s -> a) -> ((a, s) -> s) -> Lens s a
   * @param {Function} getter
   * @param {Function} setter
   * @return {Lens}
   * @see R.view, R.set, R.over, R.lensIndex, R.lensProp
   * @example
   *
   *      const xLens = R.lens(R.prop('x'), R.assoc('x'));
   *
   *      R.view(xLens, {x: 1, y: 2});            //=> 1
   *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}
   *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}
   */
  
  
  var lens =
  /*#__PURE__*/
  _curry2(function lens(getter, setter) {
    return function (toFunctorFn) {
      return function (target) {
        return map(function (focus) {
          return setter(focus, target);
        }, toFunctorFn(getter(target)));
      };
    };
  });
  
  module.exports = lens;
  
  /***/ }),
  /* 597 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.partialMatch = exports.match = exports.getSearchPaths = void 0;
  const pathHelper = __importStar(__webpack_require__(972));
  const internal_match_kind_1 = __webpack_require__(327);
  const IS_WINDOWS = process.platform === 'win32';
  /**
   * Given an array of patterns, returns an array of paths to search.
   * Duplicates and paths under other included paths are filtered out.
   */
  function getSearchPaths(patterns) {
      // Ignore negate patterns
      patterns = patterns.filter(x => !x.negate);
      // Create a map of all search paths
      const searchPathMap = {};
      for (const pattern of patterns) {
          const key = IS_WINDOWS
              ? pattern.searchPath.toUpperCase()
              : pattern.searchPath;
          searchPathMap[key] = 'candidate';
      }
      const result = [];
      for (const pattern of patterns) {
          // Check if already included
          const key = IS_WINDOWS
              ? pattern.searchPath.toUpperCase()
              : pattern.searchPath;
          if (searchPathMap[key] === 'included') {
              continue;
          }
          // Check for an ancestor search path
          let foundAncestor = false;
          let tempKey = key;
          let parent = pathHelper.dirname(tempKey);
          while (parent !== tempKey) {
              if (searchPathMap[parent]) {
                  foundAncestor = true;
                  break;
              }
              tempKey = parent;
              parent = pathHelper.dirname(tempKey);
          }
          // Include the search pattern in the result
          if (!foundAncestor) {
              result.push(pattern.searchPath);
              searchPathMap[key] = 'included';
          }
      }
      return result;
  }
  exports.getSearchPaths = getSearchPaths;
  /**
   * Matches the patterns against the path
   */
  function match(patterns, itemPath) {
      let result = internal_match_kind_1.MatchKind.None;
      for (const pattern of patterns) {
          if (pattern.negate) {
              result &= ~pattern.match(itemPath);
          }
          else {
              result |= pattern.match(itemPath);
          }
      }
      return result;
  }
  exports.match = match;
  /**
   * Checks whether to descend further into the directory
   */
  function partialMatch(patterns, itemPath) {
      return patterns.some(x => !x.negate && x.partialMatch(itemPath));
  }
  exports.partialMatch = partialMatch;
  //# sourceMappingURL=internal-pattern-helper.js.map
  
  /***/ }),
  /* 598 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _assertPromise =
  /*#__PURE__*/
  __webpack_require__(385);
  /**
   * Returns the result of applying the onSuccess function to the value inside
   * a successfully resolved promise. This is useful for working with promises
   * inside function compositions.
   *
   * @func
   * @memberOf R
   * @since v0.27.1
   * @category Function
   * @sig (a -> b) -> (Promise e a) -> (Promise e b)
   * @sig (a -> (Promise e b)) -> (Promise e a) -> (Promise e b)
   * @param {Function} onSuccess The function to apply. Can return a value or a promise of a value.
   * @param {Promise} p
   * @return {Promise} The result of calling `p.then(onSuccess)`
   * @see R.otherwise
   * @example
   *
   *      var makeQuery = (email) => ({ query: { email }});
   *
   *      //getMemberName :: String -> Promise ({firstName, lastName})
   *      var getMemberName = R.pipe(
   *        makeQuery,
   *        fetchMember,
   *        R.andThen(R.pick(['firstName', 'lastName']))
   *      );
   */
  
  
  var andThen =
  /*#__PURE__*/
  _curry2(function andThen(f, p) {
    _assertPromise('andThen', p);
  
    return p.then(f);
  });
  
  module.exports = andThen;
  
  /***/ }),
  /* 599 */,
  /* 600 */,
  /* 601 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.getOptions = void 0;
  const core = __importStar(__webpack_require__(470));
  /**
   * Returns a copy with defaults filled in.
   */
  function getOptions(copy) {
      const result = {
          followSymbolicLinks: true,
          implicitDescendants: true,
          omitBrokenSymbolicLinks: true
      };
      if (copy) {
          if (typeof copy.followSymbolicLinks === 'boolean') {
              result.followSymbolicLinks = copy.followSymbolicLinks;
              core.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`);
          }
          if (typeof copy.implicitDescendants === 'boolean') {
              result.implicitDescendants = copy.implicitDescendants;
              core.debug(`implicitDescendants '${result.implicitDescendants}'`);
          }
          if (typeof copy.omitBrokenSymbolicLinks === 'boolean') {
              result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks;
              core.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`);
          }
      }
      return result;
  }
  exports.getOptions = getOptions;
  //# sourceMappingURL=internal-glob-options-helper.js.map
  
  /***/ }),
  /* 602 */,
  /* 603 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var take =
  /*#__PURE__*/
  __webpack_require__(498);
  
  function dropLast(n, xs) {
    return take(n < xs.length ? xs.length - n : 0, xs);
  }
  
  module.exports = dropLast;
  
  /***/ }),
  /* 604 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var max =
  /*#__PURE__*/
  __webpack_require__(793);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.
   * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments
   * to `fn` are applied to each of the predicates in turn until one returns a
   * "truthy" value, at which point `fn` returns the result of applying its
   * arguments to the corresponding transformer. If none of the predicates
   * matches, `fn` returns undefined.
   *
   * @func
   * @memberOf R
   * @since v0.6.0
   * @category Logic
   * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)
   * @param {Array} pairs A list of [predicate, transformer]
   * @return {Function}
   * @see R.ifElse, R.unless, R.when
   * @example
   *
   *      const fn = R.cond([
   *        [R.equals(0),   R.always('water freezes at 0°C')],
   *        [R.equals(100), R.always('water boils at 100°C')],
   *        [R.T,           temp => 'nothing special happens at ' + temp + '°C']
   *      ]);
   *      fn(0); //=> 'water freezes at 0°C'
   *      fn(50); //=> 'nothing special happens at 50°C'
   *      fn(100); //=> 'water boils at 100°C'
   */
  
  
  var cond =
  /*#__PURE__*/
  _curry1(function cond(pairs) {
    var arity = reduce(max, 0, map(function (pair) {
      return pair[0].length;
    }, pairs));
    return _arity(arity, function () {
      var idx = 0;
  
      while (idx < pairs.length) {
        if (pairs[idx][0].apply(this, arguments)) {
          return pairs[idx][1].apply(this, arguments);
        }
  
        idx += 1;
      }
    });
  });
  
  module.exports = cond;
  
  /***/ }),
  /* 605 */
  /***/ (function(module) {
  
  module.exports = require("http");
  
  /***/ }),
  /* 606 */,
  /* 607 */,
  /* 608 */,
  /* 609 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a new list out of the two supplied by creating each possible pair
   * from the lists.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [b] -> [[a,b]]
   * @param {Array} as The first list.
   * @param {Array} bs The second list.
   * @return {Array} The list made by combining each possible pair from
   *         `as` and `bs` into pairs (`[a, b]`).
   * @example
   *
   *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
   * @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]]
   */
  
  
  var xprod =
  /*#__PURE__*/
  _curry2(function xprod(a, b) {
    // = xprodWith(prepend); (takes about 3 times as long...)
    var idx = 0;
    var ilen = a.length;
    var j;
    var jlen = b.length;
    var result = [];
  
    while (idx < ilen) {
      j = 0;
  
      while (j < jlen) {
        result[result.length] = [a[idx], b[j]];
        j += 1;
      }
  
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = xprod;
  
  /***/ }),
  /* 610 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Move an item, at index `from`, to index `to`, in a list of elements.
   * A new list will be created containing the new elements order.
   *
   * @func
   * @memberOf R
   * @since v0.27.1
   * @category List
   * @sig Number -> Number -> [a] -> [a]
   * @param {Number} from The source index
   * @param {Number} to The destination index
   * @param {Array} list The list which will serve to realise the move
   * @return {Array} The new list reordered
   * @example
   *
   *      R.move(0, 2, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['b', 'c', 'a', 'd', 'e', 'f']
   *      R.move(-1, 0, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['f', 'a', 'b', 'c', 'd', 'e'] list rotation
   */
  
  
  var move =
  /*#__PURE__*/
  _curry3(function (from, to, list) {
    var length = list.length;
    var result = list.slice();
    var positiveFrom = from < 0 ? length + from : from;
    var positiveTo = to < 0 ? length + to : to;
    var item = result.splice(positiveFrom, 1);
    return positiveFrom < 0 || positiveFrom >= list.length || positiveTo < 0 || positiveTo >= list.length ? list : [].concat(result.slice(0, positiveTo)).concat(item).concat(result.slice(positiveTo, list.length));
  });
  
  module.exports = move;
  
  /***/ }),
  /* 611 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * The `mapAccum` function behaves like a combination of map and reduce; it
   * applies a function to each element of a list, passing an accumulating
   * parameter from left to right, and returning a final value of this
   * accumulator together with the new list.
   *
   * The iterator function receives two arguments, *acc* and *value*, and should
   * return a tuple *[acc, value]*.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category List
   * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])
   * @param {Function} fn The function to be called on every element of the input `list`.
   * @param {*} acc The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.scan, R.addIndex, R.mapAccumRight
   * @example
   *
   *      const digits = ['1', '2', '3', '4'];
   *      const appender = (a, b) => [a + b, a + b];
   *
   *      R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]
   * @symb R.mapAccum(f, a, [b, c, d]) = [
   *   f(f(f(a, b)[0], c)[0], d)[0],
   *   [
   *     f(a, b)[1],
   *     f(f(a, b)[0], c)[1],
   *     f(f(f(a, b)[0], c)[0], d)[1]
   *   ]
   * ]
   */
  
  
  var mapAccum =
  /*#__PURE__*/
  _curry3(function mapAccum(fn, acc, list) {
    var idx = 0;
    var len = list.length;
    var result = [];
    var tuple = [acc];
  
    while (idx < len) {
      tuple = fn(tuple[0], list[idx]);
      result[idx] = tuple[1];
      idx += 1;
    }
  
    return [tuple[0], result];
  });
  
  module.exports = mapAccum;
  
  /***/ }),
  /* 612 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a new list containing the contents of the given list, followed by
   * the given element.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig a -> [a] -> [a]
   * @param {*} el The element to add to the end of the new list.
   * @param {Array} list The list of elements to add a new item to.
   *        list.
   * @return {Array} A new list containing the elements of the old list followed by `el`.
   * @see R.prepend
   * @example
   *
   *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
   *      R.append('tests', []); //=> ['tests']
   *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
   */
  
  
  var append =
  /*#__PURE__*/
  _curry2(function append(el, list) {
    return _concat(list, [el]);
  });
  
  module.exports = append;
  
  /***/ }),
  /* 613 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var add =
  /*#__PURE__*/
  __webpack_require__(792);
  /**
   * Decrements its argument.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Math
   * @sig Number -> Number
   * @param {Number} n
   * @return {Number} n - 1
   * @see R.inc
   * @example
   *
   *      R.dec(42); //=> 41
   */
  
  
  var dec =
  /*#__PURE__*/
  add(-1);
  module.exports = dec;
  
  /***/ }),
  /* 614 */
  /***/ (function(module) {
  
  module.exports = require("events");
  
  /***/ }),
  /* 615 */,
  /* 616 */,
  /* 617 */,
  /* 618 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Makes a descending comparator function out of a function that returns a value
   * that can be compared with `<` and `>`.
   *
   * @func
   * @memberOf R
   * @since v0.23.0
   * @category Function
   * @sig Ord b => (a -> b) -> a -> a -> Number
   * @param {Function} fn A function of arity one that returns a value that can be compared
   * @param {*} a The first item to be compared.
   * @param {*} b The second item to be compared.
   * @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0`
   * @see R.ascend
   * @example
   *
   *      const byAge = R.descend(R.prop('age'));
   *      const people = [
   *        { name: 'Emma', age: 70 },
   *        { name: 'Peter', age: 78 },
   *        { name: 'Mikhail', age: 62 },
   *      ];
   *      const peopleByOldestFirst = R.sort(byAge, people);
   *        //=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }]
   */
  
  
  var descend =
  /*#__PURE__*/
  _curry3(function descend(fn, a, b) {
    var aa = fn(a);
    var bb = fn(b);
    return aa > bb ? -1 : aa < bb ? 1 : 0;
  });
  
  module.exports = descend;
  
  /***/ }),
  /* 619 */,
  /* 620 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Returns a list containing the names of all the properties of the supplied
   * object, including prototype properties.
   * Note that the order of the output array is not guaranteed to be consistent
   * across different JS platforms.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category Object
   * @sig {k: v} -> [k]
   * @param {Object} obj The object to extract properties from
   * @return {Array} An array of the object's own and prototype properties.
   * @see R.keys, R.valuesIn
   * @example
   *
   *      const F = function() { this.x = 'X'; };
   *      F.prototype.y = 'Y';
   *      const f = new F();
   *      R.keysIn(f); //=> ['x', 'y']
   */
  
  
  var keysIn =
  /*#__PURE__*/
  _curry1(function keysIn(obj) {
    var prop;
    var ks = [];
  
    for (prop in obj) {
      ks[ks.length] = prop;
    }
  
    return ks;
  });
  
  module.exports = keysIn;
  
  /***/ }),
  /* 621 */
  /***/ (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;
  }
  
  
  /***/ }),
  /* 622 */
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  /* 623 */,
  /* 624 */,
  /* 625 */,
  /* 626 */
  /***/ (function(module) {
  
  function _map(fn, functor) {
    var idx = 0;
    var len = functor.length;
    var result = Array(len);
  
    while (idx < len) {
      result[idx] = fn(functor[idx]);
      idx += 1;
    }
  
    return result;
  }
  
  module.exports = _map;
  
  /***/ }),
  /* 627 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  
  function _indexOf(list, a, idx) {
    var inf, item; // Array.prototype.indexOf doesn't exist below IE9
  
    if (typeof list.indexOf === 'function') {
      switch (typeof a) {
        case 'number':
          if (a === 0) {
            // manually crawl the list to distinguish between +0 and -0
            inf = 1 / a;
  
            while (idx < list.length) {
              item = list[idx];
  
              if (item === 0 && 1 / item === inf) {
                return idx;
              }
  
              idx += 1;
            }
  
            return -1;
          } else if (a !== a) {
            // NaN
            while (idx < list.length) {
              item = list[idx];
  
              if (typeof item === 'number' && item !== item) {
                return idx;
              }
  
              idx += 1;
            }
  
            return -1;
          } // non-zero numbers can utilise Set
  
  
          return list.indexOf(a, idx);
        // all these types can utilise Set
  
        case 'string':
        case 'boolean':
        case 'function':
        case 'undefined':
          return list.indexOf(a, idx);
  
        case 'object':
          if (a === null) {
            // null can utilise Set
            return list.indexOf(a, idx);
          }
  
      }
    } // anything else not covered above, defer to R.equals
  
  
    while (idx < list.length) {
      if (equals(list[idx], a)) {
        return idx;
      }
  
      idx += 1;
    }
  
    return -1;
  }
  
  module.exports = _indexOf;
  
  /***/ }),
  /* 628 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var invoker =
  /*#__PURE__*/
  __webpack_require__(691);
  /**
   * Splits a string into an array of strings based on the given
   * separator.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category String
   * @sig (String | RegExp) -> String -> [String]
   * @param {String|RegExp} sep The pattern.
   * @param {String} str The string to separate into an array.
   * @return {Array} The array of strings from `str` separated by `sep`.
   * @see R.join
   * @example
   *
   *      const pathComponents = R.split('/');
   *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']
   *
   *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']
   */
  
  
  var split =
  /*#__PURE__*/
  invoker(1, 'split');
  module.exports = split;
  
  /***/ }),
  /* 629 */,
  /* 630 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a new list out of the two supplied by pairing up equally-positioned
   * items from both lists. The returned list is truncated to the length of the
   * shorter of the two input lists.
   * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [b] -> [[a,b]]
   * @param {Array} list1 The first array to consider.
   * @param {Array} list2 The second array to consider.
   * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.
   * @example
   *
   *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
   * @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]]
   */
  
  
  var zip =
  /*#__PURE__*/
  _curry2(function zip(a, b) {
    var rv = [];
    var idx = 0;
    var len = Math.min(a.length, b.length);
  
    while (idx < len) {
      rv[idx] = [a[idx], b[idx]];
      idx += 1;
    }
  
    return rv;
  });
  
  module.exports = zip;
  
  /***/ }),
  /* 631 */
  /***/ (function(module) {
  
  function _identity(x) {
    return x;
  }
  
  module.exports = _identity;
  
  /***/ }),
  /* 632 */,
  /* 633 */,
  /* 634 */,
  /* 635 */,
  /* 636 */,
  /* 637 */,
  /* 638 */,
  /* 639 */
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = function (x) {
  	var lf = typeof x === 'string' ? '\n' : '\n'.charCodeAt();
  	var cr = typeof x === 'string' ? '\r' : '\r'.charCodeAt();
  
  	if (x[x.length - 1] === lf) {
  		x = x.slice(0, x.length - 1);
  	}
  
  	if (x[x.length - 1] === cr) {
  		x = x.slice(0, x.length - 1);
  	}
  
  	return x;
  };
  
  
  /***/ }),
  /* 640 */,
  /* 641 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  /**
   * ap applies a list of functions to a list of values.
   *
   * Dispatches to the `ap` method of the second argument, if present. Also
   * treats curried functions as applicatives.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category Function
   * @sig [a -> b] -> [a] -> [b]
   * @sig Apply f => f (a -> b) -> f a -> f b
   * @sig (r -> a -> b) -> (r -> a) -> (r -> b)
   * @param {*} applyF
   * @param {*} applyX
   * @return {*}
   * @example
   *
   *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
   *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]
   *
   *      // R.ap can also be used as S combinator
   *      // when only two functions are passed
   *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'
   * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]
   */
  
  
  var ap =
  /*#__PURE__*/
  _curry2(function ap(applyF, applyX) {
    return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {
      return applyF(x)(applyX(x));
    } : _reduce(function (acc, f) {
      return _concat(acc, map(f, applyX));
    }, [], applyF);
  });
  
  module.exports = ap;
  
  /***/ }),
  /* 642 */,
  /* 643 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var slice =
  /*#__PURE__*/
  __webpack_require__(232);
  
  function dropLastWhile(pred, xs) {
    var idx = xs.length - 1;
  
    while (idx >= 0 && pred(xs[idx])) {
      idx -= 1;
    }
  
    return slice(0, idx + 1, xs);
  }
  
  module.exports = dropLastWhile;
  
  /***/ }),
  /* 644 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var invoker =
  /*#__PURE__*/
  __webpack_require__(691);
  /**
   * Returns a string made by inserting the `separator` between each element and
   * concatenating all the elements into a single string.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig String -> [a] -> String
   * @param {Number|String} separator The string used to separate the elements.
   * @param {Array} xs The elements to join into a string.
   * @return {String} str The string made by concatenating `xs` with `separator`.
   * @see R.split
   * @example
   *
   *      const spacer = R.join(' ');
   *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'
   *      R.join('|', [1, 2, 3]);    //=> '1|2|3'
   */
  
  
  var join =
  /*#__PURE__*/
  invoker(1, 'join');
  module.exports = join;
  
  /***/ }),
  /* 645 */,
  /* 646 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Severity = void 0;
  var Severity;
  (function (Severity) {
      Severity["error"] = "error";
      Severity["warning"] = "warning";
      Severity["info"] = "info";
      Severity["ignore"] = "ignore";
  })(Severity = exports.Severity || (exports.Severity = {}));
  
  
  /***/ }),
  /* 647 */,
  /* 648 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a partial copy of an object containing only the keys that satisfy
   * the supplied predicate.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Object
   * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}
   * @param {Function} pred A predicate to determine whether or not a key
   *        should be included on the output object.
   * @param {Object} obj The object to copy from
   * @return {Object} A new object with only properties that satisfy `pred`
   *         on it.
   * @see R.pick, R.filter
   * @example
   *
   *      const isUpperCase = (val, key) => key.toUpperCase() === key;
   *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
   */
  
  
  var pickBy =
  /*#__PURE__*/
  _curry2(function pickBy(test, obj) {
    var result = {};
  
    for (var prop in obj) {
      if (test(obj[prop], prop, obj)) {
        result[prop] = obj[prop];
      }
    }
  
    return result;
  });
  
  module.exports = pickBy;
  
  /***/ }),
  /* 649 */,
  /* 650 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectAssign =
  /*#__PURE__*/
  __webpack_require__(289);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Create a new object with the own properties of the first object merged with
   * the own properties of the second object. If a key exists in both objects,
   * the value from the second object will be used.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Object
   * @sig {k: v} -> {k: v} -> {k: v}
   * @param {Object} l
   * @param {Object} r
   * @return {Object}
   * @see R.mergeRight, R.mergeDeepRight, R.mergeWith, R.mergeWithKey
   * @deprecated since v0.26.0
   * @example
   *
   *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
   *      //=> { 'name': 'fred', 'age': 40 }
   *
   *      const withDefaults = R.merge({x: 0, y: 0});
   *      withDefaults({y: 2}); //=> {x: 0, y: 2}
   * @symb R.merge(a, b) = {...a, ...b}
   */
  
  
  var merge =
  /*#__PURE__*/
  _curry2(function merge(l, r) {
    return _objectAssign({}, l, r);
  });
  
  module.exports = merge;
  
  /***/ }),
  /* 651 */,
  /* 652 */,
  /* 653 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isString =
  /*#__PURE__*/
  __webpack_require__(285);
  /**
   * Returns the nth element of the given list or string. If n is negative the
   * element at index length + n is returned.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Number -> [a] -> a | Undefined
   * @sig Number -> String -> String
   * @param {Number} offset
   * @param {*} list
   * @return {*}
   * @example
   *
   *      const list = ['foo', 'bar', 'baz', 'quux'];
   *      R.nth(1, list); //=> 'bar'
   *      R.nth(-1, list); //=> 'quux'
   *      R.nth(-99, list); //=> undefined
   *
   *      R.nth(2, 'abc'); //=> 'c'
   *      R.nth(3, 'abc'); //=> ''
   * @symb R.nth(-1, [a, b, c]) = c
   * @symb R.nth(0, [a, b, c]) = a
   * @symb R.nth(1, [a, b, c]) = b
   */
  
  
  var nth =
  /*#__PURE__*/
  _curry2(function nth(offset, list) {
    var idx = offset < 0 ? list.length + offset : offset;
    return _isString(list) ? list.charAt(idx) : list[idx];
  });
  
  module.exports = nth;
  
  /***/ }),
  /* 654 */
  /***/ (function(module) {
  
  // This is not the set of all possible signals.
  //
  // It IS, however, the set of all signals that trigger
  // an exit on either Linux or BSD systems.  Linux is a
  // superset of the signal names supported on BSD, and
  // the unknown signals just fail to register, so we can
  // catch that easily enough.
  //
  // Don't bother with SIGKILL.  It's uncatchable, which
  // means that we can't fire any callbacks anyway.
  //
  // If a user does happen to register a handler on a non-
  // fatal signal like SIGWINCH or something, and then
  // exit, it'll end up firing `process.emit('exit')`, so
  // the handler will be fired anyway.
  //
  // SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
  // artificially, inherently leave the process in a
  // state from which it is not safe to try and enter JS
  // listeners.
  module.exports = [
    'SIGABRT',
    'SIGALRM',
    'SIGHUP',
    'SIGINT',
    'SIGTERM'
  ]
  
  if (process.platform !== 'win32') {
    module.exports.push(
      'SIGVTALRM',
      'SIGXCPU',
      'SIGXFSZ',
      'SIGUSR2',
      'SIGTRAP',
      'SIGSYS',
      'SIGQUIT',
      'SIGIOT'
      // should detect profiler and enable/disable accordingly.
      // see #21
      // 'SIGPROF'
    )
  }
  
  if (process.platform === 'linux') {
    module.exports.push(
      'SIGIO',
      'SIGPOLL',
      'SIGPWR',
      'SIGSTKFLT',
      'SIGUNUSED'
    )
  }
  
  
  /***/ }),
  /* 655 */,
  /* 656 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xfindLast =
  /*#__PURE__*/
  __webpack_require__(544);
  /**
   * Returns the last element of the list which matches the predicate, or
   * `undefined` if no element matches.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category List
   * @sig (a -> Boolean) -> [a] -> a | undefined
   * @param {Function} fn The predicate function used to determine if the element is the
   * desired one.
   * @param {Array} list The array to consider.
   * @return {Object} The element found, or `undefined`.
   * @see R.transduce
   * @example
   *
   *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];
   *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}
   *      R.findLast(R.propEq('a', 4))(xs); //=> undefined
   */
  
  
  var findLast =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xfindLast, function findLast(fn, list) {
    var idx = list.length - 1;
  
    while (idx >= 0) {
      if (fn(list[idx])) {
        return list[idx];
      }
  
      idx -= 1;
    }
  }));
  
  module.exports = findLast;
  
  /***/ }),
  /* 657 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Returns a function that always returns the given value. Note that for
   * non-primitives the value returned is a reference to the original value.
   *
   * This function is known as `const`, `constant`, or `K` (for K combinator) in
   * other languages and libraries.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig a -> (* -> a)
   * @param {*} val The value to wrap in a function
   * @return {Function} A Function :: * -> val.
   * @example
   *
   *      const t = R.always('Tee');
   *      t(); //=> 'Tee'
   */
  
  
  var always =
  /*#__PURE__*/
  _curry1(function always(val) {
    return function () {
      return val;
    };
  });
  
  module.exports = always;
  
  /***/ }),
  /* 658 */,
  /* 659 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Tests the final argument by passing it to the given predicate function. If
   * the predicate is satisfied, the function will return the result of calling
   * the `whenTrueFn` function with the same argument. If the predicate is not
   * satisfied, the argument is returned as is.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category Logic
   * @sig (a -> Boolean) -> (a -> a) -> a -> a
   * @param {Function} pred       A predicate function
   * @param {Function} whenTrueFn A function to invoke when the `condition`
   *                              evaluates to a truthy value.
   * @param {*}        x          An object to test with the `pred` function and
   *                              pass to `whenTrueFn` if necessary.
   * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.
   * @see R.ifElse, R.unless, R.cond
   * @example
   *
   *      // truncate :: String -> String
   *      const truncate = R.when(
   *        R.propSatisfies(R.gt(R.__, 10), 'length'),
   *        R.pipe(R.take(10), R.append('…'), R.join(''))
   *      );
   *      truncate('12345');         //=> '12345'
   *      truncate('0123456789ABC'); //=> '0123456789…'
   */
  
  
  var when =
  /*#__PURE__*/
  _curry3(function when(pred, whenTrueFn, x) {
    return pred(x) ? whenTrueFn(x) : x;
  });
  
  module.exports = when;
  
  /***/ }),
  /* 660 */,
  /* 661 */,
  /* 662 */
  /***/ (function(module) {
  
  function _isObject(x) {
    return Object.prototype.toString.call(x) === '[object Object]';
  }
  
  module.exports = _isObject;
  
  /***/ }),
  /* 663 */,
  /* 664 */,
  /* 665 */,
  /* 666 */,
  /* 667 */,
  /* 668 */,
  /* 669 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Takes a function and two values, and returns whichever value produces the
   * smaller result when passed to the provided function.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Relation
   * @sig Ord b => (a -> b) -> a -> a -> a
   * @param {Function} f
   * @param {*} a
   * @param {*} b
   * @return {*}
   * @see R.min, R.maxBy
   * @example
   *
   *      //  square :: Number -> Number
   *      const square = n => n * n;
   *
   *      R.minBy(square, -3, 2); //=> 2
   *
   *      R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1
   *      R.reduce(R.minBy(square), Infinity, []); //=> Infinity
   */
  
  
  var minBy =
  /*#__PURE__*/
  _curry3(function minBy(f, a, b) {
    return f(b) < f(a) ? b : a;
  });
  
  module.exports = minBy;
  
  /***/ }),
  /* 670 */,
  /* 671 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * `o` is a curried composition function that returns a unary function.
   * Like [`compose`](#compose), `o` performs right-to-left function composition.
   * Unlike [`compose`](#compose), the rightmost function passed to `o` will be
   * invoked with only one argument. Also, unlike [`compose`](#compose), `o` is
   * limited to accepting only 2 unary functions. The name o was chosen because
   * of its similarity to the mathematical composition operator ∘.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Function
   * @sig (b -> c) -> (a -> b) -> a -> c
   * @param {Function} f
   * @param {Function} g
   * @return {Function}
   * @see R.compose, R.pipe
   * @example
   *
   *      const classyGreeting = name => "The name's " + name.last + ", " + name.first + " " + name.last
   *      const yellGreeting = R.o(R.toUpper, classyGreeting);
   *      yellGreeting({first: 'James', last: 'Bond'}); //=> "THE NAME'S BOND, JAMES BOND"
   *
   *      R.o(R.multiply(10), R.add(10))(-4) //=> 60
   *
   * @symb R.o(f, g, x) = f(g(x))
   */
  
  
  var o =
  /*#__PURE__*/
  _curry3(function o(f, g, x) {
    return f(g(x));
  });
  
  module.exports = o;
  
  /***/ }),
  /* 672 */,
  /* 673 */,
  /* 674 */,
  /* 675 */
  /***/ (function(module) {
  
  function _aperture(n, list) {
    var idx = 0;
    var limit = list.length - (n - 1);
    var acc = new Array(limit >= 0 ? limit : 0);
  
    while (idx < limit) {
      acc[idx] = Array.prototype.slice.call(list, idx, idx + n);
      idx += 1;
    }
  
    return acc;
  }
  
  module.exports = _aperture;
  
  /***/ }),
  /* 676 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if both arguments are `true`; `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Logic
   * @sig a -> b -> a | b
   * @param {Any} a
   * @param {Any} b
   * @return {Any} the first argument if it is falsy, otherwise the second argument.
   * @see R.both, R.xor
   * @example
   *
   *      R.and(true, true); //=> true
   *      R.and(true, false); //=> false
   *      R.and(false, true); //=> false
   *      R.and(false, false); //=> false
   */
  
  
  var and =
  /*#__PURE__*/
  _curry2(function and(a, b) {
    return a && b;
  });
  
  module.exports = and;
  
  /***/ }),
  /* 677 */,
  /* 678 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var nth =
  /*#__PURE__*/
  __webpack_require__(653);
  /**
   * Returns the first element of the given list or string. In some libraries
   * this function is named `first`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> a | Undefined
   * @sig String -> String
   * @param {Array|String} list
   * @return {*}
   * @see R.tail, R.init, R.last
   * @example
   *
   *      R.head(['fi', 'fo', 'fum']); //=> 'fi'
   *      R.head([]); //=> undefined
   *
   *      R.head('abc'); //=> 'a'
   *      R.head(''); //=> ''
   */
  
  
  var head =
  /*#__PURE__*/
  nth(0);
  module.exports = head;
  
  /***/ }),
  /* 679 */,
  /* 680 */
  /***/ (function(module) {
  
  function _includesWith(pred, x, list) {
    var idx = 0;
    var len = list.length;
  
    while (idx < len) {
      if (pred(x, list[idx])) {
        return true;
      }
  
      idx += 1;
    }
  
    return false;
  }
  
  module.exports = _includesWith;
  
  /***/ }),
  /* 681 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  /**
   * Creates a new object with the own properties of the two provided objects. If
   * a key exists in both objects, the provided function is applied to the key
   * and the values associated with the key in each object, with the result being
   * used as the value associated with the key in the returned object.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Object
   * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}
   * @param {Function} fn
   * @param {Object} l
   * @param {Object} r
   * @return {Object}
   * @see R.mergeDeepWithKey, R.merge, R.mergeWith
   * @example
   *
   *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r
   *      R.mergeWithKey(concatValues,
   *                     { a: true, thing: 'foo', values: [10, 20] },
   *                     { b: true, thing: 'bar', values: [15, 35] });
   *      //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }
   * @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 }
   */
  
  
  var mergeWithKey =
  /*#__PURE__*/
  _curry3(function mergeWithKey(fn, l, r) {
    var result = {};
    var k;
  
    for (k in l) {
      if (_has(k, l)) {
        result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
      }
    }
  
    for (k in r) {
      if (_has(k, r) && !_has(k, result)) {
        result[k] = r[k];
      }
    }
  
    return result;
  });
  
  module.exports = mergeWithKey;
  
  /***/ }),
  /* 682 */,
  /* 683 */,
  /* 684 */,
  /* 685 */,
  /* 686 */,
  /* 687 */,
  /* 688 */,
  /* 689 */,
  /* 690 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectAssign =
  /*#__PURE__*/
  __webpack_require__(289);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Create a new object with the own properties of the first object merged with
   * the own properties of the second object. If a key exists in both objects,
   * the value from the second object will be used.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Object
   * @sig {k: v} -> {k: v} -> {k: v}
   * @param {Object} l
   * @param {Object} r
   * @return {Object}
   * @see R.mergeLeft, R.mergeDeepRight, R.mergeWith, R.mergeWithKey
   * @example
   *
   *      R.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
   *      //=> { 'name': 'fred', 'age': 40 }
   *
   *      const withDefaults = R.mergeRight({x: 0, y: 0});
   *      withDefaults({y: 2}); //=> {x: 0, y: 2}
   * @symb R.mergeRight(a, b) = {...a, ...b}
   */
  
  
  var mergeRight =
  /*#__PURE__*/
  _curry2(function mergeRight(l, r) {
    return _objectAssign({}, l, r);
  });
  
  module.exports = mergeRight;
  
  /***/ }),
  /* 691 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isFunction =
  /*#__PURE__*/
  __webpack_require__(504);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var toString =
  /*#__PURE__*/
  __webpack_require__(854);
  /**
   * Turns a named method with a specified arity into a function that can be
   * called directly supplied with arguments and a target object.
   *
   * The returned function is curried and accepts `arity + 1` parameters where
   * the final parameter is the target object.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)
   * @param {Number} arity Number of arguments the returned function should take
   *        before the target object.
   * @param {String} method Name of any of the target object's methods to call.
   * @return {Function} A new curried function.
   * @see R.construct
   * @example
   *
   *      const sliceFrom = R.invoker(1, 'slice');
   *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'
   *      const sliceFrom6 = R.invoker(2, 'slice')(6);
   *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'
   *
   *      const dog = {
   *        speak: async () => 'Woof!'
   *      };
   *      const speak = R.invoker(0, 'speak');
   *      speak(dog).then(console.log) //~> 'Woof!'
   *
   * @symb R.invoker(0, 'method')(o) = o['method']()
   * @symb R.invoker(1, 'method')(a, o) = o['method'](a)
   * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)
   */
  
  
  var invoker =
  /*#__PURE__*/
  _curry2(function invoker(arity, method) {
    return curryN(arity + 1, function () {
      var target = arguments[arity];
  
      if (target != null && _isFunction(target[method])) {
        return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));
      }
  
      throw new TypeError(toString(target) + ' does not have a method named "' + method + '"');
    });
  });
  
  module.exports = invoker;
  
  /***/ }),
  /* 692 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  class Deprecation extends Error {
    constructor(message) {
      super(message); // Maintains proper stack trace (only available on V8)
  
      /* istanbul ignore next */
  
      if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
      }
  
      this.name = 'Deprecation';
    }
  
  }
  
  exports.Deprecation = Deprecation;
  
  
  /***/ }),
  /* 693 */,
  /* 694 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XTake =
  /*#__PURE__*/
  function () {
    function XTake(n, xf) {
      this.xf = xf;
      this.n = n;
      this.i = 0;
    }
  
    XTake.prototype['@@transducer/init'] = _xfBase.init;
    XTake.prototype['@@transducer/result'] = _xfBase.result;
  
    XTake.prototype['@@transducer/step'] = function (result, input) {
      this.i += 1;
      var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input);
      return this.n >= 0 && this.i >= this.n ? _reduced(ret) : ret;
    };
  
    return XTake;
  }();
  
  var _xtake =
  /*#__PURE__*/
  _curry2(function _xtake(n, xf) {
    return new XTake(n, xf);
  });
  
  module.exports = _xtake;
  
  /***/ }),
  /* 695 */
  /***/ (function(module) {
  
  function _filter(fn, list) {
    var idx = 0;
    var len = list.length;
    var result = [];
  
    while (idx < len) {
      if (fn(list[idx])) {
        result[result.length] = list[idx];
      }
  
      idx += 1;
    }
  
    return result;
  }
  
  module.exports = _filter;
  
  /***/ }),
  /* 696 */,
  /* 697 */
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = (promise, onFinally) => {
  	onFinally = onFinally || (() => {});
  
  	return promise.then(
  		val => new Promise(resolve => {
  			resolve(onFinally());
  		}).then(() => val),
  		err => new Promise(resolve => {
  			resolve(onFinally());
  		}).then(() => {
  			throw err;
  		})
  	);
  };
  
  
  /***/ }),
  /* 698 */,
  /* 699 */,
  /* 700 */
  /***/ (function(module) {
  
  function _isTransformer(obj) {
    return obj != null && typeof obj['@@transducer/step'] === 'function';
  }
  
  module.exports = _isTransformer;
  
  /***/ }),
  /* 701 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _equals =
  /*#__PURE__*/
  __webpack_require__(325);
  /**
   * Returns `true` if its arguments are equivalent, `false` otherwise. Handles
   * cyclical data structures.
   *
   * Dispatches symmetrically to the `equals` methods of both arguments, if
   * present.
   *
   * @func
   * @memberOf R
   * @since v0.15.0
   * @category Relation
   * @sig a -> b -> Boolean
   * @param {*} a
   * @param {*} b
   * @return {Boolean}
   * @example
   *
   *      R.equals(1, 1); //=> true
   *      R.equals(1, '1'); //=> false
   *      R.equals([1, 2, 3], [1, 2, 3]); //=> true
   *
   *      const a = {}; a.v = a;
   *      const b = {}; b.v = b;
   *      R.equals(a, b); //=> true
   */
  
  
  var equals =
  /*#__PURE__*/
  _curry2(function equals(a, b) {
    return _equals(a, b, [], []);
  });
  
  module.exports = equals;
  
  /***/ }),
  /* 702 */,
  /* 703 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _Set =
  /*#__PURE__*/
  __webpack_require__(161);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a new list containing only one copy of each element in the original
   * list, based upon the value returned by applying the supplied function to
   * each list element. Prefers the first item if the supplied function produces
   * the same value on two items. [`R.equals`](#equals) is used for comparison.
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category List
   * @sig (a -> b) -> [a] -> [a]
   * @param {Function} fn A function used to produce a value to use during comparisons.
   * @param {Array} list The array to consider.
   * @return {Array} The list of unique items.
   * @example
   *
   *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]
   */
  
  
  var uniqBy =
  /*#__PURE__*/
  _curry2(function uniqBy(fn, list) {
    var set = new _Set();
    var result = [];
    var idx = 0;
    var appliedItem, item;
  
    while (idx < list.length) {
      item = list[idx];
      appliedItem = fn(item);
  
      if (set.add(appliedItem)) {
        result.push(item);
      }
  
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = uniqBy;
  
  /***/ }),
  /* 704 */,
  /* 705 */,
  /* 706 */,
  /* 707 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  var isObject = __webpack_require__(20);
  
  module.exports = function extend(o/*, objects*/) {
    if (!isObject(o)) { o = {}; }
  
    var len = arguments.length;
    for (var i = 1; i < len; i++) {
      var obj = arguments[i];
  
      if (isObject(obj)) {
        assign(o, obj);
      }
    }
    return o;
  };
  
  function assign(a, b) {
    for (var key in b) {
      if (hasOwn(b, key)) {
        a[key] = b[key];
      }
    }
  }
  
  /**
   * Returns true if the given `key` is an own property of `obj`.
   */
  
  function hasOwn(obj, key) {
    return Object.prototype.hasOwnProperty.call(obj, key);
  }
  
  
  /***/ }),
  /* 708 */,
  /* 709 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Inserts the sub-list into the list, at the specified `index`. _Note that this is not
   * destructive_: it returns a copy of the list with the changes.
   * <small>No lists have been harmed in the application of this function.</small>
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category List
   * @sig Number -> [a] -> [a] -> [a]
   * @param {Number} index The position to insert the sub-list
   * @param {Array} elts The sub-list to insert into the Array
   * @param {Array} list The list to insert the sub-list into
   * @return {Array} A new Array with `elts` inserted starting at `index`.
   * @example
   *
   *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]
   */
  
  
  var insertAll =
  /*#__PURE__*/
  _curry3(function insertAll(idx, elts, list) {
    idx = idx < list.length && idx >= 0 ? idx : list.length;
    return [].concat(Array.prototype.slice.call(list, 0, idx), elts, Array.prototype.slice.call(list, idx));
  });
  
  module.exports = insertAll;
  
  /***/ }),
  /* 710 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Same as [`R.invertObj`](#invertObj), however this accounts for objects with
   * duplicate values by putting the values into an array.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Object
   * @sig {s: x} -> {x: [ s, ... ]}
   * @param {Object} obj The object or array to invert
   * @return {Object} out A new object with keys in an array.
   * @see R.invertObj
   * @example
   *
   *      const raceResultsByFirstName = {
   *        first: 'alice',
   *        second: 'jake',
   *        third: 'alice',
   *      };
   *      R.invert(raceResultsByFirstName);
   *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }
   */
  
  
  var invert =
  /*#__PURE__*/
  _curry1(function invert(obj) {
    var props = keys(obj);
    var len = props.length;
    var idx = 0;
    var out = {};
  
    while (idx < len) {
      var key = props[idx];
      var val = obj[key];
      var list = _has(val, out) ? out[val] : out[val] = [];
      list[list.length] = key;
      idx += 1;
    }
  
    return out;
  });
  
  module.exports = invert;
  
  /***/ }),
  /* 711 */,
  /* 712 */,
  /* 713 */,
  /* 714 */,
  /* 715 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var nAry =
  /*#__PURE__*/
  __webpack_require__(425);
  /**
   * Wraps a function of any arity (including nullary) in a function that accepts
   * exactly 1 parameter. Any extraneous parameters will not be passed to the
   * supplied function.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category Function
   * @sig (* -> b) -> (a -> b)
   * @param {Function} fn The function to wrap.
   * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
   *         arity 1.
   * @see R.binary, R.nAry
   * @example
   *
   *      const takesTwoArgs = function(a, b) {
   *        return [a, b];
   *      };
   *      takesTwoArgs.length; //=> 2
   *      takesTwoArgs(1, 2); //=> [1, 2]
   *
   *      const takesOneArg = R.unary(takesTwoArgs);
   *      takesOneArg.length; //=> 1
   *      // Only 1 argument is passed to the wrapped function
   *      takesOneArg(1, 2); //=> [1, undefined]
   * @symb R.unary(f)(a, b, c) = f(a)
   */
  
  
  var unary =
  /*#__PURE__*/
  _curry1(function unary(fn) {
    return nAry(1, fn);
  });
  
  module.exports = unary;
  
  /***/ }),
  /* 716 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includesWith =
  /*#__PURE__*/
  __webpack_require__(680);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Finds the set (i.e. no duplicates) of all elements in the first list not
   * contained in the second list. Duplication is determined according to the
   * value returned by applying the supplied predicate to two list elements.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]
   * @param {Function} pred A predicate used to test whether two items are equal.
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The elements in `list1` that are not in `list2`.
   * @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith
   * @example
   *
   *      const cmp = (x, y) => x.a === y.a;
   *      const l1 = [{a: 1}, {a: 2}, {a: 3}];
   *      const l2 = [{a: 3}, {a: 4}];
   *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]
   */
  
  
  var differenceWith =
  /*#__PURE__*/
  _curry3(function differenceWith(pred, first, second) {
    var out = [];
    var idx = 0;
    var firstLen = first.length;
  
    while (idx < firstLen) {
      if (!_includesWith(pred, first[idx], second) && !_includesWith(pred, first[idx], out)) {
        out.push(first[idx]);
      }
  
      idx += 1;
    }
  
    return out;
  });
  
  module.exports = differenceWith;
  
  /***/ }),
  /* 717 */,
  /* 718 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Inserts the supplied element into the list, at the specified `index`. _Note that
  
   * this is not destructive_: it returns a copy of the list with the changes.
   * <small>No lists have been harmed in the application of this function.</small>
   *
   * @func
   * @memberOf R
   * @since v0.2.2
   * @category List
   * @sig Number -> a -> [a] -> [a]
   * @param {Number} index The position to insert the element
   * @param {*} elt The element to insert into the Array
   * @param {Array} list The list to insert into
   * @return {Array} A new Array with `elt` inserted at `index`.
   * @example
   *
   *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]
   */
  
  
  var insert =
  /*#__PURE__*/
  _curry3(function insert(idx, elt, list) {
    idx = idx < list.length && idx >= 0 ? idx : list.length;
    var result = Array.prototype.slice.call(list, 0);
    result.splice(idx, 0, elt);
    return result;
  });
  
  module.exports = insert;
  
  /***/ }),
  /* 719 */,
  /* 720 */,
  /* 721 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isPlaceholder =
  /*#__PURE__*/
  __webpack_require__(953);
  /**
   * Optimized internal one-arity curry function.
   *
   * @private
   * @category Function
   * @param {Function} fn The function to curry.
   * @return {Function} The curried function.
   */
  
  
  function _curry1(fn) {
    return function f1(a) {
      if (arguments.length === 0 || _isPlaceholder(a)) {
        return f1;
      } else {
        return fn.apply(this, arguments);
      }
    };
  }
  
  module.exports = _curry1;
  
  /***/ }),
  /* 722 */,
  /* 723 */,
  /* 724 */,
  /* 725 */,
  /* 726 */,
  /* 727 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  const util = __webpack_require__(343);
  
  const convertToJson = function(node, options, parentTagName) {
    const jObj = {};
  
    // when no child node or attr is present
    if ((!node.child || util.isEmptyObject(node.child)) && (!node.attrsMap || util.isEmptyObject(node.attrsMap))) {
      return util.isExist(node.val) ? node.val : '';
    }
  
    // otherwise create a textnode if node has some text
    if (util.isExist(node.val) && !(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) {
      const asArray = util.isTagNameInArrayMode(node.tagname, options.arrayMode, parentTagName)
      jObj[options.textNodeName] = asArray ? [node.val] : node.val;
    }
  
    util.merge(jObj, node.attrsMap, options.arrayMode);
  
    const keys = Object.keys(node.child);
    for (let index = 0; index < keys.length; index++) {
      const tagName = keys[index];
      if (node.child[tagName] && node.child[tagName].length > 1) {
        jObj[tagName] = [];
        for (let tag in node.child[tagName]) {
          if (node.child[tagName].hasOwnProperty(tag)) {
            jObj[tagName].push(convertToJson(node.child[tagName][tag], options, tagName));
          }
        }
      } else {
        const result = convertToJson(node.child[tagName][0], options, tagName);
        const asArray = (options.arrayMode === true && typeof result === 'object') || util.isTagNameInArrayMode(tagName, options.arrayMode, parentTagName);
        jObj[tagName] = asArray ? [result] : result;
      }
    }
  
    //add value
    return jObj;
  };
  
  exports.convertToJson = convertToJson;
  
  
  /***/ }),
  /* 728 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.SearchState = void 0;
  class SearchState {
      constructor(path, level) {
          this.path = path;
          this.level = level;
      }
  }
  exports.SearchState = SearchState;
  //# sourceMappingURL=internal-search-state.js.map
  
  /***/ }),
  /* 729 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _clone =
  /*#__PURE__*/
  __webpack_require__(794);
  
  var _curryN =
  /*#__PURE__*/
  __webpack_require__(404);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xreduceBy =
  /*#__PURE__*/
  __webpack_require__(530);
  /**
   * Groups the elements of the list according to the result of calling
   * the String-returning function `keyFn` on each element and reduces the elements
   * of each group to a single value via the reducer function `valueFn`.
   *
   * This function is basically a more general [`groupBy`](#groupBy) function.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.20.0
   * @category List
   * @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a}
   * @param {Function} valueFn The function that reduces the elements of each group to a single
   *        value. Receives two values, accumulator for a particular group and the current element.
   * @param {*} acc The (initial) accumulator value for each group.
   * @param {Function} keyFn The function that maps the list's element into a key.
   * @param {Array} list The array to group.
   * @return {Object} An object with the output of `keyFn` for keys, mapped to the output of
   *         `valueFn` for elements which produced that key when passed to `keyFn`.
   * @see R.groupBy, R.reduce
   * @example
   *
   *      const groupNames = (acc, {name}) => acc.concat(name)
   *      const toGrade = ({score}) =>
   *        score < 65 ? 'F' :
   *        score < 70 ? 'D' :
   *        score < 80 ? 'C' :
   *        score < 90 ? 'B' : 'A'
   *
   *      var students = [
   *        {name: 'Abby', score: 83},
   *        {name: 'Bart', score: 62},
   *        {name: 'Curt', score: 88},
   *        {name: 'Dora', score: 92},
   *      ]
   *
   *      reduceBy(groupNames, [], toGrade, students)
   *      //=> {"A": ["Dora"], "B": ["Abby", "Curt"], "F": ["Bart"]}
   */
  
  
  var reduceBy =
  /*#__PURE__*/
  _curryN(4, [],
  /*#__PURE__*/
  _dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) {
    return _reduce(function (acc, elt) {
      var key = keyFn(elt);
      acc[key] = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt);
      return acc;
    }, {}, list);
  }));
  
  module.exports = reduceBy;
  
  /***/ }),
  /* 730 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isNumber =
  /*#__PURE__*/
  __webpack_require__(571);
  /**
   * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Number -> Number -> [Number]
   * @param {Number} from The first number in the list.
   * @param {Number} to One more than the last number in the list.
   * @return {Array} The list of numbers in the set `[a, b)`.
   * @example
   *
   *      R.range(1, 5);    //=> [1, 2, 3, 4]
   *      R.range(50, 53);  //=> [50, 51, 52]
   */
  
  
  var range =
  /*#__PURE__*/
  _curry2(function range(from, to) {
    if (!(_isNumber(from) && _isNumber(to))) {
      throw new TypeError('Both arguments to range must be numbers');
    }
  
    var result = [];
    var n = from;
  
    while (n < to) {
      result.push(n);
      n += 1;
    }
  
    return result;
  });
  
  module.exports = range;
  
  /***/ }),
  /* 731 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  /**
   * Creates a new list iteration function from an existing one by adding two new
   * parameters to its callback function: the current index, and the entire list.
   *
   * This would turn, for instance, [`R.map`](#map) function into one that
   * more closely resembles `Array.prototype.map`. Note that this will only work
   * for functions in which the iteration callback function is the first
   * parameter, and where the list is the last parameter. (This latter might be
   * unimportant if the list parameter is not used.)
   *
   * @func
   * @memberOf R
   * @since v0.15.0
   * @category Function
   * @category List
   * @sig ((a ... -> b) ... -> [a] -> *) -> ((a ..., Int, [a] -> b) ... -> [a] -> *)
   * @param {Function} fn A list iteration function that does not pass index or list to its callback
   * @return {Function} An altered list iteration function that passes (item, index, list) to its callback
   * @example
   *
   *      const mapIndexed = R.addIndex(R.map);
   *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
   *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
   */
  
  
  var addIndex =
  /*#__PURE__*/
  _curry1(function addIndex(fn) {
    return curryN(fn.length, function () {
      var idx = 0;
      var origFn = arguments[0];
      var list = arguments[arguments.length - 1];
      var args = Array.prototype.slice.call(arguments, 0);
  
      args[0] = function () {
        var result = origFn.apply(this, _concat(arguments, [idx, list]));
        idx += 1;
        return result;
      };
  
      return fn.apply(this, args);
    });
  });
  
  module.exports = addIndex;
  
  /***/ }),
  /* 732 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var identity =
  /*#__PURE__*/
  __webpack_require__(534);
  
  var uniqBy =
  /*#__PURE__*/
  __webpack_require__(703);
  /**
   * Returns a new list containing only one copy of each element in the original
   * list. [`R.equals`](#equals) is used to determine equality.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [a]
   * @param {Array} list The array to consider.
   * @return {Array} The list of unique items.
   * @example
   *
   *      R.uniq([1, 1, 2, 1]); //=> [1, 2]
   *      R.uniq([1, '1']);     //=> [1, '1']
   *      R.uniq([[42], [42]]); //=> [[42]]
   */
  
  
  var uniq =
  /*#__PURE__*/
  uniqBy(identity);
  module.exports = uniq;
  
  /***/ }),
  /* 733 */,
  /* 734 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var mergeDeepWithKey =
  /*#__PURE__*/
  __webpack_require__(492);
  /**
   * Creates a new object with the own properties of the first object merged with
   * the own properties of the second object. If a key exists in both objects:
   * - and both values are objects, the two values will be recursively merged
   * - otherwise the value from the first object will be used.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Object
   * @sig {a} -> {a} -> {a}
   * @param {Object} lObj
   * @param {Object} rObj
   * @return {Object}
   * @see R.merge, R.mergeDeepRight, R.mergeDeepWith, R.mergeDeepWithKey
   * @example
   *
   *      R.mergeDeepLeft({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},
   *                      { age: 40, contact: { email: 'baa@example.com' }});
   *      //=> { name: 'fred', age: 10, contact: { email: 'moo@example.com' }}
   */
  
  
  var mergeDeepLeft =
  /*#__PURE__*/
  _curry2(function mergeDeepLeft(lObj, rObj) {
    return mergeDeepWithKey(function (k, lVal, rVal) {
      return lVal;
    }, lObj, rObj);
  });
  
  module.exports = mergeDeepLeft;
  
  /***/ }),
  /* 735 */,
  /* 736 */,
  /* 737 */,
  /* 738 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XDrop =
  /*#__PURE__*/
  function () {
    function XDrop(n, xf) {
      this.xf = xf;
      this.n = n;
    }
  
    XDrop.prototype['@@transducer/init'] = _xfBase.init;
    XDrop.prototype['@@transducer/result'] = _xfBase.result;
  
    XDrop.prototype['@@transducer/step'] = function (result, input) {
      if (this.n > 0) {
        this.n -= 1;
        return result;
      }
  
      return this.xf['@@transducer/step'](result, input);
    };
  
    return XDrop;
  }();
  
  var _xdrop =
  /*#__PURE__*/
  _curry2(function _xdrop(n, xf) {
    return new XDrop(n, xf);
  });
  
  module.exports = _xdrop;
  
  /***/ }),
  /* 739 */,
  /* 740 */,
  /* 741 */,
  /* 742 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XDropLastWhile =
  /*#__PURE__*/
  function () {
    function XDropLastWhile(fn, xf) {
      this.f = fn;
      this.retained = [];
      this.xf = xf;
    }
  
    XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;
  
    XDropLastWhile.prototype['@@transducer/result'] = function (result) {
      this.retained = null;
      return this.xf['@@transducer/result'](result);
    };
  
    XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {
      return this.f(input) ? this.retain(result, input) : this.flush(result, input);
    };
  
    XDropLastWhile.prototype.flush = function (result, input) {
      result = _reduce(this.xf['@@transducer/step'], result, this.retained);
      this.retained = [];
      return this.xf['@@transducer/step'](result, input);
    };
  
    XDropLastWhile.prototype.retain = function (result, input) {
      this.retained.push(input);
      return result;
    };
  
    return XDropLastWhile;
  }();
  
  var _xdropLastWhile =
  /*#__PURE__*/
  _curry2(function _xdropLastWhile(fn, xf) {
    return new XDropLastWhile(fn, xf);
  });
  
  module.exports = _xdropLastWhile;
  
  /***/ }),
  /* 743 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Subtracts its second argument from its first argument.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} a The first value.
   * @param {Number} b The second value.
   * @return {Number} The result of `a - b`.
   * @see R.add
   * @example
   *
   *      R.subtract(10, 8); //=> 2
   *
   *      const minus5 = R.subtract(R.__, 5);
   *      minus5(17); //=> 12
   *
   *      const complementaryAngle = R.subtract(90);
   *      complementaryAngle(30); //=> 60
   *      complementaryAngle(72); //=> 18
   */
  
  
  var subtract =
  /*#__PURE__*/
  _curry2(function subtract(a, b) {
    return Number(a) - Number(b);
  });
  
  module.exports = subtract;
  
  /***/ }),
  /* 744 */,
  /* 745 */,
  /* 746 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var keys =
  /*#__PURE__*/
  __webpack_require__(89);
  /**
   * Returns a new object with the keys of the given object as values, and the
   * values of the given object, which are coerced to strings, as keys. Note
   * that the last key found is preferred when handling the same value.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Object
   * @sig {s: x} -> {x: s}
   * @param {Object} obj The object or array to invert
   * @return {Object} out A new object
   * @see R.invert
   * @example
   *
   *      const raceResults = {
   *        first: 'alice',
   *        second: 'jake'
   *      };
   *      R.invertObj(raceResults);
   *      //=> { 'alice': 'first', 'jake':'second' }
   *
   *      // Alternatively:
   *      const raceResults = ['alice', 'jake'];
   *      R.invertObj(raceResults);
   *      //=> { 'alice': '0', 'jake':'1' }
   */
  
  
  var invertObj =
  /*#__PURE__*/
  _curry1(function invertObj(obj) {
    var props = keys(obj);
    var len = props.length;
    var idx = 0;
    var out = {};
  
    while (idx < len) {
      var key = props[idx];
      out[obj[key]] = key;
      idx += 1;
    }
  
    return out;
  });
  
  module.exports = invertObj;
  
  /***/ }),
  /* 747 */
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  /* 748 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var ap =
  /*#__PURE__*/
  __webpack_require__(641);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  /**
   * "lifts" a function to be the specified arity, so that it may "map over" that
   * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
   *
   * @func
   * @memberOf R
   * @since v0.7.0
   * @category Function
   * @sig Number -> (*... -> *) -> ([*]... -> [*])
   * @param {Function} fn The function to lift into higher context
   * @return {Function} The lifted function.
   * @see R.lift, R.ap
   * @example
   *
   *      const madd3 = R.liftN(3, (...args) => R.sum(args));
   *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
   */
  
  
  var liftN =
  /*#__PURE__*/
  _curry2(function liftN(arity, fn) {
    var lifted = curryN(arity, fn);
    return curryN(arity, function () {
      return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
    });
  });
  
  module.exports = liftN;
  
  /***/ }),
  /* 749 */,
  /* 750 */,
  /* 751 */,
  /* 752 */,
  /* 753 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var endpoint = __webpack_require__(892);
  var universalUserAgent = __webpack_require__(392);
  var isPlainObject = __webpack_require__(767);
  var nodeFetch = _interopDefault(__webpack_require__(369));
  var requestError = __webpack_require__(463);
  
  const VERSION = "5.6.0";
  
  function getBufferResponse(response) {
    return response.arrayBuffer();
  }
  
  function fetchWrapper(requestOptions) {
    const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console;
  
    if (isPlainObject.isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) {
      requestOptions.body = JSON.stringify(requestOptions.body);
    }
  
    let headers = {};
    let status;
    let url;
    const fetch = requestOptions.request && requestOptions.request.fetch || nodeFetch;
    return fetch(requestOptions.url, Object.assign({
      method: requestOptions.method,
      body: requestOptions.body,
      headers: requestOptions.headers,
      redirect: requestOptions.redirect
    }, // `requestOptions.request.agent` type is incompatible
    // see https://github.com/octokit/types.ts/pull/264
    requestOptions.request)).then(async response => {
      url = response.url;
      status = response.status;
  
      for (const keyAndValue of response.headers) {
        headers[keyAndValue[0]] = keyAndValue[1];
      }
  
      if ("deprecation" in headers) {
        const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/);
        const deprecationLink = matches && matches.pop();
        log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
      }
  
      if (status === 204 || status === 205) {
        return;
      } // GitHub API returns 200 for HEAD requests
  
  
      if (requestOptions.method === "HEAD") {
        if (status < 400) {
          return;
        }
  
        throw new requestError.RequestError(response.statusText, status, {
          response: {
            url,
            status,
            headers,
            data: undefined
          },
          request: requestOptions
        });
      }
  
      if (status === 304) {
        throw new requestError.RequestError("Not modified", status, {
          response: {
            url,
            status,
            headers,
            data: await getResponseData(response)
          },
          request: requestOptions
        });
      }
  
      if (status >= 400) {
        const data = await getResponseData(response);
        const error = new requestError.RequestError(toErrorMessage(data), status, {
          response: {
            url,
            status,
            headers,
            data
          },
          request: requestOptions
        });
        throw error;
      }
  
      return getResponseData(response);
    }).then(data => {
      return {
        status,
        url,
        headers,
        data
      };
    }).catch(error => {
      if (error instanceof requestError.RequestError) throw error;
      throw new requestError.RequestError(error.message, 500, {
        request: requestOptions
      });
    });
  }
  
  async function getResponseData(response) {
    const contentType = response.headers.get("content-type");
  
    if (/application\/json/.test(contentType)) {
      return response.json();
    }
  
    if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
      return response.text();
    }
  
    return getBufferResponse(response);
  }
  
  function toErrorMessage(data) {
    if (typeof data === "string") return data; // istanbul ignore else - just in case
  
    if ("message" in data) {
      if (Array.isArray(data.errors)) {
        return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`;
      }
  
      return data.message;
    } // istanbul ignore next - just in case
  
  
    return `Unknown error: ${JSON.stringify(data)}`;
  }
  
  function withDefaults(oldEndpoint, newDefaults) {
    const endpoint = oldEndpoint.defaults(newDefaults);
  
    const newApi = function (route, parameters) {
      const endpointOptions = endpoint.merge(route, parameters);
  
      if (!endpointOptions.request || !endpointOptions.request.hook) {
        return fetchWrapper(endpoint.parse(endpointOptions));
      }
  
      const request = (route, parameters) => {
        return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters)));
      };
  
      Object.assign(request, {
        endpoint,
        defaults: withDefaults.bind(null, endpoint)
      });
      return endpointOptions.request.hook(request, endpointOptions);
    };
  
    return Object.assign(newApi, {
      endpoint,
      defaults: withDefaults.bind(null, endpoint)
    });
  }
  
  const request = withDefaults(endpoint.endpoint, {
    headers: {
      "user-agent": `octokit-request.js/${VERSION} ${universalUserAgent.getUserAgent()}`
    }
  });
  
  exports.request = request;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 754 */,
  /* 755 */,
  /* 756 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var paths =
  /*#__PURE__*/
  __webpack_require__(394);
  /**
   * Retrieve the value at a given path.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category Object
   * @typedefn Idx = String | Int
   * @sig [Idx] -> {a} -> a | Undefined
   * @param {Array} path The path to use.
   * @param {Object} obj The object to retrieve the nested property from.
   * @return {*} The data at `path`.
   * @see R.prop, R.nth
   * @example
   *
   *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2
   *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined
   *      R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1
   *      R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2
   */
  
  
  var path =
  /*#__PURE__*/
  _curry2(function path(pathAr, obj) {
    return paths([pathAr], obj)[0];
  });
  
  module.exports = path;
  
  /***/ }),
  /* 757 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Returns `true` if the specified object property satisfies the given
   * predicate; `false` otherwise. You can test multiple properties with
   * [`R.where`](#where).
   *
   * @func
   * @memberOf R
   * @since v0.16.0
   * @category Logic
   * @sig (a -> Boolean) -> String -> {String: a} -> Boolean
   * @param {Function} pred
   * @param {String} name
   * @param {*} obj
   * @return {Boolean}
   * @see R.where, R.propEq, R.propIs
   * @example
   *
   *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true
   */
  
  
  var propSatisfies =
  /*#__PURE__*/
  _curry3(function propSatisfies(pred, name, obj) {
    return pred(obj[name]);
  });
  
  module.exports = propSatisfies;
  
  /***/ }),
  /* 758 */,
  /* 759 */,
  /* 760 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var multiply =
  /*#__PURE__*/
  __webpack_require__(880);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Multiplies together all the elements of a list.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig [Number] -> Number
   * @param {Array} list An array of numbers
   * @return {Number} The product of all the numbers in the list.
   * @see R.reduce
   * @example
   *
   *      R.product([2,4,6,8,100,1]); //=> 38400
   */
  
  
  var product =
  /*#__PURE__*/
  reduce(multiply, 1);
  module.exports = product;
  
  /***/ }),
  /* 761 */
  /***/ (function(module) {
  
  module.exports = require("zlib");
  
  /***/ }),
  /* 762 */,
  /* 763 */
  /***/ (function(module) {
  
  module.exports = removeHook;
  
  function removeHook(state, name, method) {
    if (!state.registry[name]) {
      return;
    }
  
    var index = state.registry[name]
      .map(function (registered) {
        return registered.orig;
      })
      .indexOf(method);
  
    if (index === -1) {
      return;
    }
  
    state.registry[name].splice(index, 1);
  }
  
  
  /***/ }),
  /* 764 */,
  /* 765 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Takes a predicate, a transformation function, and an initial value,
   * and returns a value of the same type as the initial value.
   * It does so by applying the transformation until the predicate is satisfied,
   * at which point it returns the satisfactory value.
   *
   * @func
   * @memberOf R
   * @since v0.20.0
   * @category Logic
   * @sig (a -> Boolean) -> (a -> a) -> a -> a
   * @param {Function} pred A predicate function
   * @param {Function} fn The iterator function
   * @param {*} init Initial value
   * @return {*} Final value that satisfies predicate
   * @example
   *
   *      R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128
   */
  
  
  var until =
  /*#__PURE__*/
  _curry3(function until(pred, fn, init) {
    var val = init;
  
    while (!pred(val)) {
      val = fn(val);
    }
  
    return val;
  });
  
  module.exports = until;
  
  /***/ }),
  /* 766 */,
  /* 767 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  /*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObject(o) {
    return Object.prototype.toString.call(o) === '[object Object]';
  }
  
  function isPlainObject(o) {
    var ctor,prot;
  
    if (isObject(o) === false) return false;
  
    // If has modified constructor
    ctor = o.constructor;
    if (ctor === undefined) return true;
  
    // If has modified prototype
    prot = ctor.prototype;
    if (isObject(prot) === false) return false;
  
    // If constructor does not have an Object-specific method
    if (prot.hasOwnProperty('isPrototypeOf') === false) {
      return false;
    }
  
    // Most likely a plain Object
    return true;
  }
  
  exports.isPlainObject = isPlainObject;
  
  
  /***/ }),
  /* 768 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var curry =
  /*#__PURE__*/
  __webpack_require__(447);
  
  var nAry =
  /*#__PURE__*/
  __webpack_require__(425);
  /**
   * Wraps a constructor function inside a curried function that can be called
   * with the same arguments and returns the same type. The arity of the function
   * returned is specified to allow using variadic constructor functions.
   *
   * @func
   * @memberOf R
   * @since v0.4.0
   * @category Function
   * @sig Number -> (* -> {*}) -> (* -> {*})
   * @param {Number} n The arity of the constructor function.
   * @param {Function} Fn The constructor function to wrap.
   * @return {Function} A wrapped, curried constructor function.
   * @example
   *
   *      // Variadic Constructor function
   *      function Salad() {
   *        this.ingredients = arguments;
   *      }
   *
   *      Salad.prototype.recipe = function() {
   *        const instructions = R.map(ingredient => 'Add a dollop of ' + ingredient, this.ingredients);
   *        return R.join('\n', instructions);
   *      };
   *
   *      const ThreeLayerSalad = R.constructN(3, Salad);
   *
   *      // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.
   *      const salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup');
   *
   *      console.log(salad.recipe());
   *      // Add a dollop of Mayonnaise
   *      // Add a dollop of Potato Chips
   *      // Add a dollop of Ketchup
   */
  
  
  var constructN =
  /*#__PURE__*/
  _curry2(function constructN(n, Fn) {
    if (n > 10) {
      throw new Error('Constructor with greater than ten arguments');
    }
  
    if (n === 0) {
      return function () {
        return new Fn();
      };
    }
  
    return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
      switch (arguments.length) {
        case 1:
          return new Fn($0);
  
        case 2:
          return new Fn($0, $1);
  
        case 3:
          return new Fn($0, $1, $2);
  
        case 4:
          return new Fn($0, $1, $2, $3);
  
        case 5:
          return new Fn($0, $1, $2, $3, $4);
  
        case 6:
          return new Fn($0, $1, $2, $3, $4, $5);
  
        case 7:
          return new Fn($0, $1, $2, $3, $4, $5, $6);
  
        case 8:
          return new Fn($0, $1, $2, $3, $4, $5, $6, $7);
  
        case 9:
          return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);
  
        case 10:
          return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);
      }
    }));
  });
  
  module.exports = constructN;
  
  /***/ }),
  /* 769 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curryN =
  /*#__PURE__*/
  __webpack_require__(404);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  /**
   * Like [`reduce`](#reduce), `reduceWhile` returns a single item by iterating
   * through the list, successively calling the iterator function. `reduceWhile`
   * also takes a predicate that is evaluated before each step. If the predicate
   * returns `false`, it "short-circuits" the iteration and returns the current
   * value of the accumulator.
   *
   * @func
   * @memberOf R
   * @since v0.22.0
   * @category List
   * @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a
   * @param {Function} pred The predicate. It is passed the accumulator and the
   *        current element.
   * @param {Function} fn The iterator function. Receives two values, the
   *        accumulator and the current element.
   * @param {*} a The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.reduce, R.reduced
   * @example
   *
   *      const isOdd = (acc, x) => x % 2 === 1;
   *      const xs = [1, 3, 5, 60, 777, 800];
   *      R.reduceWhile(isOdd, R.add, 0, xs); //=> 9
   *
   *      const ys = [2, 4, 6]
   *      R.reduceWhile(isOdd, R.add, 111, ys); //=> 111
   */
  
  
  var reduceWhile =
  /*#__PURE__*/
  _curryN(4, [], function _reduceWhile(pred, fn, a, list) {
    return _reduce(function (acc, x) {
      return pred(acc, x) ? fn(acc, x) : _reduced(acc);
    }, a, list);
  });
  
  module.exports = reduceWhile;
  
  /***/ }),
  /* 770 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var invoker =
  /*#__PURE__*/
  __webpack_require__(691);
  /**
   * The upper case version of a string.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category String
   * @sig String -> String
   * @param {String} str The string to upper case.
   * @return {String} The upper case version of `str`.
   * @see R.toLower
   * @example
   *
   *      R.toUpper('abc'); //=> 'ABC'
   */
  
  
  var toUpper =
  /*#__PURE__*/
  invoker(0, 'toUpperCase');
  module.exports = toUpper;
  
  /***/ }),
  /* 771 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _createPartialApplicator =
  /*#__PURE__*/
  __webpack_require__(166);
  
  var flip =
  /*#__PURE__*/
  __webpack_require__(328);
  /**
   * Takes a function `f` and a list of arguments, and returns a function `g`.
   * When applied, `g` returns the result of applying `f` to the arguments
   * provided to `g` followed by the arguments provided initially.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Function
   * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)
   * @param {Function} f
   * @param {Array} args
   * @return {Function}
   * @see R.partial
   * @example
   *
   *      const greet = (salutation, title, firstName, lastName) =>
   *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
   *
   *      const greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);
   *
   *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'
   * @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b)
   */
  
  
  var partialRight =
  /*#__PURE__*/
  _createPartialApplicator(
  /*#__PURE__*/
  flip(_concat));
  
  module.exports = partialRight;
  
  /***/ }),
  /* 772 */,
  /* 773 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a new list with the given element at the front, followed by the
   * contents of the list.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig a -> [a] -> [a]
   * @param {*} el The item to add to the head of the output list.
   * @param {Array} list The array to add to the tail of the output list.
   * @return {Array} A new array.
   * @see R.append
   * @example
   *
   *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
   */
  
  
  var prepend =
  /*#__PURE__*/
  _curry2(function prepend(el, list) {
    return _concat([el], list);
  });
  
  module.exports = prepend;
  
  /***/ }),
  /* 774 */,
  /* 775 */,
  /* 776 */,
  /* 777 */,
  /* 778 */,
  /* 779 */,
  /* 780 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includesWith =
  /*#__PURE__*/
  __webpack_require__(680);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a new list containing only one copy of each element in the original
   * list, based upon the value returned by applying the supplied predicate to
   * two list elements. Prefers the first item if two items compare equal based
   * on the predicate.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category List
   * @sig ((a, a) -> Boolean) -> [a] -> [a]
   * @param {Function} pred A predicate used to test whether two items are equal.
   * @param {Array} list The array to consider.
   * @return {Array} The list of unique items.
   * @example
   *
   *      const strEq = R.eqBy(String);
   *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]
   *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]
   *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]
   *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']
   */
  
  
  var uniqWith =
  /*#__PURE__*/
  _curry2(function uniqWith(pred, list) {
    var idx = 0;
    var len = list.length;
    var result = [];
    var item;
  
    while (idx < len) {
      item = list[idx];
  
      if (!_includesWith(pred, item, result)) {
        result[result.length] = item;
      }
  
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = uniqWith;
  
  /***/ }),
  /* 781 */,
  /* 782 */,
  /* 783 */,
  /* 784 */,
  /* 785 */,
  /* 786 */,
  /* 787 */,
  /* 788 */,
  /* 789 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function getUserAgent() {
    if (typeof navigator === "object" && "userAgent" in navigator) {
      return navigator.userAgent;
    }
  
    if (typeof process === "object" && "version" in process) {
      return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
    }
  
    return "<environment undetectable>";
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 790 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var nAry =
  /*#__PURE__*/
  __webpack_require__(425);
  /**
   * Wraps a function of any arity (including nullary) in a function that accepts
   * exactly 2 parameters. Any extraneous parameters will not be passed to the
   * supplied function.
   *
   * @func
   * @memberOf R
   * @since v0.2.0
   * @category Function
   * @sig (* -> c) -> (a, b -> c)
   * @param {Function} fn The function to wrap.
   * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
   *         arity 2.
   * @see R.nAry, R.unary
   * @example
   *
   *      const takesThreeArgs = function(a, b, c) {
   *        return [a, b, c];
   *      };
   *      takesThreeArgs.length; //=> 3
   *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]
   *
   *      const takesTwoArgs = R.binary(takesThreeArgs);
   *      takesTwoArgs.length; //=> 2
   *      // Only 2 arguments are passed to the wrapped function
   *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]
   * @symb R.binary(f)(a, b, c) = f(a, b)
   */
  
  
  var binary =
  /*#__PURE__*/
  _curry1(function binary(fn) {
    return nAry(2, fn);
  });
  
  module.exports = binary;
  
  /***/ }),
  /* 791 */,
  /* 792 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Adds two values.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} a
   * @param {Number} b
   * @return {Number}
   * @see R.subtract
   * @example
   *
   *      R.add(2, 3);       //=>  5
   *      R.add(7)(10);      //=> 17
   */
  
  
  var add =
  /*#__PURE__*/
  _curry2(function add(a, b) {
    return Number(a) + Number(b);
  });
  
  module.exports = add;
  
  /***/ }),
  /* 793 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns the larger of its two arguments.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> a
   * @param {*} a
   * @param {*} b
   * @return {*}
   * @see R.maxBy, R.min
   * @example
   *
   *      R.max(789, 123); //=> 789
   *      R.max('a', 'b'); //=> 'b'
   */
  
  
  var max =
  /*#__PURE__*/
  _curry2(function max(a, b) {
    return b > a ? b : a;
  });
  
  module.exports = max;
  
  /***/ }),
  /* 794 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _cloneRegExp =
  /*#__PURE__*/
  __webpack_require__(480);
  
  var type =
  /*#__PURE__*/
  __webpack_require__(552);
  /**
   * Copies an object.
   *
   * @private
   * @param {*} value The value to be copied
   * @param {Array} refFrom Array containing the source references
   * @param {Array} refTo Array containing the copied source references
   * @param {Boolean} deep Whether or not to perform deep cloning.
   * @return {*} The copied value.
   */
  
  
  function _clone(value, refFrom, refTo, deep) {
    var copy = function copy(copiedValue) {
      var len = refFrom.length;
      var idx = 0;
  
      while (idx < len) {
        if (value === refFrom[idx]) {
          return refTo[idx];
        }
  
        idx += 1;
      }
  
      refFrom[idx + 1] = value;
      refTo[idx + 1] = copiedValue;
  
      for (var key in value) {
        copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];
      }
  
      return copiedValue;
    };
  
    switch (type(value)) {
      case 'Object':
        return copy({});
  
      case 'Array':
        return copy([]);
  
      case 'Date':
        return new Date(value.valueOf());
  
      case 'RegExp':
        return _cloneRegExp(value);
  
      default:
        return value;
    }
  }
  
  module.exports = _clone;
  
  /***/ }),
  /* 795 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Creates a new object from a list key-value pairs. If a key appears in
   * multiple pairs, the rightmost pair is included in the object.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category List
   * @sig [[k,v]] -> {k: v}
   * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.
   * @return {Object} The object made by pairing up `keys` and `values`.
   * @see R.toPairs, R.pair
   * @example
   *
   *      R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}
   */
  
  
  var fromPairs =
  /*#__PURE__*/
  _curry1(function fromPairs(pairs) {
    var result = {};
    var idx = 0;
  
    while (idx < pairs.length) {
      result[pairs[idx][0]] = pairs[idx][1];
      idx += 1;
    }
  
    return result;
  });
  
  module.exports = fromPairs;
  
  /***/ }),
  /* 796 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var osName = _interopDefault(__webpack_require__(282));
  
  function getUserAgent() {
    try {
      return `Node.js/${process.version.substr(1)} (${osName()}; ${process.arch})`;
    } catch (error) {
      if (/wmic os get Caption/.test(error.message)) {
        return "Windows <version undetectable>";
      }
  
      return "<environment undetectable>";
    }
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 797 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _checkForMethod =
  /*#__PURE__*/
  __webpack_require__(417);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var reduceBy =
  /*#__PURE__*/
  __webpack_require__(729);
  /**
   * Splits a list into sub-lists stored in an object, based on the result of
   * calling a String-returning function on each element, and grouping the
   * results according to values returned.
   *
   * Dispatches to the `groupBy` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig (a -> String) -> [a] -> {String: [a]}
   * @param {Function} fn Function :: a -> String
   * @param {Array} list The array to group
   * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements
   *         that produced that key when passed to `fn`.
   * @see R.reduceBy, R.transduce
   * @example
   *
   *      const byGrade = R.groupBy(function(student) {
   *        const score = student.score;
   *        return score < 65 ? 'F' :
   *               score < 70 ? 'D' :
   *               score < 80 ? 'C' :
   *               score < 90 ? 'B' : 'A';
   *      });
   *      const students = [{name: 'Abby', score: 84},
   *                      {name: 'Eddy', score: 58},
   *                      // ...
   *                      {name: 'Jack', score: 69}];
   *      byGrade(students);
   *      // {
   *      //   'A': [{name: 'Dianne', score: 99}],
   *      //   'B': [{name: 'Abby', score: 84}]
   *      //   // ...,
   *      //   'F': [{name: 'Eddy', score: 58}]
   *      // }
   */
  
  
  var groupBy =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _checkForMethod('groupBy',
  /*#__PURE__*/
  reduceBy(function (acc, item) {
    if (acc == null) {
      acc = [];
    }
  
    acc.push(item);
    return acc;
  }, null)));
  
  module.exports = groupBy;
  
  /***/ }),
  /* 798 */
  /***/ (function(module) {
  
  function _arrayFromIterator(iter) {
    var list = [];
    var next;
  
    while (!(next = iter.next()).done) {
      list.push(next.value);
    }
  
    return list;
  }
  
  module.exports = _arrayFromIterator;
  
  /***/ }),
  /* 799 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns a new object that does not contain a `prop` property.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Object
   * @sig String -> {k: v} -> {k: v}
   * @param {String} prop The name of the property to dissociate
   * @param {Object} obj The object to clone
   * @return {Object} A new object equivalent to the original but without the specified property
   * @see R.assoc, R.omit
   * @example
   *
   *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
   */
  
  
  var dissoc =
  /*#__PURE__*/
  _curry2(function dissoc(prop, obj) {
    var result = {};
  
    for (var p in obj) {
      result[p] = obj[p];
    }
  
    delete result[prop];
    return result;
  });
  
  module.exports = dissoc;
  
  /***/ }),
  /* 800 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  // Note: since nyc uses this module to output coverage, any lines
  // that are in the direct sync flow of nyc's outputCoverage are
  // ignored, since we can never get coverage for them.
  var assert = __webpack_require__(357)
  var signals = __webpack_require__(654)
  
  var EE = __webpack_require__(614)
  /* istanbul ignore if */
  if (typeof EE !== 'function') {
    EE = EE.EventEmitter
  }
  
  var emitter
  if (process.__signal_exit_emitter__) {
    emitter = process.__signal_exit_emitter__
  } else {
    emitter = process.__signal_exit_emitter__ = new EE()
    emitter.count = 0
    emitter.emitted = {}
  }
  
  // Because this emitter is a global, we have to check to see if a
  // previous version of this library failed to enable infinite listeners.
  // I know what you're about to say.  But literally everything about
  // signal-exit is a compromise with evil.  Get used to it.
  if (!emitter.infinite) {
    emitter.setMaxListeners(Infinity)
    emitter.infinite = true
  }
  
  module.exports = function (cb, opts) {
    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
  
    if (loaded === false) {
      load()
    }
  
    var ev = 'exit'
    if (opts && opts.alwaysLast) {
      ev = 'afterexit'
    }
  
    var remove = function () {
      emitter.removeListener(ev, cb)
      if (emitter.listeners('exit').length === 0 &&
          emitter.listeners('afterexit').length === 0) {
        unload()
      }
    }
    emitter.on(ev, cb)
  
    return remove
  }
  
  module.exports.unload = unload
  function unload () {
    if (!loaded) {
      return
    }
    loaded = false
  
    signals.forEach(function (sig) {
      try {
        process.removeListener(sig, sigListeners[sig])
      } catch (er) {}
    })
    process.emit = originalProcessEmit
    process.reallyExit = originalProcessReallyExit
    emitter.count -= 1
  }
  
  function emit (event, code, signal) {
    if (emitter.emitted[event]) {
      return
    }
    emitter.emitted[event] = true
    emitter.emit(event, code, signal)
  }
  
  // { <signal>: <listener fn>, ... }
  var sigListeners = {}
  signals.forEach(function (sig) {
    sigListeners[sig] = function listener () {
      // If there are no other listeners, an exit is coming!
      // Simplest way: remove us and then re-send the signal.
      // We know that this will kill the process, so we can
      // safely emit now.
      var listeners = process.listeners(sig)
      if (listeners.length === emitter.count) {
        unload()
        emit('exit', null, sig)
        /* istanbul ignore next */
        emit('afterexit', null, sig)
        /* istanbul ignore next */
        process.kill(process.pid, sig)
      }
    }
  })
  
  module.exports.signals = function () {
    return signals
  }
  
  module.exports.load = load
  
  var loaded = false
  
  function load () {
    if (loaded) {
      return
    }
    loaded = true
  
    // This is the number of onSignalExit's that are in play.
    // It's important so that we can count the correct number of
    // listeners on signals, and don't wait for the other one to
    // handle it instead of us.
    emitter.count += 1
  
    signals = signals.filter(function (sig) {
      try {
        process.on(sig, sigListeners[sig])
        return true
      } catch (er) {
        return false
      }
    })
  
    process.emit = processEmit
    process.reallyExit = processReallyExit
  }
  
  var originalProcessReallyExit = process.reallyExit
  function processReallyExit (code) {
    process.exitCode = code || 0
    emit('exit', process.exitCode, null)
    /* istanbul ignore next */
    emit('afterexit', process.exitCode, null)
    /* istanbul ignore next */
    originalProcessReallyExit.call(process, process.exitCode)
  }
  
  var originalProcessEmit = process.emit
  function processEmit (ev, arg) {
    if (ev === 'exit') {
      if (arg !== undefined) {
        process.exitCode = arg
      }
      var ret = originalProcessEmit.apply(this, arguments)
      emit('exit', process.exitCode, null)
      /* istanbul ignore next */
      emit('afterexit', process.exitCode, null)
      return ret
    } else {
      return originalProcessEmit.apply(this, arguments)
    }
  }
  
  
  /***/ }),
  /* 801 */,
  /* 802 */
  /***/ (function(module) {
  
  /**
   * Determine if the passed argument is an integer.
   *
   * @private
   * @param {*} n
   * @category Type
   * @return {Boolean}
   */
  module.exports = Number.isInteger || function _isInteger(n) {
    return n << 0 === n;
  };
  
  /***/ }),
  /* 803 */,
  /* 804 */,
  /* 805 */,
  /* 806 */,
  /* 807 */,
  /* 808 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XTakeWhile =
  /*#__PURE__*/
  function () {
    function XTakeWhile(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;
    XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;
  
    XTakeWhile.prototype['@@transducer/step'] = function (result, input) {
      return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);
    };
  
    return XTakeWhile;
  }();
  
  var _xtakeWhile =
  /*#__PURE__*/
  _curry2(function _xtakeWhile(f, xf) {
    return new XTakeWhile(f, xf);
  });
  
  module.exports = _xtakeWhile;
  
  /***/ }),
  /* 809 */,
  /* 810 */,
  /* 811 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XDropWhile =
  /*#__PURE__*/
  function () {
    function XDropWhile(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XDropWhile.prototype['@@transducer/init'] = _xfBase.init;
    XDropWhile.prototype['@@transducer/result'] = _xfBase.result;
  
    XDropWhile.prototype['@@transducer/step'] = function (result, input) {
      if (this.f) {
        if (this.f(input)) {
          return result;
        }
  
        this.f = null;
      }
  
      return this.xf['@@transducer/step'](result, input);
    };
  
    return XDropWhile;
  }();
  
  var _xdropWhile =
  /*#__PURE__*/
  _curry2(function _xdropWhile(f, xf) {
    return new XDropWhile(f, xf);
  });
  
  module.exports = _xdropWhile;
  
  /***/ }),
  /* 812 */,
  /* 813 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var fs = __webpack_require__(747)
  var core
  if (process.platform === 'win32' || global.TESTING_WINDOWS) {
    core = __webpack_require__(587)
  } else {
    core = __webpack_require__(197)
  }
  
  module.exports = isexe
  isexe.sync = sync
  
  function isexe (path, options, cb) {
    if (typeof options === 'function') {
      cb = options
      options = {}
    }
  
    if (!cb) {
      if (typeof Promise !== 'function') {
        throw new TypeError('callback not provided')
      }
  
      return new Promise(function (resolve, reject) {
        isexe(path, options || {}, function (er, is) {
          if (er) {
            reject(er)
          } else {
            resolve(is)
          }
        })
      })
    }
  
    core(path, options || {}, function (er, is) {
      // ignore EACCES because that just means we aren't allowed to run it
      if (er) {
        if (er.code === 'EACCES' || options && options.ignoreErrors) {
          er = null
          is = false
        }
      }
      cb(er, is)
    })
  }
  
  function sync (path, options) {
    // my kingdom for a filtered catch
    try {
      return core.sync(path, options || {})
    } catch (er) {
      if (options && options.ignoreErrors || er.code === 'EACCES') {
        return false
      } else {
        throw er
      }
    }
  }
  
  
  /***/ }),
  /* 814 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _createPartialApplicator =
  /*#__PURE__*/
  __webpack_require__(166);
  /**
   * Takes a function `f` and a list of arguments, and returns a function `g`.
   * When applied, `g` returns the result of applying `f` to the arguments
   * provided initially followed by the arguments provided to `g`.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Function
   * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)
   * @param {Function} f
   * @param {Array} args
   * @return {Function}
   * @see R.partialRight, R.curry
   * @example
   *
   *      const multiply2 = (a, b) => a * b;
   *      const double = R.partial(multiply2, [2]);
   *      double(2); //=> 4
   *
   *      const greet = (salutation, title, firstName, lastName) =>
   *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
   *
   *      const sayHello = R.partial(greet, ['Hello']);
   *      const sayHelloToMs = R.partial(sayHello, ['Ms.']);
   *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'
   * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)
   */
  
  
  var partial =
  /*#__PURE__*/
  _createPartialApplicator(_concat);
  
  module.exports = partial;
  
  /***/ }),
  /* 815 */,
  /* 816 */
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = /^#!.*/;
  
  
  /***/ }),
  /* 817 */,
  /* 818 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var _isFunction =
  /*#__PURE__*/
  __webpack_require__(504);
  
  var _isString =
  /*#__PURE__*/
  __webpack_require__(285);
  
  var toString =
  /*#__PURE__*/
  __webpack_require__(854);
  /**
   * Returns the result of concatenating the given lists or strings.
   *
   * Note: `R.concat` expects both arguments to be of the same type,
   * unlike the native `Array.prototype.concat` method. It will throw
   * an error if you `concat` an Array with a non-Array value.
   *
   * Dispatches to the `concat` method of the first argument, if present.
   * Can also concatenate two members of a [fantasy-land
   * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig [a] -> [a] -> [a]
   * @sig String -> String -> String
   * @param {Array|String} firstList The first list
   * @param {Array|String} secondList The second list
   * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of
   * `secondList`.
   *
   * @example
   *
   *      R.concat('ABC', 'DEF'); // 'ABCDEF'
   *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
   *      R.concat([], []); //=> []
   */
  
  
  var concat =
  /*#__PURE__*/
  _curry2(function concat(a, b) {
    if (_isArray(a)) {
      if (_isArray(b)) {
        return a.concat(b);
      }
  
      throw new TypeError(toString(b) + ' is not an array');
    }
  
    if (_isString(a)) {
      if (_isString(b)) {
        return a + b;
      }
  
      throw new TypeError(toString(b) + ' is not a string');
    }
  
    if (a != null && _isFunction(a['fantasy-land/concat'])) {
      return a['fantasy-land/concat'](b);
    }
  
    if (a != null && _isFunction(a.concat)) {
      return a.concat(b);
    }
  
    throw new TypeError(toString(a) + ' does not have a method named "concat" or "fantasy-land/concat"');
  });
  
  module.exports = concat;
  
  /***/ }),
  /* 819 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var prop =
  /*#__PURE__*/
  __webpack_require__(196);
  /**
   * Returns a new list by plucking the same named property off all objects in
   * the list supplied.
   *
   * `pluck` will work on
   * any [functor](https://github.com/fantasyland/fantasy-land#functor) in
   * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig Functor f => k -> f {k: v} -> f v
   * @param {Number|String} key The key name to pluck off of each object.
   * @param {Array} f The array or functor to consider.
   * @return {Array} The list of values for the given key.
   * @see R.props
   * @example
   *
   *      var getAges = R.pluck('age');
   *      getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27]
   *
   *      R.pluck(0, [[1, 2], [3, 4]]);               //=> [1, 3]
   *      R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}
   * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]
   * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]
   */
  
  
  var pluck =
  /*#__PURE__*/
  _curry2(function pluck(p, list) {
    return map(prop(p), list);
  });
  
  module.exports = pluck;
  
  /***/ }),
  /* 820 */,
  /* 821 */,
  /* 822 */,
  /* 823 */,
  /* 824 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.AnnotationLevel = void 0;
  var AnnotationLevel;
  (function (AnnotationLevel) {
      AnnotationLevel["notice"] = "notice";
      AnnotationLevel["warning"] = "warning";
      AnnotationLevel["failure"] = "failure";
  })(AnnotationLevel = exports.AnnotationLevel || (exports.AnnotationLevel = {}));
  
  
  /***/ }),
  /* 825 */,
  /* 826 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * The `mapAccumRight` function behaves like a combination of map and reduce; it
   * applies a function to each element of a list, passing an accumulating
   * parameter from right to left, and returning a final value of this
   * accumulator together with the new list.
   *
   * Similar to [`mapAccum`](#mapAccum), except moves through the input list from
   * the right to the left.
   *
   * The iterator function receives two arguments, *acc* and *value*, and should
   * return a tuple *[acc, value]*.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category List
   * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])
   * @param {Function} fn The function to be called on every element of the input `list`.
   * @param {*} acc The accumulator value.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.addIndex, R.mapAccum
   * @example
   *
   *      const digits = ['1', '2', '3', '4'];
   *      const appender = (a, b) => [b + a, b + a];
   *
   *      R.mapAccumRight(appender, 5, digits); //=> ['12345', ['12345', '2345', '345', '45']]
   * @symb R.mapAccumRight(f, a, [b, c, d]) = [
   *   f(f(f(a, d)[0], c)[0], b)[0],
   *   [
   *     f(a, d)[1],
   *     f(f(a, d)[0], c)[1],
   *     f(f(f(a, d)[0], c)[0], b)[1]
   *   ]
   * ]
   */
  
  
  var mapAccumRight =
  /*#__PURE__*/
  _curry3(function mapAccumRight(fn, acc, list) {
    var idx = list.length - 1;
    var result = [];
    var tuple = [acc];
  
    while (idx >= 0) {
      tuple = fn(tuple[0], list[idx]);
      result[idx] = tuple[1];
      idx -= 1;
    }
  
    return [tuple[0], result];
  });
  
  module.exports = mapAccumRight;
  
  /***/ }),
  /* 827 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var ap =
  /*#__PURE__*/
  __webpack_require__(641);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var prepend =
  /*#__PURE__*/
  __webpack_require__(773);
  
  var reduceRight =
  /*#__PURE__*/
  __webpack_require__(382);
  /**
   * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)
   * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an
   * Applicative of Traversable.
   *
   * Dispatches to the `sequence` method of the second argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)
   * @param {Function} of
   * @param {*} traversable
   * @return {*}
   * @see R.traverse
   * @example
   *
   *      R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])
   *      R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()
   *
   *      R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]
   *      R.sequence(R.of, Nothing());       //=> [Nothing()]
   */
  
  
  var sequence =
  /*#__PURE__*/
  _curry2(function sequence(of, traversable) {
    return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight(function (x, acc) {
      return ap(map(prepend, x), acc);
    }, of([]), traversable);
  });
  
  module.exports = sequence;
  
  /***/ }),
  /* 828 */,
  /* 829 */,
  /* 830 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _isPlaceholder =
  /*#__PURE__*/
  __webpack_require__(953);
  /**
   * Optimized internal two-arity curry function.
   *
   * @private
   * @category Function
   * @param {Function} fn The function to curry.
   * @return {Function} The curried function.
   */
  
  
  function _curry2(fn) {
    return function f2(a, b) {
      switch (arguments.length) {
        case 0:
          return f2;
  
        case 1:
          return _isPlaceholder(a) ? f2 : _curry1(function (_b) {
            return fn(a, _b);
          });
  
        default:
          return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {
            return fn(_a, b);
          }) : _isPlaceholder(b) ? _curry1(function (_b) {
            return fn(a, _b);
          }) : fn(a, b);
      }
    };
  }
  
  module.exports = _curry2;
  
  /***/ }),
  /* 831 */,
  /* 832 */,
  /* 833 */,
  /* 834 */,
  /* 835 */
  /***/ (function(module) {
  
  module.exports = require("url");
  
  /***/ }),
  /* 836 */,
  /* 837 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Creates a new list out of the two supplied by applying the function to each
   * equally-positioned pair in the lists. The returned list is truncated to the
   * length of the shorter of the two input lists.
   *
   * @function
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig ((a, b) -> c) -> [a] -> [b] -> [c]
   * @param {Function} fn The function used to combine the two elements into one value.
   * @param {Array} list1 The first array to consider.
   * @param {Array} list2 The second array to consider.
   * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`
   *         using `fn`.
   * @example
   *
   *      const f = (x, y) => {
   *        // ...
   *      };
   *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);
   *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
   * @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)]
   */
  
  
  var zipWith =
  /*#__PURE__*/
  _curry3(function zipWith(fn, a, b) {
    var rv = [];
    var idx = 0;
    var len = Math.min(a.length, b.length);
  
    while (idx < len) {
      rv[idx] = fn(a[idx], b[idx]);
      idx += 1;
    }
  
    return rv;
  });
  
  module.exports = zipWith;
  
  /***/ }),
  /* 838 */,
  /* 839 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XTap =
  /*#__PURE__*/
  function () {
    function XTap(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XTap.prototype['@@transducer/init'] = _xfBase.init;
    XTap.prototype['@@transducer/result'] = _xfBase.result;
  
    XTap.prototype['@@transducer/step'] = function (result, input) {
      this.f(input);
      return this.xf['@@transducer/step'](result, input);
    };
  
    return XTap;
  }();
  
  var _xtap =
  /*#__PURE__*/
  _curry2(function _xtap(f, xf) {
    return new XTap(f, xf);
  });
  
  module.exports = _xtap;
  
  /***/ }),
  /* 840 */,
  /* 841 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _objectAssign =
  /*#__PURE__*/
  __webpack_require__(289);
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Merges a list of objects together into one object.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category List
   * @sig [{k: v}] -> {k: v}
   * @param {Array} list An array of objects
   * @return {Object} A merged object.
   * @see R.reduce
   * @example
   *
   *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
   *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}
   * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }
   */
  
  
  var mergeAll =
  /*#__PURE__*/
  _curry1(function mergeAll(list) {
    return _objectAssign.apply(null, [{}].concat(list));
  });
  
  module.exports = mergeAll;
  
  /***/ }),
  /* 842 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  const Endpoints = {
    actions: {
      addSelectedRepoToOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
      cancelWorkflowRun: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],
      createOrUpdateOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}"],
      createOrUpdateRepoSecret: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamedParameters: {
          name: "secret_name"
        }
      }],
      createOrUpdateSecretForRepo: ["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamed: ["actions", "createOrUpdateRepoSecret"],
        renamedParameters: {
          name: "secret_name"
        }
      }],
      createRegistrationToken: ["POST /repos/{owner}/{repo}/actions/runners/registration-token", {}, {
        renamed: ["actions", "createRegistrationTokenForRepo"]
      }],
      createRegistrationTokenForOrg: ["POST /orgs/{org}/actions/runners/registration-token"],
      createRegistrationTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/registration-token"],
      createRemoveToken: ["POST /repos/{owner}/{repo}/actions/runners/remove-token", {}, {
        renamed: ["actions", "createRemoveTokenForRepo"]
      }],
      createRemoveTokenForOrg: ["POST /orgs/{org}/actions/runners/remove-token"],
      createRemoveTokenForRepo: ["POST /repos/{owner}/{repo}/actions/runners/remove-token"],
      deleteArtifact: ["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
      deleteOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}"],
      deleteRepoSecret: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamedParameters: {
          name: "secret_name"
        }
      }],
      deleteSecretFromRepo: ["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamed: ["actions", "deleteRepoSecret"],
        renamedParameters: {
          name: "secret_name"
        }
      }],
      deleteSelfHostedRunnerFromOrg: ["DELETE /orgs/{org}/actions/runners/{runner_id}"],
      deleteSelfHostedRunnerFromRepo: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],
      deleteWorkflowRunLogs: ["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
      downloadArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],
      downloadJobLogsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],
      downloadWorkflowJobLogs: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs", {}, {
        renamed: ["actions", "downloadJobLogsForWorkflowRun"]
      }],
      downloadWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],
      getArtifact: ["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],
      getJobForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],
      getOrgPublicKey: ["GET /orgs/{org}/actions/secrets/public-key"],
      getOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}"],
      getPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key", {}, {
        renamed: ["actions", "getRepoPublicKey"]
      }],
      getRepoPublicKey: ["GET /repos/{owner}/{repo}/actions/secrets/public-key"],
      getRepoSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamedParameters: {
          name: "secret_name"
        }
      }],
      getSecret: ["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}", {}, {
        renamed: ["actions", "getRepoSecret"],
        renamedParameters: {
          name: "secret_name"
        }
      }],
      getSelfHostedRunner: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}", {}, {
        renamed: ["actions", "getSelfHostedRunnerForRepo"]
      }],
      getSelfHostedRunnerForOrg: ["GET /orgs/{org}/actions/runners/{runner_id}"],
      getSelfHostedRunnerForRepo: ["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],
      getWorkflow: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],
      getWorkflowJob: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}", {}, {
        renamed: ["actions", "getJobForWorkflowRun"]
      }],
      getWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],
      getWorkflowRunUsage: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],
      getWorkflowUsage: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],
      listArtifactsForRepo: ["GET /repos/{owner}/{repo}/actions/artifacts"],
      listDownloadsForSelfHostedRunnerApplication: ["GET /repos/{owner}/{repo}/actions/runners/downloads", {}, {
        renamed: ["actions", "listRunnerApplicationsForRepo"]
      }],
      listJobsForWorkflowRun: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],
      listOrgSecrets: ["GET /orgs/{org}/actions/secrets"],
      listRepoSecrets: ["GET /repos/{owner}/{repo}/actions/secrets"],
      listRepoWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/runs", {}, {
        renamed: ["actions", "listWorkflowRunsForRepo"]
      }],
      listRepoWorkflows: ["GET /repos/{owner}/{repo}/actions/workflows"],
      listRunnerApplicationsForOrg: ["GET /orgs/{org}/actions/runners/downloads"],
      listRunnerApplicationsForRepo: ["GET /repos/{owner}/{repo}/actions/runners/downloads"],
      listSecretsForRepo: ["GET /repos/{owner}/{repo}/actions/secrets", {}, {
        renamed: ["actions", "listRepoSecrets"]
      }],
      listSelectedReposForOrgSecret: ["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],
      listSelfHostedRunnersForOrg: ["GET /orgs/{org}/actions/runners"],
      listSelfHostedRunnersForRepo: ["GET /repos/{owner}/{repo}/actions/runners"],
      listWorkflowJobLogs: ["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs", {}, {
        renamed: ["actions", "downloadWorkflowJobLogs"]
      }],
      listWorkflowRunArtifacts: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],
      listWorkflowRunLogs: ["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs", {}, {
        renamed: ["actions", "downloadWorkflowRunLogs"]
      }],
      listWorkflowRuns: ["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],
      listWorkflowRunsForRepo: ["GET /repos/{owner}/{repo}/actions/runs"],
      reRunWorkflow: ["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],
      removeSelectedRepoFromOrgSecret: ["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],
      removeSelfHostedRunner: ["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}", {}, {
        renamed: ["actions", "deleteSelfHostedRunnerFromRepo"]
      }],
      setSelectedReposForOrgSecret: ["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"]
    },
    activity: {
      checkRepoIsStarredByAuthenticatedUser: ["GET /user/starred/{owner}/{repo}"],
      checkStarringRepo: ["GET /user/starred/{owner}/{repo}", {}, {
        renamed: ["activity", "checkRepoIsStarredByAuthenticatedUser"]
      }],
      deleteRepoSubscription: ["DELETE /repos/{owner}/{repo}/subscription"],
      deleteThreadSubscription: ["DELETE /notifications/threads/{thread_id}/subscription"],
      getFeeds: ["GET /feeds"],
      getRepoSubscription: ["GET /repos/{owner}/{repo}/subscription"],
      getThread: ["GET /notifications/threads/{thread_id}"],
      getThreadSubscription: ["PUT /notifications", {}, {
        renamed: ["activity", "getThreadSubscriptionForAuthenticatedUser"]
      }],
      getThreadSubscriptionForAuthenticatedUser: ["GET /notifications/threads/{thread_id}/subscription"],
      listEventsForAuthenticatedUser: ["GET /users/{username}/events"],
      listEventsForOrg: ["GET /users/{username}/events/orgs/{org}", {}, {
        renamed: ["activity", "listOrgEventsForAuthenticatedUser"]
      }],
      listEventsForUser: ["GET /users/{username}/events", {}, {
        renamed: ["activity", "listEventsForAuthenticatedUser"]
      }],
      listFeeds: ["GET /feeds", {}, {
        renamed: ["activity", "getFeeds"]
      }],
      listNotifications: ["GET /notifications", {}, {
        renamed: ["activity", "listNotificationsForAuthenticatedUser"]
      }],
      listNotificationsForAuthenticatedUser: ["GET /notifications"],
      listNotificationsForRepo: ["GET /repos/{owner}/{repo}/notifications", {}, {
        renamed: ["activity", "listRepoNotificationsForAuthenticatedUser"]
      }],
      listOrgEventsForAuthenticatedUser: ["GET /users/{username}/events/orgs/{org}"],
      listPublicEvents: ["GET /events"],
      listPublicEventsForOrg: ["GET /orgs/{org}/events", {}, {
        renamed: ["activity", "listPublicOrgEvents"]
      }],
      listPublicEventsForRepoNetwork: ["GET /networks/{owner}/{repo}/events"],
      listPublicEventsForUser: ["GET /users/{username}/events/public"],
      listPublicOrgEvents: ["GET /orgs/{org}/events"],
      listReceivedEventsForUser: ["GET /users/{username}/received_events"],
      listReceivedPublicEventsForUser: ["GET /users/{username}/received_events/public"],
      listRepoEvents: ["GET /repos/{owner}/{repo}/events"],
      listRepoNotificationsForAuthenticatedUser: ["GET /repos/{owner}/{repo}/notifications"],
      listReposStarredByAuthenticatedUser: ["GET /user/starred"],
      listReposStarredByUser: ["GET /users/{username}/starred"],
      listReposWatchedByUser: ["GET /users/{username}/subscriptions"],
      listStargazersForRepo: ["GET /repos/{owner}/{repo}/stargazers"],
      listWatchedReposForAuthenticatedUser: ["GET /user/subscriptions"],
      listWatchersForRepo: ["GET /repos/{owner}/{repo}/subscribers"],
      markAsRead: ["PUT /notifications", {}, {
        renamed: ["activity", "markNotificationsAsRead"]
      }],
      markNotificationsAsRead: ["PUT /notifications"],
      markNotificationsAsReadForRepo: ["PUT /repos/{owner}/{repo}/notifications", {}, {
        renamed: ["activity", "markRepoNotificationsAsRead"]
      }],
      markRepoNotificationsAsRead: ["PUT /repos/{owner}/{repo}/notifications"],
      markThreadAsRead: ["PATCH /notifications/threads/{thread_id}"],
      setRepoSubscription: ["PUT /repos/{owner}/{repo}/subscription"],
      setThreadSubscription: ["PUT /notifications/threads/{thread_id}/subscription"],
      starRepo: ["PUT /user/starred/{owner}/{repo}", {}, {
        renamed: ["activity", "starRepoForAuthenticatedUser"]
      }],
      starRepoForAuthenticatedUser: ["PUT /user/starred/{owner}/{repo}"],
      unstarRepo: ["DELETE /user/starred/{owner}/{repo}", {}, {
        renamed: ["activity", "unstarRepoForAuthenticatedUser"]
      }],
      unstarRepoForAuthenticatedUser: ["DELETE /user/starred/{owner}/{repo}"]
    },
    apps: {
      addRepoToInstallation: ["PUT /user/installations/{installation_id}/repositories/{repository_id}", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      checkAccountIsAssociatedWithAny: ["GET /marketplace_listing/accounts/{account_id}", {}, {
        renamed: ["apps", "getSubscriptionPlanForAccount"]
      }],
      checkAccountIsAssociatedWithAnyStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}", {}, {
        renamed: ["apps", "getSubscriptionPlanForAccountStubbed"]
      }],
      checkToken: ["POST /applications/{client_id}/token"],
      createContentAttachment: ["POST /content_references/{content_reference_id}/attachments", {
        mediaType: {
          previews: ["corsair"]
        }
      }],
      createFromManifest: ["POST /app-manifests/{code}/conversions"],
      createInstallationAccessToken: ["POST /app/installations/{installation_id}/access_tokens", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      createInstallationToken: ["POST /app/installations/{installation_id}/access_tokens", {
        mediaType: {
          previews: ["machine-man"]
        }
      }, {
        renamed: ["apps", "createInstallationAccessToken"]
      }],
      deleteAuthorization: ["DELETE /applications/{client_id}/grant"],
      deleteInstallation: ["DELETE /app/installations/{installation_id}", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      deleteToken: ["DELETE /applications/{client_id}/token"],
      getAuthenticated: ["GET /app", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      getBySlug: ["GET /apps/{app_slug}", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      getInstallation: ["GET /app/installations/{installation_id}", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      getOrgInstallation: ["GET /orgs/{org}/installation", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      getRepoInstallation: ["GET /repos/{owner}/{repo}/installation", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      getSubscriptionPlanForAccount: ["GET /marketplace_listing/accounts/{account_id}"],
      getSubscriptionPlanForAccountStubbed: ["GET /marketplace_listing/stubbed/accounts/{account_id}"],
      getUserInstallation: ["GET /users/{username}/installation", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listAccountsForPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts"],
      listAccountsForPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],
      listAccountsUserOrOrgOnPlan: ["GET /marketplace_listing/plans/{plan_id}/accounts", {}, {
        renamed: ["apps", "listAccountsForPlan"]
      }],
      listAccountsUserOrOrgOnPlanStubbed: ["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts", {}, {
        renamed: ["apps", "listAccountsForPlanStubbed"]
      }],
      listInstallationReposForAuthenticatedUser: ["GET /user/installations/{installation_id}/repositories", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listInstallations: ["GET /app/installations", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listInstallationsForAuthenticatedUser: ["GET /user/installations", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listMarketplacePurchasesForAuthenticatedUser: ["GET /user/marketplace_purchases", {}, {
        renamed: ["apps", "listSubscriptionsForAuthenticatedUser"]
      }],
      listMarketplacePurchasesForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed", {}, {
        renamed: ["apps", "listSubscriptionsForAuthenticatedUserStubbed"]
      }],
      listPlans: ["GET /marketplace_listing/plans"],
      listPlansStubbed: ["GET /marketplace_listing/stubbed/plans"],
      listRepos: ["GET /installation/repositories", {
        mediaType: {
          previews: ["machine-man"]
        }
      }, {
        renamed: ["apps", "listReposAccessibleToInstallation"]
      }],
      listReposAccessibleToInstallation: ["GET /installation/repositories", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listSubscriptionsForAuthenticatedUser: ["GET /user/marketplace_purchases"],
      listSubscriptionsForAuthenticatedUserStubbed: ["GET /user/marketplace_purchases/stubbed"],
      removeRepoFromInstallation: ["DELETE /user/installations/{installation_id}/repositories/{repository_id}", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      resetToken: ["PATCH /applications/{client_id}/token"],
      revokeInstallationAccessToken: ["DELETE /installation/token"],
      revokeInstallationToken: ["DELETE /installation/token", {}, {
        renamed: ["apps", "revokeInstallationAccessToken"]
      }],
      suspendInstallation: ["PUT /app/installations/{installation_id}/suspended"],
      unsuspendInstallation: ["DELETE /app/installations/{installation_id}/suspended"]
    },
    checks: {
      create: ["POST /repos/{owner}/{repo}/check-runs", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      createSuite: ["POST /repos/{owner}/{repo}/check-suites", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      get: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      getSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      listAnnotations: ["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      listForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-runs", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      listForSuite: ["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      listSuitesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/check-suites", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      rerequestSuite: ["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      setSuitesPreferences: ["PATCH /repos/{owner}/{repo}/check-suites/preferences", {
        mediaType: {
          previews: ["antiope"]
        }
      }],
      update: ["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}", {
        mediaType: {
          previews: ["antiope"]
        }
      }]
    },
    codeScanning: {
      getAlert: ["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_id}"],
      listAlertsForRepo: ["GET /repos/{owner}/{repo}/code-scanning/alerts"]
    },
    codesOfConduct: {
      getAllCodesOfConduct: ["GET /codes_of_conduct", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }],
      getConductCode: ["GET /codes_of_conduct/{key}", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }],
      getForRepo: ["GET /repos/{owner}/{repo}/community/code_of_conduct", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }],
      listConductCodes: ["GET /codes_of_conduct", {
        mediaType: {
          previews: ["scarlet-witch"]
        }
      }, {
        renamed: ["codesOfConduct", "getAllCodesOfConduct"]
      }]
    },
    emojis: {
      get: ["GET /emojis"]
    },
    gists: {
      checkIsStarred: ["GET /gists/{gist_id}/star"],
      create: ["POST /gists"],
      createComment: ["POST /gists/{gist_id}/comments"],
      delete: ["DELETE /gists/{gist_id}"],
      deleteComment: ["DELETE /gists/{gist_id}/comments/{comment_id}"],
      fork: ["POST /gists/{gist_id}/forks"],
      get: ["GET /gists/{gist_id}"],
      getComment: ["GET /gists/{gist_id}/comments/{comment_id}"],
      getRevision: ["GET /gists/{gist_id}/{sha}"],
      list: ["GET /gists"],
      listComments: ["GET /gists/{gist_id}/comments"],
      listCommits: ["GET /gists/{gist_id}/commits"],
      listForUser: ["GET /users/{username}/gists"],
      listForks: ["GET /gists/{gist_id}/forks"],
      listPublic: ["GET /gists/public"],
      listPublicForUser: ["GET /users/{username}/gists", {}, {
        renamed: ["gists", "listForUser"]
      }],
      listStarred: ["GET /gists/starred"],
      star: ["PUT /gists/{gist_id}/star"],
      unstar: ["DELETE /gists/{gist_id}/star"],
      update: ["PATCH /gists/{gist_id}"],
      updateComment: ["PATCH /gists/{gist_id}/comments/{comment_id}"]
    },
    git: {
      createBlob: ["POST /repos/{owner}/{repo}/git/blobs"],
      createCommit: ["POST /repos/{owner}/{repo}/git/commits"],
      createRef: ["POST /repos/{owner}/{repo}/git/refs"],
      createTag: ["POST /repos/{owner}/{repo}/git/tags"],
      createTree: ["POST /repos/{owner}/{repo}/git/trees"],
      deleteRef: ["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],
      getBlob: ["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],
      getCommit: ["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],
      getRef: ["GET /repos/{owner}/{repo}/git/ref/{ref}"],
      getTag: ["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],
      getTree: ["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],
      listMatchingRefs: ["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],
      updateRef: ["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]
    },
    gitignore: {
      getAllTemplates: ["GET /gitignore/templates"],
      getTemplate: ["GET /gitignore/templates/{name}"],
      listTemplates: ["GET /gitignore/templates", {}, {
        renamed: ["gitignore", "getAllTemplates"]
      }]
    },
    interactions: {
      addOrUpdateRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }, {
        renamed: ["interactions", "setRestrictionsForOrg"]
      }],
      addOrUpdateRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }, {
        renamed: ["interactions", "setRestrictionsForRepo"]
      }],
      getRestrictionsForOrg: ["GET /orgs/{org}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }],
      getRestrictionsForRepo: ["GET /repos/{owner}/{repo}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }],
      removeRestrictionsForOrg: ["DELETE /orgs/{org}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }],
      removeRestrictionsForRepo: ["DELETE /repos/{owner}/{repo}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }],
      setRestrictionsForOrg: ["PUT /orgs/{org}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }],
      setRestrictionsForRepo: ["PUT /repos/{owner}/{repo}/interaction-limits", {
        mediaType: {
          previews: ["sombra"]
        }
      }]
    },
    issues: {
      addAssignees: ["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
      addLabels: ["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      checkAssignee: ["GET /repos/{owner}/{repo}/assignees/{assignee}", {}, {
        renamed: ["issues", "checkUserCanBeAssigned"]
      }],
      checkUserCanBeAssigned: ["GET /repos/{owner}/{repo}/assignees/{assignee}"],
      create: ["POST /repos/{owner}/{repo}/issues"],
      createComment: ["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],
      createLabel: ["POST /repos/{owner}/{repo}/labels"],
      createMilestone: ["POST /repos/{owner}/{repo}/milestones"],
      deleteComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      deleteLabel: ["DELETE /repos/{owner}/{repo}/labels/{name}"],
      deleteMilestone: ["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],
      get: ["GET /repos/{owner}/{repo}/issues/{issue_number}"],
      getComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      getEvent: ["GET /repos/{owner}/{repo}/issues/events/{event_id}"],
      getLabel: ["GET /repos/{owner}/{repo}/labels/{name}"],
      getMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],
      list: ["GET /issues"],
      listAssignees: ["GET /repos/{owner}/{repo}/assignees"],
      listComments: ["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],
      listCommentsForRepo: ["GET /repos/{owner}/{repo}/issues/comments"],
      listEvents: ["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],
      listEventsForRepo: ["GET /repos/{owner}/{repo}/issues/events"],
      listEventsForTimeline: ["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline", {
        mediaType: {
          previews: ["mockingbird"]
        }
      }],
      listForAuthenticatedUser: ["GET /user/issues"],
      listForOrg: ["GET /orgs/{org}/issues"],
      listForRepo: ["GET /repos/{owner}/{repo}/issues"],
      listLabelsForMilestone: ["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],
      listLabelsForRepo: ["GET /repos/{owner}/{repo}/labels"],
      listLabelsOnIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      listMilestones: ["GET /repos/{owner}/{repo}/milestones"],
      listMilestonesForRepo: ["GET /repos/{owner}/{repo}/milestones", {}, {
        renamed: ["issues", "listMilestones"]
      }],
      lock: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],
      removeAllLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      removeAssignees: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],
      removeLabel: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],
      removeLabels: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels", {}, {
        renamed: ["issues", "removeAllLabels"]
      }],
      replaceAllLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels", {}, {
        renamed: ["issues", "setLabels"]
      }],
      replaceLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels", {}, {
        renamed: ["issues", "replaceAllLabels"]
      }],
      setLabels: ["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],
      unlock: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],
      update: ["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],
      updateComment: ["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],
      updateLabel: ["PATCH /repos/{owner}/{repo}/labels/{name}"],
      updateMilestone: ["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]
    },
    licenses: {
      get: ["GET /licenses/{license}"],
      getAllCommonlyUsed: ["GET /licenses"],
      getForRepo: ["GET /repos/{owner}/{repo}/license"],
      listCommonlyUsed: ["GET /licenses", {}, {
        renamed: ["licenses", "getAllCommonlyUsed"]
      }]
    },
    markdown: {
      render: ["POST /markdown"],
      renderRaw: ["POST /markdown/raw", {
        headers: {
          "content-type": "text/plain; charset=utf-8"
        }
      }]
    },
    meta: {
      get: ["GET /meta"]
    },
    migrations: {
      cancelImport: ["DELETE /repos/{owner}/{repo}/import"],
      deleteArchiveForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      deleteArchiveForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      downloadArchiveForOrg: ["GET /orgs/{org}/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getArchiveForAuthenticatedUser: ["GET /user/migrations/{migration_id}/archive", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getCommitAuthors: ["GET /repos/{owner}/{repo}/import/authors"],
      getImportProgress: ["GET /repos/{owner}/{repo}/import", {}, {
        renamed: ["migrations", "getImportStatus"]
      }],
      getImportStatus: ["GET /repos/{owner}/{repo}/import"],
      getLargeFiles: ["GET /repos/{owner}/{repo}/import/large_files"],
      getStatusForAuthenticatedUser: ["GET /user/migrations/{migration_id}", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      getStatusForOrg: ["GET /orgs/{org}/migrations/{migration_id}", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listForAuthenticatedUser: ["GET /user/migrations", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listForOrg: ["GET /orgs/{org}/migrations", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listReposForOrg: ["GET /orgs/{org}/migrations/{migration_id}/repositories", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      listReposForUser: ["GET /user/{migration_id}/repositories", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      mapCommitAuthor: ["PATCH /repos/{owner}/{repo}/import/authors/{author_id}"],
      setLfsPreference: ["PATCH /repos/{owner}/{repo}/import/lfs"],
      startForAuthenticatedUser: ["POST /user/migrations"],
      startForOrg: ["POST /orgs/{org}/migrations"],
      startImport: ["PUT /repos/{owner}/{repo}/import"],
      unlockRepoForAuthenticatedUser: ["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      unlockRepoForOrg: ["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock", {
        mediaType: {
          previews: ["wyandotte"]
        }
      }],
      updateImport: ["PATCH /repos/{owner}/{repo}/import"]
    },
    orgs: {
      addOrUpdateMembership: ["PUT /orgs/{org}/memberships/{username}", {}, {
        renamed: ["orgs", "setMembershipForUser"]
      }],
      blockUser: ["PUT /orgs/{org}/blocks/{username}"],
      checkBlockedUser: ["GET /orgs/{org}/blocks/{username}"],
      checkMembership: ["GET /orgs/{org}/members/{username}", {}, {
        renamed: ["orgs", "checkMembershipForUser"]
      }],
      checkMembershipForUser: ["GET /orgs/{org}/members/{username}"],
      checkPublicMembership: ["GET /orgs/{org}/public_members/{username}", {}, {
        renamed: ["orgs", "checkPublicMembershipForUser"]
      }],
      checkPublicMembershipForUser: ["GET /orgs/{org}/public_members/{username}"],
      concealMembership: ["DELETE /orgs/{org}/public_members/{username}", {}, {
        renamed: ["orgs", "removePublicMembershipForAuthenticatedUser"]
      }],
      convertMemberToOutsideCollaborator: ["PUT /orgs/{org}/outside_collaborators/{username}"],
      createHook: ["POST /orgs/{org}/hooks", {}, {
        renamed: ["orgs", "createWebhook"]
      }],
      createInvitation: ["POST /orgs/{org}/invitations"],
      createWebhook: ["POST /orgs/{org}/hooks"],
      deleteHook: ["DELETE /orgs/{org}/hooks/{hook_id}", {}, {
        renamed: ["orgs", "deleteWebhook"]
      }],
      deleteWebhook: ["DELETE /orgs/{org}/hooks/{hook_id}"],
      get: ["GET /orgs/{org}"],
      getHook: ["GET /orgs/{org}/hooks/{hook_id}", {}, {
        renamed: ["orgs", "getWebhook"]
      }],
      getMembership: ["GET /orgs/{org}/memberships/{username}", {}, {
        renamed: ["orgs", "getMembershipForUser"]
      }],
      getMembershipForAuthenticatedUser: ["GET /user/memberships/orgs/{org}"],
      getMembershipForUser: ["GET /orgs/{org}/memberships/{username}"],
      getWebhook: ["GET /orgs/{org}/hooks/{hook_id}"],
      list: ["GET /organizations"],
      listAppInstallations: ["GET /orgs/{org}/installations", {
        mediaType: {
          previews: ["machine-man"]
        }
      }],
      listBlockedUsers: ["GET /orgs/{org}/blocks"],
      listForAuthenticatedUser: ["GET /user/orgs"],
      listForUser: ["GET /users/{username}/orgs"],
      listHooks: ["GET /orgs/{org}/hooks", {}, {
        renamed: ["orgs", "listWebhooks"]
      }],
      listInstallations: ["GET /orgs/{org}/installations", {
        mediaType: {
          previews: ["machine-man"]
        }
      }, {
        renamed: ["orgs", "listAppInstallations"]
      }],
      listInvitationTeams: ["GET /orgs/{org}/invitations/{invitation_id}/teams"],
      listMembers: ["GET /orgs/{org}/members"],
      listMemberships: ["GET /user/memberships/orgs", {}, {
        renamed: ["orgs", "listMembershipsForAuthenticatedUser"]
      }],
      listMembershipsForAuthenticatedUser: ["GET /user/memberships/orgs"],
      listOutsideCollaborators: ["GET /orgs/{org}/outside_collaborators"],
      listPendingInvitations: ["GET /orgs/{org}/invitations"],
      listPublicMembers: ["GET /orgs/{org}/public_members"],
      listWebhooks: ["GET /orgs/{org}/hooks"],
      pingHook: ["POST /orgs/{org}/hooks/{hook_id}/pings", {}, {
        renamed: ["orgs", "pingWebhook"]
      }],
      pingWebhook: ["POST /orgs/{org}/hooks/{hook_id}/pings"],
      publicizeMembership: ["PUT /orgs/{org}/public_members/{username}", {}, {
        renamed: ["orgs", "setPublicMembershipForAuthenticatedUser"]
      }],
      removeMember: ["DELETE /orgs/{org}/members/{username}"],
      removeMembership: ["DELETE /orgs/{org}/memberships/{username}", {}, {
        renamed: ["orgs", "removeMembershipForUser"]
      }],
      removeMembershipForUser: ["DELETE /orgs/{org}/memberships/{username}"],
      removeOutsideCollaborator: ["DELETE /orgs/{org}/outside_collaborators/{username}"],
      removePublicMembershipForAuthenticatedUser: ["DELETE /orgs/{org}/public_members/{username}"],
      setMembershipForUser: ["PUT /orgs/{org}/memberships/{username}"],
      setPublicMembershipForAuthenticatedUser: ["PUT /orgs/{org}/public_members/{username}"],
      unblockUser: ["DELETE /orgs/{org}/blocks/{username}"],
      update: ["PATCH /orgs/{org}"],
      updateHook: ["PATCH /orgs/{org}/hooks/{hook_id}", {}, {
        renamed: ["orgs", "updateWebhook"]
      }],
      updateMembership: ["PATCH /user/memberships/orgs/{org}", {}, {
        renamed: ["orgs", "updateMembershipForAuthenticatedUser"]
      }],
      updateMembershipForAuthenticatedUser: ["PATCH /user/memberships/orgs/{org}"],
      updateWebhook: ["PATCH /orgs/{org}/hooks/{hook_id}"]
    },
    projects: {
      addCollaborator: ["PUT /projects/{project_id}/collaborators/{username}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createCard: ["POST /projects/columns/{column_id}/cards", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createColumn: ["POST /projects/{project_id}/columns", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForAuthenticatedUser: ["POST /user/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForOrg: ["POST /orgs/{org}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      createForRepo: ["POST /repos/{owner}/{repo}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      delete: ["DELETE /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      deleteCard: ["DELETE /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      deleteColumn: ["DELETE /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      get: ["GET /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getCard: ["GET /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getColumn: ["GET /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      getPermissionForUser: ["GET /projects/{project_id}/collaborators/{username}/permission", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listCards: ["GET /projects/columns/{column_id}/cards", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listCollaborators: ["GET /projects/{project_id}/collaborators", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listColumns: ["GET /projects/{project_id}/columns", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForOrg: ["GET /orgs/{org}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForRepo: ["GET /repos/{owner}/{repo}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listForUser: ["GET /users/{username}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      moveCard: ["POST /projects/columns/cards/{card_id}/moves", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      moveColumn: ["POST /projects/columns/{column_id}/moves", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      removeCollaborator: ["DELETE /projects/{project_id}/collaborators/{username}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      reviewUserPermissionLevel: ["GET /projects/{project_id}/collaborators/{username}/permission", {
        mediaType: {
          previews: ["inertia"]
        }
      }, {
        renamed: ["projects", "getPermissionForUser"]
      }],
      update: ["PATCH /projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      updateCard: ["PATCH /projects/columns/cards/{card_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      updateColumn: ["PATCH /projects/columns/{column_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }]
    },
    pulls: {
      checkIfMerged: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
      create: ["POST /repos/{owner}/{repo}/pulls"],
      createComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments", {}, {
        renamed: ["pulls", "createReviewComment"]
      }],
      createReplyForReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],
      createReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
      createReviewComment: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
      createReviewCommentReply: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies", {}, {
        renamed: ["pulls", "createReplyForReviewComment"]
      }],
      createReviewRequest: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", {}, {
        renamed: ["pulls", "requestReviewers"]
      }],
      deleteComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}", {}, {
        renamed: ["pulls", "deleteReviewComment"]
      }],
      deletePendingReview: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      deleteReviewComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
      deleteReviewRequest: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", {}, {
        renamed: ["pulls", "removeRequestedReviewers"]
      }],
      dismissReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],
      get: ["GET /repos/{owner}/{repo}/pulls/{pull_number}"],
      getComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}", {}, {
        renamed: ["pulls", "getReviewComment"]
      }],
      getCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments", {}, {
        renamed: ["pulls", "listCommentsForReview"]
      }],
      getReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      getReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],
      list: ["GET /repos/{owner}/{repo}/pulls"],
      listComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments", {}, {
        renamed: ["pulls", "listReviewComments"]
      }],
      listCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments", {}, {
        renamed: ["pulls", "listReviewCommentsForRepo"]
      }],
      listCommentsForReview: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],
      listCommits: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],
      listFiles: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],
      listRequestedReviewers: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      listReviewComments: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],
      listReviewCommentsForRepo: ["GET /repos/{owner}/{repo}/pulls/comments"],
      listReviewRequests: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers", {}, {
        renamed: ["pulls", "listRequestedReviewers"]
      }],
      listReviews: ["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],
      merge: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],
      removeRequestedReviewers: ["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      requestReviewers: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],
      submitReview: ["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],
      update: ["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],
      updateBranch: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch", {
        mediaType: {
          previews: ["lydian"]
        }
      }],
      updateComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}", {}, {
        renamed: ["pulls", "updateReviewComment"]
      }],
      updateReview: ["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],
      updateReviewComment: ["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]
    },
    rateLimit: {
      get: ["GET /rate_limit"]
    },
    reactions: {
      createForCommitComment: ["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForIssue: ["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForIssueComment: ["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForPullRequestReviewComment: ["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForTeamDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      createForTeamDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      delete: ["DELETE /reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }, {
        renamed: ["reactions", "deleteLegacy"]
      }],
      deleteForCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForIssue: ["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForIssueComment: ["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForPullRequestComment: ["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForTeamDiscussion: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteForTeamDiscussionComment: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      deleteLegacy: ["DELETE /reactions/{reaction_id}", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }, {
        deprecated: "octokit.reactions.deleteLegacy() is deprecated, see https://developer.github.com/v3/reactions/#delete-a-reaction-legacy"
      }],
      listForCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForIssue: ["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForIssueComment: ["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForPullRequestReviewComment: ["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForTeamDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }],
      listForTeamDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions", {
        mediaType: {
          previews: ["squirrel-girl"]
        }
      }]
    },
    repos: {
      acceptInvitation: ["PATCH /user/repository_invitations/{invitation_id}"],
      addAppAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      addCollaborator: ["PUT /repos/{owner}/{repo}/collaborators/{username}"],
      addDeployKey: ["POST /repos/{owner}/{repo}/keys", {}, {
        renamed: ["repos", "createDeployKey"]
      }],
      addProtectedBranchAdminEnforcement: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins", {}, {
        renamed: ["repos", "setAdminBranchProtection"]
      }],
      addProtectedBranchAppRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps",
        renamed: ["repos", "addAppAccessRestrictions"]
      }],
      addProtectedBranchRequiredSignatures: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }, {
        renamed: ["repos", "createCommitSignatureProtection"]
      }],
      addProtectedBranchRequiredStatusChecksContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts",
        renamed: ["repos", "addStatusCheckContexts"]
      }],
      addProtectedBranchTeamRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams",
        renamed: ["repos", "addTeamAccessRestrictions"]
      }],
      addProtectedBranchUserRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users",
        renamed: ["repos", "addUserAccessRestrictions"]
      }],
      addStatusCheckContexts: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      addTeamAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      addUserAccessRestrictions: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      checkCollaborator: ["GET /repos/{owner}/{repo}/collaborators/{username}"],
      checkVulnerabilityAlerts: ["GET /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      compareCommits: ["GET /repos/{owner}/{repo}/compare/{base}...{head}"],
      createCommitComment: ["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
      createCommitSignatureProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      createCommitStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}"],
      createDeployKey: ["POST /repos/{owner}/{repo}/keys"],
      createDeployment: ["POST /repos/{owner}/{repo}/deployments"],
      createDeploymentStatus: ["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
      createDispatchEvent: ["POST /repos/{owner}/{repo}/dispatches"],
      createForAuthenticatedUser: ["POST /user/repos"],
      createFork: ["POST /repos/{owner}/{repo}/forks"],
      createHook: ["POST /repos/{owner}/{repo}/hooks", {}, {
        renamed: ["repos", "createWebhook"]
      }],
      createInOrg: ["POST /orgs/{org}/repos"],
      createOrUpdateFile: ["PUT /repos/{owner}/{repo}/contents/{path}", {}, {
        renamed: ["repos", "createOrUpdateFileContents"]
      }],
      createOrUpdateFileContents: ["PUT /repos/{owner}/{repo}/contents/{path}"],
      createPagesSite: ["POST /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }],
      createRelease: ["POST /repos/{owner}/{repo}/releases"],
      createStatus: ["POST /repos/{owner}/{repo}/statuses/{sha}", {}, {
        renamed: ["repos", "createCommitStatus"]
      }],
      createUsingTemplate: ["POST /repos/{template_owner}/{template_repo}/generate", {
        mediaType: {
          previews: ["baptiste"]
        }
      }],
      createWebhook: ["POST /repos/{owner}/{repo}/hooks"],
      declineInvitation: ["DELETE /user/repository_invitations/{invitation_id}"],
      delete: ["DELETE /repos/{owner}/{repo}"],
      deleteAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
      deleteAdminBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      deleteBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],
      deleteCommitComment: ["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],
      deleteCommitSignatureProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      deleteDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}"],
      deleteDeployment: ["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],
      deleteDownload: ["DELETE /repos/{owner}/{repo}/downloads/{download_id}"],
      deleteFile: ["DELETE /repos/{owner}/{repo}/contents/{path}"],
      deleteHook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}", {}, {
        renamed: ["repos", "deleteWebhook"]
      }],
      deleteInvitation: ["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],
      deletePagesSite: ["DELETE /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }],
      deletePullRequestReviewProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      deleteRelease: ["DELETE /repos/{owner}/{repo}/releases/{release_id}"],
      deleteReleaseAsset: ["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      deleteWebhook: ["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],
      disableAutomatedSecurityFixes: ["DELETE /repos/{owner}/{repo}/automated-security-fixes", {
        mediaType: {
          previews: ["london"]
        }
      }],
      disablePagesSite: ["DELETE /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }, {
        renamed: ["repos", "deletePagesSite"]
      }],
      disableVulnerabilityAlerts: ["DELETE /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      downloadArchive: ["GET /repos/{owner}/{repo}/{archive_format}/{ref}"],
      enableAutomatedSecurityFixes: ["PUT /repos/{owner}/{repo}/automated-security-fixes", {
        mediaType: {
          previews: ["london"]
        }
      }],
      enablePagesSite: ["POST /repos/{owner}/{repo}/pages", {
        mediaType: {
          previews: ["switcheroo"]
        }
      }, {
        renamed: ["repos", "createPagesSite"]
      }],
      enableVulnerabilityAlerts: ["PUT /repos/{owner}/{repo}/vulnerability-alerts", {
        mediaType: {
          previews: ["dorian"]
        }
      }],
      get: ["GET /repos/{owner}/{repo}"],
      getAccessRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],
      getAdminBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      getAllStatusCheckContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],
      getAllTopics: ["GET /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }],
      getAppsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],
      getArchiveLink: ["GET /repos/{owner}/{repo}/{archive_format}/{ref}", {}, {
        renamed: ["repos", "downloadArchive"]
      }],
      getBranch: ["GET /repos/{owner}/{repo}/branches/{branch}"],
      getBranchProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection"],
      getClones: ["GET /repos/{owner}/{repo}/traffic/clones"],
      getCodeFrequencyStats: ["GET /repos/{owner}/{repo}/stats/code_frequency"],
      getCollaboratorPermissionLevel: ["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],
      getCombinedStatusForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/status"],
      getCommit: ["GET /repos/{owner}/{repo}/commits/{ref}"],
      getCommitActivityStats: ["GET /repos/{owner}/{repo}/stats/commit_activity"],
      getCommitComment: ["GET /repos/{owner}/{repo}/comments/{comment_id}"],
      getCommitSignatureProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }],
      getCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile"],
      getContent: ["GET /repos/{owner}/{repo}/contents/{path}"],
      getContents: ["GET /repos/{owner}/{repo}/contents/{path}", {}, {
        renamed: ["repos", "getContent"]
      }],
      getContributorsStats: ["GET /repos/{owner}/{repo}/stats/contributors"],
      getDeployKey: ["GET /repos/{owner}/{repo}/keys/{key_id}"],
      getDeployment: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],
      getDeploymentStatus: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],
      getDownload: ["GET /repos/{owner}/{repo}/downloads/{download_id}"],
      getHook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}", {}, {
        renamed: ["repos", "getWebhook"]
      }],
      getLatestPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/latest"],
      getLatestRelease: ["GET /repos/{owner}/{repo}/releases/latest"],
      getPages: ["GET /repos/{owner}/{repo}/pages"],
      getPagesBuild: ["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],
      getParticipationStats: ["GET /repos/{owner}/{repo}/stats/participation"],
      getProtectedBranchAdminEnforcement: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins", {}, {
        renamed: ["repos", "getAdminBranchProtection"]
      }],
      getProtectedBranchPullRequestReviewEnforcement: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews", {}, {
        renamed: ["repos", "getPullRequestReviewProtection"]
      }],
      getProtectedBranchRequiredSignatures: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }, {
        renamed: ["repos", "getCommitSignatureProtection"]
      }],
      getProtectedBranchRequiredStatusChecks: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, {
        renamed: ["repos", "getStatusChecksProtection"]
      }],
      getProtectedBranchRestrictions: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions", {}, {
        renamed: ["repos", "getAccessRestrictions"]
      }],
      getPullRequestReviewProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      getPunchCardStats: ["GET /repos/{owner}/{repo}/stats/punch_card"],
      getReadme: ["GET /repos/{owner}/{repo}/readme"],
      getRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}"],
      getReleaseAsset: ["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      getReleaseByTag: ["GET /repos/{owner}/{repo}/releases/tags/{tag}"],
      getStatusChecksProtection: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      getTeamsWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],
      getTopPaths: ["GET /repos/{owner}/{repo}/traffic/popular/paths"],
      getTopReferrers: ["GET /repos/{owner}/{repo}/traffic/popular/referrers"],
      getUsersWithAccessToProtectedBranch: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],
      getViews: ["GET /repos/{owner}/{repo}/traffic/views"],
      getWebhook: ["GET /repos/{owner}/{repo}/hooks/{hook_id}"],
      list: ["GET /user/repos", {}, {
        renamed: ["repos", "listForAuthenticatedUser"]
      }],
      listAssetsForRelease: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets", {}, {
        renamed: ["repos", "listReleaseAssets"]
      }],
      listBranches: ["GET /repos/{owner}/{repo}/branches"],
      listBranchesForHeadCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head", {
        mediaType: {
          previews: ["groot"]
        }
      }],
      listCollaborators: ["GET /repos/{owner}/{repo}/collaborators"],
      listCommentsForCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],
      listCommitComments: ["GET /repos/{owner}/{repo}/comments", {}, {
        renamed: ["repos", "listCommitCommentsForRepo"]
      }],
      listCommitCommentsForRepo: ["GET /repos/{owner}/{repo}/comments"],
      listCommitStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],
      listCommits: ["GET /repos/{owner}/{repo}/commits"],
      listContributors: ["GET /repos/{owner}/{repo}/contributors"],
      listDeployKeys: ["GET /repos/{owner}/{repo}/keys"],
      listDeploymentStatuses: ["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],
      listDeployments: ["GET /repos/{owner}/{repo}/deployments"],
      listDownloads: ["GET /repos/{owner}/{repo}/downloads"],
      listForAuthenticatedUser: ["GET /user/repos"],
      listForOrg: ["GET /orgs/{org}/repos"],
      listForUser: ["GET /users/{username}/repos"],
      listForks: ["GET /repos/{owner}/{repo}/forks"],
      listHooks: ["GET /repos/{owner}/{repo}/hooks", {}, {
        renamed: ["repos", "listWebhooks"]
      }],
      listInvitations: ["GET /repos/{owner}/{repo}/invitations"],
      listInvitationsForAuthenticatedUser: ["GET /user/repository_invitations"],
      listLanguages: ["GET /repos/{owner}/{repo}/languages"],
      listPagesBuilds: ["GET /repos/{owner}/{repo}/pages/builds"],
      listProtectedBranchRequiredStatusChecksContexts: ["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        renamed: ["repos", "getAllStatusCheckContexts"]
      }],
      listPublic: ["GET /repositories"],
      listPullRequestsAssociatedWithCommit: ["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls", {
        mediaType: {
          previews: ["groot"]
        }
      }],
      listReleaseAssets: ["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],
      listReleases: ["GET /repos/{owner}/{repo}/releases"],
      listStatusesForRef: ["GET /repos/{owner}/{repo}/commits/{ref}/statuses", {}, {
        renamed: ["repos", "listCommitStatusesForRef"]
      }],
      listTags: ["GET /repos/{owner}/{repo}/tags"],
      listTeams: ["GET /repos/{owner}/{repo}/teams"],
      listTopics: ["GET /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }, {
        renamed: ["repos", "getAllTopics"]
      }],
      listWebhooks: ["GET /repos/{owner}/{repo}/hooks"],
      merge: ["POST /repos/{owner}/{repo}/merges"],
      pingHook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings", {}, {
        renamed: ["repos", "pingWebhook"]
      }],
      pingWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],
      removeAppAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      removeBranchProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection", {}, {
        renamed: ["repos", "deleteBranchProtection"]
      }],
      removeCollaborator: ["DELETE /repos/{owner}/{repo}/collaborators/{username}"],
      removeDeployKey: ["DELETE /repos/{owner}/{repo}/keys/{key_id}", {}, {
        renamed: ["repos", "deleteDeployKey"]
      }],
      removeProtectedBranchAdminEnforcement: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins", {}, {
        renamed: ["repos", "deleteAdminBranchProtection"]
      }],
      removeProtectedBranchAppRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps",
        renamed: ["repos", "removeAppAccessRestrictions"]
      }],
      removeProtectedBranchPullRequestReviewEnforcement: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews", {}, {
        renamed: ["repos", "deletePullRequestReviewProtection"]
      }],
      removeProtectedBranchRequiredSignatures: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures", {
        mediaType: {
          previews: ["zzzax"]
        }
      }, {
        renamed: ["repos", "deleteCommitSignatureProtection"]
      }],
      removeProtectedBranchRequiredStatusChecks: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, {
        renamed: ["repos", "removeStatusChecksProtection"]
      }],
      removeProtectedBranchRequiredStatusChecksContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts",
        renamed: ["repos", "removeStatusCheckContexts"]
      }],
      removeProtectedBranchRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions", {}, {
        renamed: ["repos", "deleteAccessRestrictions"]
      }],
      removeProtectedBranchTeamRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams",
        renamed: ["repos", "removeTeamAccessRestrictions"]
      }],
      removeProtectedBranchUserRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users",
        renamed: ["repos", "removeUserAccessRestrictions"]
      }],
      removeStatusCheckContexts: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      removeStatusCheckProtection: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      removeTeamAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      removeUserAccessRestrictions: ["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      replaceAllTopics: ["PUT /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }],
      replaceProtectedBranchAppRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps",
        renamed: ["repos", "setAppAccessRestrictions"]
      }],
      replaceProtectedBranchRequiredStatusChecksContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts",
        renamed: ["repos", "setStatusCheckContexts"]
      }],
      replaceProtectedBranchTeamRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams",
        renamed: ["repos", "setTeamAccessRestrictions"]
      }],
      replaceProtectedBranchUserRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users",
        renamed: ["repos", "setUserAccessRestrictions"]
      }],
      replaceTopics: ["PUT /repos/{owner}/{repo}/topics", {
        mediaType: {
          previews: ["mercy"]
        }
      }, {
        renamed: ["repos", "replaceAllTopics"]
      }],
      requestPageBuild: ["POST /repos/{owner}/{repo}/pages/builds", {}, {
        renamed: ["repos", "requestPagesBuild"]
      }],
      requestPagesBuild: ["POST /repos/{owner}/{repo}/pages/builds"],
      retrieveCommunityProfileMetrics: ["GET /repos/{owner}/{repo}/community/profile", {}, {
        renamed: ["repos", "getCommunityProfileMetrics"]
      }],
      setAdminBranchProtection: ["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],
      setAppAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps", {}, {
        mapToData: "apps"
      }],
      setStatusCheckContexts: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts", {}, {
        mapToData: "contexts"
      }],
      setTeamAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams", {}, {
        mapToData: "teams"
      }],
      setUserAccessRestrictions: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users", {}, {
        mapToData: "users"
      }],
      testPushHook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests", {}, {
        renamed: ["repos", "testPushWebhook"]
      }],
      testPushWebhook: ["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],
      transfer: ["POST /repos/{owner}/{repo}/transfer"],
      update: ["PATCH /repos/{owner}/{repo}"],
      updateBranchProtection: ["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],
      updateCommitComment: ["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],
      updateHook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}", {}, {
        renamed: ["repos", "updateWebhook"]
      }],
      updateInformationAboutPagesSite: ["PUT /repos/{owner}/{repo}/pages"],
      updateInvitation: ["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],
      updateProtectedBranchPullRequestReviewEnforcement: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews", {}, {
        renamed: ["repos", "updatePullRequestReviewProtection"]
      }],
      updateProtectedBranchRequiredStatusChecks: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks", {}, {
        renamed: ["repos", "updateStatusChecksProtection"]
      }],
      updatePullRequestReviewProtection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],
      updateRelease: ["PATCH /repos/{owner}/{repo}/releases/{release_id}"],
      updateReleaseAsset: ["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],
      updateStatusCheckPotection: ["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],
      updateWebhook: ["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],
      uploadReleaseAsset: ["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}", {
        baseUrl: "https://uploads.github.com"
      }]
    },
    search: {
      code: ["GET /search/code"],
      commits: ["GET /search/commits", {
        mediaType: {
          previews: ["cloak"]
        }
      }],
      issuesAndPullRequests: ["GET /search/issues"],
      labels: ["GET /search/labels"],
      repos: ["GET /search/repositories"],
      topics: ["GET /search/topics"],
      users: ["GET /search/users"]
    },
    teams: {
      addOrUpdateMembershipForUserInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      addOrUpdateMembershipInOrg: ["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}", {}, {
        renamed: ["teams", "addOrUpdateMembershipForUserInOrg"]
      }],
      addOrUpdateProjectInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }, {
        renamed: ["teams", "addOrUpdateProjectPermissionsInOrg"]
      }],
      addOrUpdateProjectPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      addOrUpdateRepoInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}", {}, {
        renamed: ["teams", "addOrUpdateRepoPermissionsInOrg"]
      }],
      addOrUpdateRepoPermissionsInOrg: ["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      checkManagesRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}", {}, {
        renamed: ["teams", "checkPermissionsForRepoInOrg"]
      }],
      checkPermissionsForProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      checkPermissionsForRepoInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      create: ["POST /orgs/{org}/teams"],
      createDiscussionCommentInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
      createDiscussionInOrg: ["POST /orgs/{org}/teams/{team_slug}/discussions"],
      deleteDiscussionCommentInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      deleteDiscussionInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      deleteInOrg: ["DELETE /orgs/{org}/teams/{team_slug}"],
      getByName: ["GET /orgs/{org}/teams/{team_slug}"],
      getDiscussionCommentInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      getDiscussionInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      getMembershipForUserInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      getMembershipInOrg: ["GET /orgs/{org}/teams/{team_slug}/memberships/{username}", {}, {
        renamed: ["teams", "getMembershipForUserInOrg"]
      }],
      list: ["GET /orgs/{org}/teams"],
      listChildInOrg: ["GET /orgs/{org}/teams/{team_slug}/teams"],
      listDiscussionCommentsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],
      listDiscussionsInOrg: ["GET /orgs/{org}/teams/{team_slug}/discussions"],
      listForAuthenticatedUser: ["GET /user/teams"],
      listMembersInOrg: ["GET /orgs/{org}/teams/{team_slug}/members"],
      listPendingInvitationsInOrg: ["GET /orgs/{org}/teams/{team_slug}/invitations"],
      listProjectsInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects", {
        mediaType: {
          previews: ["inertia"]
        }
      }],
      listReposInOrg: ["GET /orgs/{org}/teams/{team_slug}/repos"],
      removeMembershipForUserInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],
      removeMembershipInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}", {}, {
        renamed: ["teams", "removeMembershipForUserInOrg"]
      }],
      removeProjectInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/projects/{project_id}"],
      removeRepoInOrg: ["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],
      reviewProjectInOrg: ["GET /orgs/{org}/teams/{team_slug}/projects/{project_id}", {
        mediaType: {
          previews: ["inertia"]
        }
      }, {
        renamed: ["teams", "checkPermissionsForProjectInOrg"]
      }],
      updateDiscussionCommentInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],
      updateDiscussionInOrg: ["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],
      updateInOrg: ["PATCH /orgs/{org}/teams/{team_slug}"]
    },
    users: {
      addEmailForAuthenticated: ["POST /user/emails"],
      addEmails: ["POST /user/emails", {}, {
        renamed: ["users", "addEmailsForAuthenticated"]
      }],
      block: ["PUT /user/blocks/{username}"],
      checkBlocked: ["GET /user/blocks/{username}"],
      checkFollowing: ["GET /user/following/{username}", {}, {
        renamed: ["users", "checkPersonIsFollowedByAuthenticated"]
      }],
      checkFollowingForUser: ["GET /users/{username}/following/{target_user}"],
      checkPersonIsFollowedByAuthenticated: ["GET /user/following/{username}"],
      createGpgKey: ["POST /user/gpg_keys", {}, {
        renamed: ["users", "createGpgKeyForAuthenticated"]
      }],
      createGpgKeyForAuthenticated: ["POST /user/gpg_keys"],
      createPublicKey: ["POST /user/keys", {}, {
        renamed: ["users", "createPublicSshKeyForAuthenticated"]
      }],
      createPublicSshKeyForAuthenticated: ["POST /user/keys"],
      deleteEmailForAuthenticated: ["DELETE /user/emails"],
      deleteEmails: ["DELETE /user/emails", {}, {
        renamed: ["users", "deleteEmailsForAuthenticated"]
      }],
      deleteGpgKey: ["DELETE /user/gpg_keys/{gpg_key_id}", {}, {
        renamed: ["users", "deleteGpgKeyForAuthenticated"]
      }],
      deleteGpgKeyForAuthenticated: ["DELETE /user/gpg_keys/{gpg_key_id}"],
      deletePublicKey: ["DELETE /user/keys/{key_id}", {}, {
        renamed: ["users", "deletePublicSshKeyForAuthenticated"]
      }],
      deletePublicSshKeyForAuthenticated: ["DELETE /user/keys/{key_id}"],
      follow: ["PUT /user/following/{username}"],
      getAuthenticated: ["GET /user"],
      getByUsername: ["GET /users/{username}"],
      getContextForUser: ["GET /users/{username}/hovercard"],
      getGpgKey: ["GET /user/gpg_keys/{gpg_key_id}", {}, {
        renamed: ["users", "getGpgKeyForAuthenticated"]
      }],
      getGpgKeyForAuthenticated: ["GET /user/gpg_keys/{gpg_key_id}"],
      getPublicKey: ["GET /user/keys/{key_id}", {}, {
        renamed: ["users", "getPublicSshKeyForAuthenticated"]
      }],
      getPublicSshKeyForAuthenticated: ["GET /user/keys/{key_id}"],
      list: ["GET /users"],
      listBlocked: ["GET /user/blocks", {}, {
        renamed: ["users", "listBlockedByAuthenticated"]
      }],
      listBlockedByAuthenticated: ["GET /user/blocks"],
      listEmails: ["GET /user/emails", {}, {
        renamed: ["users", "listEmailsForAuthenticated"]
      }],
      listEmailsForAuthenticated: ["GET /user/emails"],
      listFollowedByAuthenticated: ["GET /user/following"],
      listFollowersForAuthenticatedUser: ["GET /user/followers"],
      listFollowersForUser: ["GET /users/{username}/followers"],
      listFollowingForAuthenticatedUser: ["GET /user/following", {}, {
        renamed: ["users", "listFollowedByAuthenticated"]
      }],
      listFollowingForUser: ["GET /users/{username}/following"],
      listGpgKeys: ["GET /user/gpg_keys", {}, {
        renamed: ["users", "listGpgKeysForAuthenticated"]
      }],
      listGpgKeysForAuthenticated: ["GET /user/gpg_keys"],
      listGpgKeysForUser: ["GET /users/{username}/gpg_keys"],
      listPublicEmails: ["GET /user/public_emails", {}, {
        renamed: ["users", "listPublicEmailsForAuthenticatedUser"]
      }],
      listPublicEmailsForAuthenticated: ["GET /user/public_emails"],
      listPublicKeys: ["GET /user/keys", {}, {
        renamed: ["users", "listPublicSshKeysForAuthenticated"]
      }],
      listPublicKeysForUser: ["GET /users/{username}/keys"],
      listPublicSshKeysForAuthenticated: ["GET /user/keys"],
      setPrimaryEmailVisibilityForAuthenticated: ["PATCH /user/email/visibility"],
      togglePrimaryEmailVisibility: ["PATCH /user/email/visibility", {}, {
        renamed: ["users", "setPrimaryEmailVisibilityForAuthenticated"]
      }],
      unblock: ["DELETE /user/blocks/{username}"],
      unfollow: ["DELETE /user/following/{username}"],
      updateAuthenticated: ["PATCH /user"]
    }
  };
  
  const VERSION = "3.17.0";
  
  function endpointsToMethods(octokit, endpointsMap) {
    const newMethods = {};
  
    for (const [scope, endpoints] of Object.entries(endpointsMap)) {
      for (const [methodName, endpoint] of Object.entries(endpoints)) {
        const [route, defaults, decorations] = endpoint;
        const [method, url] = route.split(/ /);
        const endpointDefaults = Object.assign({
          method,
          url
        }, defaults);
  
        if (!newMethods[scope]) {
          newMethods[scope] = {};
        }
  
        const scopeMethods = newMethods[scope];
  
        if (decorations) {
          scopeMethods[methodName] = decorate(octokit, scope, methodName, endpointDefaults, decorations);
          continue;
        }
  
        scopeMethods[methodName] = octokit.request.defaults(endpointDefaults);
      }
    }
  
    return newMethods;
  }
  
  function decorate(octokit, scope, methodName, defaults, decorations) {
    const requestWithDefaults = octokit.request.defaults(defaults);
  
    function withDecorations(...args) {
      // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
      let options = requestWithDefaults.endpoint.merge(...args); // There are currently no other decorations than `.mapToData`
  
      if (decorations.mapToData) {
        options = Object.assign({}, options, {
          data: options[decorations.mapToData],
          [decorations.mapToData]: undefined
        });
        return requestWithDefaults(options);
      } // NOTE: there are currently no deprecations. But we keep the code
      //       below for future reference
  
  
      if (decorations.renamed) {
        const [newScope, newMethodName] = decorations.renamed;
        octokit.log.warn(`octokit.${scope}.${methodName}() has been renamed to octokit.${newScope}.${newMethodName}()`);
      }
  
      if (decorations.deprecated) {
        octokit.log.warn(decorations.deprecated);
      }
  
      if (decorations.renamedParameters) {
        // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
        const options = requestWithDefaults.endpoint.merge(...args);
  
        for (const [name, alias] of Object.entries(decorations.renamedParameters)) {
          // There is currently no deprecated parameter that is optional,
          // so we never hit the else branch below at this point.
  
          /* istanbul ignore else */
          if (name in options) {
            octokit.log.warn(`"${name}" parameter is deprecated for "octokit.${scope}.${methodName}()". Use "${alias}" instead`);
  
            if (!(alias in options)) {
              options[alias] = options[name];
            }
  
            delete options[name];
          }
        }
  
        return requestWithDefaults(options);
      } // @ts-ignore https://github.com/microsoft/TypeScript/issues/25488
  
  
      return requestWithDefaults(...args);
    }
  
    return Object.assign(withDecorations, requestWithDefaults);
  }
  
  /**
   * This plugin is a 1:1 copy of internal @octokit/rest plugins. The primary
   * goal is to rebuild @octokit/rest on top of @octokit/core. Once that is
   * done, we will remove the registerEndpoints methods and return the methods
   * directly as with the other plugins. At that point we will also remove the
   * legacy workarounds and deprecations.
   *
   * See the plan at
   * https://github.com/octokit/plugin-rest-endpoint-methods.js/pull/1
   */
  
  function restEndpointMethods(octokit) {
    return endpointsToMethods(octokit, Endpoints);
  }
  restEndpointMethods.VERSION = VERSION;
  
  exports.restEndpointMethods = restEndpointMethods;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 843 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Makes an ascending comparator function out of a function that returns a value
   * that can be compared with `<` and `>`.
   *
   * @func
   * @memberOf R
   * @since v0.23.0
   * @category Function
   * @sig Ord b => (a -> b) -> a -> a -> Number
   * @param {Function} fn A function of arity one that returns a value that can be compared
   * @param {*} a The first item to be compared.
   * @param {*} b The second item to be compared.
   * @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0`
   * @see R.descend
   * @example
   *
   *      const byAge = R.ascend(R.prop('age'));
   *      const people = [
   *        { name: 'Emma', age: 70 },
   *        { name: 'Peter', age: 78 },
   *        { name: 'Mikhail', age: 62 },
   *      ];
   *      const peopleByYoungestFirst = R.sort(byAge, people);
   *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]
   */
  
  
  var ascend =
  /*#__PURE__*/
  _curry3(function ascend(fn, a, b) {
    var aa = fn(a);
    var bb = fn(b);
    return aa < bb ? -1 : aa > bb ? 1 : 0;
  });
  
  module.exports = ascend;
  
  /***/ }),
  /* 844 */,
  /* 845 */,
  /* 846 */,
  /* 847 */,
  /* 848 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  /**
   * Returns a value wrapped to indicate that it is the final value of the reduce
   * and transduce functions. The returned value should be considered a black
   * box: the internal structure is not guaranteed to be stable.
   *
   * Note: this optimization is only available to the below functions:
   * - [`reduce`](#reduce)
   * - [`reduceWhile`](#reduceWhile)
   * - [`transduce`](#transduce)
   *
   * @func
   * @memberOf R
   * @since v0.15.0
   * @category List
   * @sig a -> *
   * @param {*} x The final value of the reduce.
   * @return {*} The wrapped value.
   * @see R.reduce, R.reduceWhile, R.transduce
   * @example
   *
   *     R.reduce(
   *       (acc, item) => item > 3 ? R.reduced(acc) : acc.concat(item),
   *       [],
   *       [1, 2, 3, 4, 5]) // [1, 2, 3]
   */
  
  
  var reduced =
  /*#__PURE__*/
  _curry1(_reduced);
  
  module.exports = reduced;
  
  /***/ }),
  /* 849 */,
  /* 850 */,
  /* 851 */,
  /* 852 */,
  /* 853 */
  /***/ (function(module) {
  
  module.exports = require("util");
  
  /***/ }),
  /* 854 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _toString =
  /*#__PURE__*/
  __webpack_require__(203);
  /**
   * Returns the string representation of the given value. `eval`'ing the output
   * should result in a value equivalent to the input value. Many of the built-in
   * `toString` methods do not satisfy this requirement.
   *
   * If the given value is an `[object Object]` with a `toString` method other
   * than `Object.prototype.toString`, this method is invoked with no arguments
   * to produce the return value. This means user-defined constructor functions
   * can provide a suitable `toString` method. For example:
   *
   *     function Point(x, y) {
   *       this.x = x;
   *       this.y = y;
   *     }
   *
   *     Point.prototype.toString = function() {
   *       return 'new Point(' + this.x + ', ' + this.y + ')';
   *     };
   *
   *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category String
   * @sig * -> String
   * @param {*} val
   * @return {String}
   * @example
   *
   *      R.toString(42); //=> '42'
   *      R.toString('abc'); //=> '"abc"'
   *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'
   *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
   *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
   */
  
  
  var toString =
  /*#__PURE__*/
  _curry1(function toString(val) {
    return _toString(val, []);
  });
  
  module.exports = toString;
  
  /***/ }),
  /* 855 */,
  /* 856 */,
  /* 857 */,
  /* 858 */,
  /* 859 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _filter =
  /*#__PURE__*/
  __webpack_require__(695);
  
  var flip =
  /*#__PURE__*/
  __webpack_require__(328);
  
  var uniq =
  /*#__PURE__*/
  __webpack_require__(732);
  /**
   * Combines two lists into a set (i.e. no duplicates) composed of those
   * elements common to both lists.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig [*] -> [*] -> [*]
   * @param {Array} list1 The first list.
   * @param {Array} list2 The second list.
   * @return {Array} The list of elements found in both `list1` and `list2`.
   * @see R.innerJoin
   * @example
   *
   *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]
   */
  
  
  var intersection =
  /*#__PURE__*/
  _curry2(function intersection(list1, list2) {
    var lookupList, filteredList;
  
    if (list1.length > list2.length) {
      lookupList = list1;
      filteredList = list2;
    } else {
      lookupList = list2;
      filteredList = list1;
    }
  
    return uniq(_filter(flip(_includes)(lookupList), filteredList));
  });
  
  module.exports = intersection;
  
  /***/ }),
  /* 860 */,
  /* 861 */,
  /* 862 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xfind =
  /*#__PURE__*/
  __webpack_require__(966);
  /**
   * Returns the first element of the list which matches the predicate, or
   * `undefined` if no element matches.
   *
   * Dispatches to the `find` method of the second argument, if present.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig (a -> Boolean) -> [a] -> a | undefined
   * @param {Function} fn The predicate function used to determine if the element is the
   *        desired one.
   * @param {Array} list The array to consider.
   * @return {Object} The element found, or `undefined`.
   * @see R.transduce
   * @example
   *
   *      const xs = [{a: 1}, {a: 2}, {a: 3}];
   *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}
   *      R.find(R.propEq('a', 4))(xs); //=> undefined
   */
  
  
  var find =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable(['find'], _xfind, function find(fn, list) {
    var idx = 0;
    var len = list.length;
  
    while (idx < len) {
      if (fn(list[idx])) {
        return list[idx];
      }
  
      idx += 1;
    }
  }));
  
  module.exports = find;
  
  /***/ }),
  /* 863 */,
  /* 864 */,
  /* 865 */,
  /* 866 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var map =
  /*#__PURE__*/
  __webpack_require__(523);
  
  var sequence =
  /*#__PURE__*/
  __webpack_require__(827);
  /**
   * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning
   * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),
   * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative
   * into an Applicative of Traversable.
   *
   * Dispatches to the `traverse` method of the third argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)
   * @param {Function} of
   * @param {Function} f
   * @param {*} traversable
   * @return {*}
   * @see R.sequence
   * @example
   *
   *      // Returns `Maybe.Nothing` if the given divisor is `0`
   *      const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)
   *
   *      R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2])
   *      R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing
   */
  
  
  var traverse =
  /*#__PURE__*/
  _curry3(function traverse(of, f, traversable) {
    return typeof traversable['fantasy-land/traverse'] === 'function' ? traversable['fantasy-land/traverse'](f, of) : sequence(of, map(f, traversable));
  });
  
  module.exports = traverse;
  
  /***/ }),
  /* 867 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns the second argument if it is not `null`, `undefined` or `NaN`;
   * otherwise the first argument is returned.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Logic
   * @sig a -> b -> a | b
   * @param {a} default The default value.
   * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.
   * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value
   * @example
   *
   *      const defaultTo42 = R.defaultTo(42);
   *
   *      defaultTo42(null);  //=> 42
   *      defaultTo42(undefined);  //=> 42
   *      defaultTo42(false);  //=> false
   *      defaultTo42('Ramda');  //=> 'Ramda'
   *      // parseInt('string') results in NaN
   *      defaultTo42(parseInt('string')); //=> 42
   */
  
  
  var defaultTo =
  /*#__PURE__*/
  _curry2(function defaultTo(d, v) {
    return v == null || v !== v ? d : v;
  });
  
  module.exports = defaultTo;
  
  /***/ }),
  /* 868 */,
  /* 869 */,
  /* 870 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isArrayLike =
  /*#__PURE__*/
  __webpack_require__(260);
  
  var _xwrap =
  /*#__PURE__*/
  __webpack_require__(43);
  
  var bind =
  /*#__PURE__*/
  __webpack_require__(269);
  
  function _arrayReduce(xf, acc, list) {
    var idx = 0;
    var len = list.length;
  
    while (idx < len) {
      acc = xf['@@transducer/step'](acc, list[idx]);
  
      if (acc && acc['@@transducer/reduced']) {
        acc = acc['@@transducer/value'];
        break;
      }
  
      idx += 1;
    }
  
    return xf['@@transducer/result'](acc);
  }
  
  function _iterableReduce(xf, acc, iter) {
    var step = iter.next();
  
    while (!step.done) {
      acc = xf['@@transducer/step'](acc, step.value);
  
      if (acc && acc['@@transducer/reduced']) {
        acc = acc['@@transducer/value'];
        break;
      }
  
      step = iter.next();
    }
  
    return xf['@@transducer/result'](acc);
  }
  
  function _methodReduce(xf, acc, obj, methodName) {
    return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));
  }
  
  var symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';
  
  function _reduce(fn, acc, list) {
    if (typeof fn === 'function') {
      fn = _xwrap(fn);
    }
  
    if (_isArrayLike(list)) {
      return _arrayReduce(fn, acc, list);
    }
  
    if (typeof list['fantasy-land/reduce'] === 'function') {
      return _methodReduce(fn, acc, list, 'fantasy-land/reduce');
    }
  
    if (list[symIterator] != null) {
      return _iterableReduce(fn, acc, list[symIterator]());
    }
  
    if (typeof list.next === 'function') {
      return _iterableReduce(fn, acc, list);
    }
  
    if (typeof list.reduce === 'function') {
      return _methodReduce(fn, acc, list, 'reduce');
    }
  
    throw new TypeError('reduce: list must be array or iterable');
  }
  
  module.exports = _reduce;
  
  /***/ }),
  /* 871 */,
  /* 872 */,
  /* 873 */,
  /* 874 */,
  /* 875 */,
  /* 876 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XAny =
  /*#__PURE__*/
  function () {
    function XAny(f, xf) {
      this.xf = xf;
      this.f = f;
      this.any = false;
    }
  
    XAny.prototype['@@transducer/init'] = _xfBase.init;
  
    XAny.prototype['@@transducer/result'] = function (result) {
      if (!this.any) {
        result = this.xf['@@transducer/step'](result, false);
      }
  
      return this.xf['@@transducer/result'](result);
    };
  
    XAny.prototype['@@transducer/step'] = function (result, input) {
      if (this.f(input)) {
        this.any = true;
        result = _reduced(this.xf['@@transducer/step'](result, true));
      }
  
      return result;
    };
  
    return XAny;
  }();
  
  var _xany =
  /*#__PURE__*/
  _curry2(function _xany(f, xf) {
    return new XAny(f, xf);
  });
  
  module.exports = _xany;
  
  /***/ }),
  /* 877 */,
  /* 878 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _includes =
  /*#__PURE__*/
  __webpack_require__(216);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns `true` if the specified value is equal, in [`R.equals`](#equals)
   * terms, to at least one element of the given list; `false` otherwise.
   * Works also with strings.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category List
   * @sig a -> [a] -> Boolean
   * @param {Object} a The item to compare against.
   * @param {Array} list The array to consider.
   * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.
   * @see R.includes
   * @deprecated since v0.26.0
   * @example
   *
   *      R.contains(3, [1, 2, 3]); //=> true
   *      R.contains(4, [1, 2, 3]); //=> false
   *      R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true
   *      R.contains([42], [[42]]); //=> true
   *      R.contains('ba', 'banana'); //=>true
   */
  
  
  var contains =
  /*#__PURE__*/
  _curry2(_includes);
  
  module.exports = contains;
  
  /***/ }),
  /* 879 */,
  /* 880 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Multiplies two numbers. Equivalent to `a * b` but curried.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} a The first value.
   * @param {Number} b The second value.
   * @return {Number} The result of `a * b`.
   * @see R.divide
   * @example
   *
   *      const double = R.multiply(2);
   *      const triple = R.multiply(3);
   *      double(3);       //=>  6
   *      triple(4);       //=> 12
   *      R.multiply(2, 5);  //=> 10
   */
  
  
  var multiply =
  /*#__PURE__*/
  _curry2(function multiply(a, b) {
    return a * b;
  });
  
  module.exports = multiply;
  
  /***/ }),
  /* 881 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var adjust =
  /*#__PURE__*/
  __webpack_require__(908);
  
  var always =
  /*#__PURE__*/
  __webpack_require__(657);
  /**
   * Returns a new copy of the array with the element at the provided index
   * replaced with the given value.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category List
   * @sig Number -> a -> [a] -> [a]
   * @param {Number} idx The index to update.
   * @param {*} x The value to exist at the given index of the returned array.
   * @param {Array|Arguments} list The source array-like object to be updated.
   * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.
   * @see R.adjust
   * @example
   *
   *      R.update(1, '_', ['a', 'b', 'c']);      //=> ['a', '_', 'c']
   *      R.update(-1, '_', ['a', 'b', 'c']);     //=> ['a', 'b', '_']
   * @symb R.update(-1, a, [b, c]) = [b, a]
   * @symb R.update(0, a, [b, c]) = [a, c]
   * @symb R.update(1, a, [b, c]) = [b, a]
   */
  
  
  var update =
  /*#__PURE__*/
  _curry3(function update(idx, x, list) {
    return adjust(idx, always(x), list);
  });
  
  module.exports = update;
  
  /***/ }),
  /* 882 */,
  /* 883 */,
  /* 884 */,
  /* 885 */
  /***/ (function(module) {
  
  function _functionName(f) {
    // String(x => x) evaluates to "x => x", so the pattern may not match.
    var match = String(f).match(/^function (\w*)/);
    return match == null ? '' : match[1];
  }
  
  module.exports = _functionName;
  
  /***/ }),
  /* 886 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _map =
  /*#__PURE__*/
  __webpack_require__(626);
  
  var curryN =
  /*#__PURE__*/
  __webpack_require__(535);
  
  var max =
  /*#__PURE__*/
  __webpack_require__(793);
  
  var pluck =
  /*#__PURE__*/
  __webpack_require__(819);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  /**
   * Accepts a converging function and a list of branching functions and returns
   * a new function. The arity of the new function is the same as the arity of
   * the longest branching function. When invoked, this new function is applied
   * to some arguments, and each branching function is applied to those same
   * arguments. The results of each branching function are passed as arguments
   * to the converging function to produce the return value.
   *
   * @func
   * @memberOf R
   * @since v0.4.2
   * @category Function
   * @sig ((x1, x2, ...) -> z) -> [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> (a -> b -> ... -> z)
   * @param {Function} after A function. `after` will be invoked with the return values of
   *        `fn1` and `fn2` as its arguments.
   * @param {Array} functions A list of functions.
   * @return {Function} A new function.
   * @see R.useWith
   * @example
   *
   *      const average = R.converge(R.divide, [R.sum, R.length])
   *      average([1, 2, 3, 4, 5, 6, 7]) //=> 4
   *
   *      const strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])
   *      strangeConcat("Yodel") //=> "YODELyodel"
   *
   * @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b))
   */
  
  
  var converge =
  /*#__PURE__*/
  _curry2(function converge(after, fns) {
    return curryN(reduce(max, 0, pluck('length', fns)), function () {
      var args = arguments;
      var context = this;
      return after.apply(context, _map(function (fn) {
        return fn.apply(context, args);
      }, fns));
    });
  });
  
  module.exports = converge;
  
  /***/ }),
  /* 887 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a new object by recursively evolving a shallow copy of `object`,
   * according to the `transformation` functions. All non-primitive properties
   * are copied by reference.
   *
   * A `transformation` function will not be invoked if its corresponding key
   * does not exist in the evolved object.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Object
   * @sig {k: (v -> v)} -> {k: v} -> {k: v}
   * @param {Object} transformations The object specifying transformation functions to apply
   *        to the object.
   * @param {Object} object The object to be transformed.
   * @return {Object} The transformed object.
   * @example
   *
   *      const tomato = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};
   *      const transformations = {
   *        firstName: R.trim,
   *        lastName: R.trim, // Will not get invoked.
   *        data: {elapsed: R.add(1), remaining: R.add(-1)}
   *      };
   *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}
   */
  
  
  var evolve =
  /*#__PURE__*/
  _curry2(function evolve(transformations, object) {
    var result = object instanceof Array ? [] : {};
    var transformation, key, type;
  
    for (key in object) {
      transformation = transformations[key];
      type = typeof transformation;
      result[key] = type === 'function' ? transformation(object[key]) : transformation && type === 'object' ? evolve(transformation, object[key]) : object[key];
    }
  
    return result;
  });
  
  module.exports = evolve;
  
  /***/ }),
  /* 888 */,
  /* 889 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _clone =
  /*#__PURE__*/
  __webpack_require__(794);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var _isTransformer =
  /*#__PURE__*/
  __webpack_require__(700);
  
  var _reduce =
  /*#__PURE__*/
  __webpack_require__(870);
  
  var _stepCat =
  /*#__PURE__*/
  __webpack_require__(438);
  /**
   * Transforms the items of the list with the transducer and appends the
   * transformed items to the accumulator using an appropriate iterator function
   * based on the accumulator type.
   *
   * The accumulator can be an array, string, object or a transformer. Iterated
   * items will be appended to arrays and concatenated to strings. Objects will
   * be merged directly or 2-item arrays will be merged as key, value pairs.
   *
   * The accumulator can also be a transformer object that provides a 2-arity
   * reducing iterator function, step, 0-arity initial value function, init, and
   * 1-arity result extraction function result. The step function is used as the
   * iterator function in reduce. The result function is used to convert the
   * final accumulator into the return type and in most cases is R.identity. The
   * init function is used to provide the initial accumulator.
   *
   * The iteration is performed with [`R.reduce`](#reduce) after initializing the
   * transducer.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category List
   * @sig a -> (b -> b) -> [c] -> a
   * @param {*} acc The initial accumulator value.
   * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
   * @param {Array} list The list to iterate over.
   * @return {*} The final, accumulated value.
   * @see R.transduce
   * @example
   *
   *      const numbers = [1, 2, 3, 4];
   *      const transducer = R.compose(R.map(R.add(1)), R.take(2));
   *
   *      R.into([], transducer, numbers); //=> [2, 3]
   *
   *      const intoArray = R.into([]);
   *      intoArray(transducer, numbers); //=> [2, 3]
   */
  
  
  var into =
  /*#__PURE__*/
  _curry3(function into(acc, xf, list) {
    return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);
  });
  
  module.exports = into;
  
  /***/ }),
  /* 890 */,
  /* 891 */,
  /* 892 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var isPlainObject = __webpack_require__(3);
  var universalUserAgent = __webpack_require__(40);
  
  function lowercaseKeys(object) {
    if (!object) {
      return {};
    }
  
    return Object.keys(object).reduce((newObj, key) => {
      newObj[key.toLowerCase()] = object[key];
      return newObj;
    }, {});
  }
  
  function mergeDeep(defaults, options) {
    const result = Object.assign({}, defaults);
    Object.keys(options).forEach(key => {
      if (isPlainObject.isPlainObject(options[key])) {
        if (!(key in defaults)) Object.assign(result, {
          [key]: options[key]
        });else result[key] = mergeDeep(defaults[key], options[key]);
      } else {
        Object.assign(result, {
          [key]: options[key]
        });
      }
    });
    return result;
  }
  
  function removeUndefinedProperties(obj) {
    for (const key in obj) {
      if (obj[key] === undefined) {
        delete obj[key];
      }
    }
  
    return obj;
  }
  
  function merge(defaults, route, options) {
    if (typeof route === "string") {
      let [method, url] = route.split(" ");
      options = Object.assign(url ? {
        method,
        url
      } : {
        url: method
      }, options);
    } else {
      options = Object.assign({}, route);
    } // lowercase header names before merging with defaults to avoid duplicates
  
  
    options.headers = lowercaseKeys(options.headers); // remove properties with undefined values before merging
  
    removeUndefinedProperties(options);
    removeUndefinedProperties(options.headers);
    const mergedOptions = mergeDeep(defaults || {}, options); // mediaType.previews arrays are merged, instead of overwritten
  
    if (defaults && defaults.mediaType.previews.length) {
      mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(preview => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
    }
  
    mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map(preview => preview.replace(/-preview/, ""));
    return mergedOptions;
  }
  
  function addQueryParameters(url, parameters) {
    const separator = /\?/.test(url) ? "&" : "?";
    const names = Object.keys(parameters);
  
    if (names.length === 0) {
      return url;
    }
  
    return url + separator + names.map(name => {
      if (name === "q") {
        return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
      }
  
      return `${name}=${encodeURIComponent(parameters[name])}`;
    }).join("&");
  }
  
  const urlVariableRegex = /\{[^}]+\}/g;
  
  function removeNonChars(variableName) {
    return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
  }
  
  function extractUrlVariableNames(url) {
    const matches = url.match(urlVariableRegex);
  
    if (!matches) {
      return [];
    }
  
    return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
  }
  
  function omit(object, keysToOmit) {
    return Object.keys(object).filter(option => !keysToOmit.includes(option)).reduce((obj, key) => {
      obj[key] = object[key];
      return obj;
    }, {});
  }
  
  // Based on https://github.com/bramstein/url-template, licensed under BSD
  // TODO: create separate package.
  //
  // Copyright (c) 2012-2014, Bram Stein
  // 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. The name of the author may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  // THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 OWNER 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.
  
  /* istanbul ignore file */
  function encodeReserved(str) {
    return str.split(/(%[0-9A-Fa-f]{2})/g).map(function (part) {
      if (!/%[0-9A-Fa-f]/.test(part)) {
        part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
      }
  
      return part;
    }).join("");
  }
  
  function encodeUnreserved(str) {
    return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
      return "%" + c.charCodeAt(0).toString(16).toUpperCase();
    });
  }
  
  function encodeValue(operator, value, key) {
    value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
  
    if (key) {
      return encodeUnreserved(key) + "=" + value;
    } else {
      return value;
    }
  }
  
  function isDefined(value) {
    return value !== undefined && value !== null;
  }
  
  function isKeyOperator(operator) {
    return operator === ";" || operator === "&" || operator === "?";
  }
  
  function getValues(context, operator, key, modifier) {
    var value = context[key],
        result = [];
  
    if (isDefined(value) && value !== "") {
      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
        value = value.toString();
  
        if (modifier && modifier !== "*") {
          value = value.substring(0, parseInt(modifier, 10));
        }
  
        result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
      } else {
        if (modifier === "*") {
          if (Array.isArray(value)) {
            value.filter(isDefined).forEach(function (value) {
              result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
            });
          } else {
            Object.keys(value).forEach(function (k) {
              if (isDefined(value[k])) {
                result.push(encodeValue(operator, value[k], k));
              }
            });
          }
        } else {
          const tmp = [];
  
          if (Array.isArray(value)) {
            value.filter(isDefined).forEach(function (value) {
              tmp.push(encodeValue(operator, value));
            });
          } else {
            Object.keys(value).forEach(function (k) {
              if (isDefined(value[k])) {
                tmp.push(encodeUnreserved(k));
                tmp.push(encodeValue(operator, value[k].toString()));
              }
            });
          }
  
          if (isKeyOperator(operator)) {
            result.push(encodeUnreserved(key) + "=" + tmp.join(","));
          } else if (tmp.length !== 0) {
            result.push(tmp.join(","));
          }
        }
      }
    } else {
      if (operator === ";") {
        if (isDefined(value)) {
          result.push(encodeUnreserved(key));
        }
      } else if (value === "" && (operator === "&" || operator === "?")) {
        result.push(encodeUnreserved(key) + "=");
      } else if (value === "") {
        result.push("");
      }
    }
  
    return result;
  }
  
  function parseUrl(template) {
    return {
      expand: expand.bind(null, template)
    };
  }
  
  function expand(template, context) {
    var operators = ["+", "#", ".", "/", ";", "?", "&"];
    return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
      if (expression) {
        let operator = "";
        const values = [];
  
        if (operators.indexOf(expression.charAt(0)) !== -1) {
          operator = expression.charAt(0);
          expression = expression.substr(1);
        }
  
        expression.split(/,/g).forEach(function (variable) {
          var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
          values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
        });
  
        if (operator && operator !== "+") {
          var separator = ",";
  
          if (operator === "?") {
            separator = "&";
          } else if (operator !== "#") {
            separator = operator;
          }
  
          return (values.length !== 0 ? operator : "") + values.join(separator);
        } else {
          return values.join(",");
        }
      } else {
        return encodeReserved(literal);
      }
    });
  }
  
  function parse(options) {
    // https://fetch.spec.whatwg.org/#methods
    let method = options.method.toUpperCase(); // replace :varname with {varname} to make it RFC 6570 compatible
  
    let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
    let headers = Object.assign({}, options.headers);
    let body;
    let parameters = omit(options, ["method", "baseUrl", "url", "headers", "request", "mediaType"]); // extract variable names from URL to calculate remaining variables later
  
    const urlVariableNames = extractUrlVariableNames(url);
    url = parseUrl(url).expand(parameters);
  
    if (!/^http/.test(url)) {
      url = options.baseUrl + url;
    }
  
    const omittedParameters = Object.keys(options).filter(option => urlVariableNames.includes(option)).concat("baseUrl");
    const remainingParameters = omit(parameters, omittedParameters);
    const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
  
    if (!isBinaryRequest) {
      if (options.mediaType.format) {
        // e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
        headers.accept = headers.accept.split(/,/).map(preview => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
      }
  
      if (options.mediaType.previews.length) {
        const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
        headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map(preview => {
          const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
          return `application/vnd.github.${preview}-preview${format}`;
        }).join(",");
      }
    } // for GET/HEAD requests, set URL query parameters from remaining parameters
    // for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
  
  
    if (["GET", "HEAD"].includes(method)) {
      url = addQueryParameters(url, remainingParameters);
    } else {
      if ("data" in remainingParameters) {
        body = remainingParameters.data;
      } else {
        if (Object.keys(remainingParameters).length) {
          body = remainingParameters;
        } else {
          headers["content-length"] = 0;
        }
      }
    } // default content-type for JSON if body is set
  
  
    if (!headers["content-type"] && typeof body !== "undefined") {
      headers["content-type"] = "application/json; charset=utf-8";
    } // GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
    // fetch does not allow to set `content-length` header, but we can set body to an empty string
  
  
    if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
      body = "";
    } // Only return body/request keys if present
  
  
    return Object.assign({
      method,
      url,
      headers
    }, typeof body !== "undefined" ? {
      body
    } : null, options.request ? {
      request: options.request
    } : null);
  }
  
  function endpointWithDefaults(defaults, route, options) {
    return parse(merge(defaults, route, options));
  }
  
  function withDefaults(oldDefaults, newDefaults) {
    const DEFAULTS = merge(oldDefaults, newDefaults);
    const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
    return Object.assign(endpoint, {
      DEFAULTS,
      defaults: withDefaults.bind(null, DEFAULTS),
      merge: merge.bind(null, DEFAULTS),
      parse
    });
  }
  
  const VERSION = "6.0.12";
  
  const userAgent = `octokit-endpoint.js/${VERSION} ${universalUserAgent.getUserAgent()}`; // DEFAULTS has all properties set that EndpointOptions has, except url.
  // So we use RequestParameters and add method as additional required property.
  
  const DEFAULTS = {
    method: "GET",
    baseUrl: "https://api.github.com",
    headers: {
      accept: "application/vnd.github.v3+json",
      "user-agent": userAgent
    },
    mediaType: {
      format: "",
      previews: []
    }
  };
  
  const endpoint = withDefaults(null, DEFAULTS);
  
  exports.endpoint = endpoint;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  /* 893 */,
  /* 894 */,
  /* 895 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Sorts a list according to a list of comparators.
   *
   * @func
   * @memberOf R
   * @since v0.23.0
   * @category Relation
   * @sig [(a, a) -> Number] -> [a] -> [a]
   * @param {Array} functions A list of comparator functions.
   * @param {Array} list The list to sort.
   * @return {Array} A new list sorted according to the comarator functions.
   * @example
   *
   *      const alice = {
   *        name: 'alice',
   *        age: 40
   *      };
   *      const bob = {
   *        name: 'bob',
   *        age: 30
   *      };
   *      const clara = {
   *        name: 'clara',
   *        age: 40
   *      };
   *      const people = [clara, bob, alice];
   *      const ageNameSort = R.sortWith([
   *        R.descend(R.prop('age')),
   *        R.ascend(R.prop('name'))
   *      ]);
   *      ageNameSort(people); //=> [alice, clara, bob]
   */
  
  
  var sortWith =
  /*#__PURE__*/
  _curry2(function sortWith(fns, list) {
    return Array.prototype.slice.call(list, 0).sort(function (a, b) {
      var result = 0;
      var i = 0;
  
      while (result === 0 && i < fns.length) {
        result = fns[i](a, b);
        i += 1;
      }
  
      return result;
    });
  });
  
  module.exports = sortWith;
  
  /***/ }),
  /* 896 */
  /***/ (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]';
  };
  
  
  /***/ }),
  /* 897 */,
  /* 898 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _aperture =
  /*#__PURE__*/
  __webpack_require__(675);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xaperture =
  /*#__PURE__*/
  __webpack_require__(550);
  /**
   * Returns a new list, composed of n-tuples of consecutive elements. If `n` is
   * greater than the length of the list, an empty list is returned.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.12.0
   * @category List
   * @sig Number -> [a] -> [[a]]
   * @param {Number} n The size of the tuples to create
   * @param {Array} list The list to split into `n`-length tuples
   * @return {Array} The resulting list of `n`-length tuples
   * @see R.transduce
   * @example
   *
   *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
   *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
   *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []
   */
  
  
  var aperture =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xaperture, _aperture));
  
  module.exports = aperture;
  
  /***/ }),
  /* 899 */,
  /* 900 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  
  var takeLast =
  /*#__PURE__*/
  __webpack_require__(173);
  /**
   * Checks if a list ends with the provided sublist.
   *
   * Similarly, checks if a string ends with the provided substring.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category List
   * @sig [a] -> [a] -> Boolean
   * @sig String -> String -> Boolean
   * @param {*} suffix
   * @param {*} list
   * @return {Boolean}
   * @see R.startsWith
   * @example
   *
   *      R.endsWith('c', 'abc')                //=> true
   *      R.endsWith('b', 'abc')                //=> false
   *      R.endsWith(['c'], ['a', 'b', 'c'])    //=> true
   *      R.endsWith(['b'], ['a', 'b', 'c'])    //=> false
   */
  
  
  var endsWith =
  /*#__PURE__*/
  _curry2(function (suffix, list) {
    return equals(takeLast(suffix.length, list), suffix);
  });
  
  module.exports = endsWith;
  
  /***/ }),
  /* 901 */,
  /* 902 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  /**
   * Converts an object into an array of key, value arrays. Only the object's
   * own properties are used.
   * Note that the order of the output array is not guaranteed to be consistent
   * across different JS platforms.
   *
   * @func
   * @memberOf R
   * @since v0.4.0
   * @category Object
   * @sig {String: *} -> [[String,*]]
   * @param {Object} obj The object to extract from
   * @return {Array} An array of key, value arrays from the object's own properties.
   * @see R.fromPairs
   * @example
   *
   *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]
   */
  
  
  var toPairs =
  /*#__PURE__*/
  _curry1(function toPairs(obj) {
    var pairs = [];
  
    for (var prop in obj) {
      if (_has(prop, obj)) {
        pairs[pairs.length] = [prop, obj[prop]];
      }
    }
  
    return pairs;
  });
  
  module.exports = toPairs;
  
  /***/ }),
  /* 903 */,
  /* 904 */,
  /* 905 */,
  /* 906 */,
  /* 907 */,
  /* 908 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _concat =
  /*#__PURE__*/
  __webpack_require__(340);
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Applies a function to the value at the given index of an array, returning a
   * new copy of the array with the element at the given index replaced with the
   * result of the function application.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category List
   * @sig Number -> (a -> a) -> [a] -> [a]
   * @param {Number} idx The index.
   * @param {Function} fn The function to apply.
   * @param {Array|Arguments} list An array-like object whose value
   *        at the supplied index will be replaced.
   * @return {Array} A copy of the supplied array-like object with
   *         the element at index `idx` replaced with the value
   *         returned by applying `fn` to the existing element.
   * @see R.update
   * @example
   *
   *      R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']);      //=> ['a', 'B', 'c', 'd']
   *      R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']);     //=> ['a', 'b', 'c', 'D']
   * @symb R.adjust(-1, f, [a, b]) = [a, f(b)]
   * @symb R.adjust(0, f, [a, b]) = [f(a), b]
   */
  
  
  var adjust =
  /*#__PURE__*/
  _curry3(function adjust(idx, fn, list) {
    if (idx >= list.length || idx < -list.length) {
      return list;
    }
  
    var start = idx < 0 ? list.length : 0;
  
    var _idx = start + idx;
  
    var _list = _concat(list);
  
    _list[_idx] = fn(list[_idx]);
    return _list;
  });
  
  module.exports = adjust;
  
  /***/ }),
  /* 909 */,
  /* 910 */,
  /* 911 */,
  /* 912 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  /**
   * Takes a function and two values in its domain and returns `true` if the
   * values map to the same value in the codomain; `false` otherwise.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category Relation
   * @sig (a -> b) -> a -> a -> Boolean
   * @param {Function} f
   * @param {*} x
   * @param {*} y
   * @return {Boolean}
   * @example
   *
   *      R.eqBy(Math.abs, 5, -5); //=> true
   */
  
  
  var eqBy =
  /*#__PURE__*/
  _curry3(function eqBy(f, x, y) {
    return equals(f(x), f(y));
  });
  
  module.exports = eqBy;
  
  /***/ }),
  /* 913 */
  /***/ (function(module) {
  
  /**
   * A function that always returns `false`. Any passed in parameters are ignored.
   *
   * @func
   * @memberOf R
   * @since v0.9.0
   * @category Function
   * @sig * -> Boolean
   * @param {*}
   * @return {Boolean}
   * @see R.T
   * @example
   *
   *      R.F(); //=> false
   */
  var F = function () {
    return false;
  };
  
  module.exports = F;
  
  /***/ }),
  /* 914 */,
  /* 915 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Returns the smaller of its two arguments.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Relation
   * @sig Ord a => a -> a -> a
   * @param {*} a
   * @param {*} b
   * @return {*}
   * @see R.minBy, R.max
   * @example
   *
   *      R.min(789, 123); //=> 123
   *      R.min('a', 'b'); //=> 'a'
   */
  
  
  var min =
  /*#__PURE__*/
  _curry2(function min(a, b) {
    return b < a ? b : a;
  });
  
  module.exports = min;
  
  /***/ }),
  /* 916 */,
  /* 917 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Removes the sub-list of `list` starting at index `start` and containing
   * `count` elements. _Note that this is not destructive_: it returns a copy of
   * the list with the changes.
   * <small>No lists have been harmed in the application of this function.</small>
   *
   * @func
   * @memberOf R
   * @since v0.2.2
   * @category List
   * @sig Number -> Number -> [a] -> [a]
   * @param {Number} start The position to start removing elements
   * @param {Number} count The number of elements to remove
   * @param {Array} list The list to remove from
   * @return {Array} A new Array with `count` elements from `start` removed.
   * @see R.without
   * @example
   *
   *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
   */
  
  
  var remove =
  /*#__PURE__*/
  _curry3(function remove(start, count, list) {
    var result = Array.prototype.slice.call(list, 0);
    result.splice(start, count);
    return result;
  });
  
  module.exports = remove;
  
  /***/ }),
  /* 918 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _pipe =
  /*#__PURE__*/
  __webpack_require__(313);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  
  var tail =
  /*#__PURE__*/
  __webpack_require__(193);
  /**
   * Performs left-to-right function composition. The first argument may have
   * any arity; the remaining arguments must be unary.
   *
   * In some libraries this function is named `sequence`.
   *
   * **Note:** The result of pipe is not automatically curried.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
   * @param {...Function} functions
   * @return {Function}
   * @see R.compose
   * @example
   *
   *      const f = R.pipe(Math.pow, R.negate, R.inc);
   *
   *      f(3, 4); // -(3^4) + 1
   * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))
   */
  
  
  function pipe() {
    if (arguments.length === 0) {
      throw new Error('pipe requires at least one argument');
    }
  
    return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));
  }
  
  module.exports = pipe;
  
  /***/ }),
  /* 919 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _dispatchable =
  /*#__PURE__*/
  __webpack_require__(968);
  
  var _xdropRepeatsWith =
  /*#__PURE__*/
  __webpack_require__(424);
  
  var last =
  /*#__PURE__*/
  __webpack_require__(951);
  /**
   * Returns a new list without any consecutively repeating elements. Equality is
   * determined by applying the supplied predicate to each pair of consecutive elements. The
   * first element in a series of equal elements will be preserved.
   *
   * Acts as a transducer if a transformer is given in list position.
   *
   * @func
   * @memberOf R
   * @since v0.14.0
   * @category List
   * @sig ((a, a) -> Boolean) -> [a] -> [a]
   * @param {Function} pred A predicate used to test whether two items are equal.
   * @param {Array} list The array to consider.
   * @return {Array} `list` without repeating elements.
   * @see R.transduce
   * @example
   *
   *      const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];
   *      R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
   */
  
  
  var dropRepeatsWith =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {
    var result = [];
    var idx = 1;
    var len = list.length;
  
    if (len !== 0) {
      result[0] = list[0];
  
      while (idx < len) {
        if (!pred(last(result), list[idx])) {
          result[result.length] = list[idx];
        }
  
        idx += 1;
      }
    }
  
    return result;
  }));
  
  module.exports = dropRepeatsWith;
  
  /***/ }),
  /* 920 */,
  /* 921 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Divides two numbers. Equivalent to `a / b`.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Math
   * @sig Number -> Number -> Number
   * @param {Number} a The first value.
   * @param {Number} b The second value.
   * @return {Number} The result of `a / b`.
   * @see R.multiply
   * @example
   *
   *      R.divide(71, 100); //=> 0.71
   *
   *      const half = R.divide(R.__, 2);
   *      half(42); //=> 21
   *
   *      const reciprocal = R.divide(1);
   *      reciprocal(4);   //=> 0.25
   */
  
  
  var divide =
  /*#__PURE__*/
  _curry2(function divide(a, b) {
    return a / b;
  });
  
  module.exports = divide;
  
  /***/ }),
  /* 922 */,
  /* 923 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Pattern = void 0;
  const os = __importStar(__webpack_require__(87));
  const path = __importStar(__webpack_require__(622));
  const pathHelper = __importStar(__webpack_require__(972));
  const assert_1 = __importDefault(__webpack_require__(357));
  const minimatch_1 = __webpack_require__(93);
  const internal_match_kind_1 = __webpack_require__(327);
  const internal_path_1 = __webpack_require__(383);
  const IS_WINDOWS = process.platform === 'win32';
  class Pattern {
      constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
          /**
           * Indicates whether matches should be excluded from the result set
           */
          this.negate = false;
          // Pattern overload
          let pattern;
          if (typeof patternOrNegate === 'string') {
              pattern = patternOrNegate.trim();
          }
          // Segments overload
          else {
              // Convert to pattern
              segments = segments || [];
              assert_1.default(segments.length, `Parameter 'segments' must not empty`);
              const root = Pattern.getLiteral(segments[0]);
              assert_1.default(root && pathHelper.hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
              pattern = new internal_path_1.Path(segments).toString().trim();
              if (patternOrNegate) {
                  pattern = `!${pattern}`;
              }
          }
          // Negate
          while (pattern.startsWith('!')) {
              this.negate = !this.negate;
              pattern = pattern.substr(1).trim();
          }
          // Normalize slashes and ensures absolute root
          pattern = Pattern.fixupPattern(pattern, homedir);
          // Segments
          this.segments = new internal_path_1.Path(pattern).segments;
          // Trailing slash indicates the pattern should only match directories, not regular files
          this.trailingSeparator = pathHelper
              .normalizeSeparators(pattern)
              .endsWith(path.sep);
          pattern = pathHelper.safeTrimTrailingSeparator(pattern);
          // Search path (literal path prior to the first glob segment)
          let foundGlob = false;
          const searchSegments = this.segments
              .map(x => Pattern.getLiteral(x))
              .filter(x => !foundGlob && !(foundGlob = x === ''));
          this.searchPath = new internal_path_1.Path(searchSegments).toString();
          // Root RegExp (required when determining partial match)
          this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), IS_WINDOWS ? 'i' : '');
          this.isImplicitPattern = isImplicitPattern;
          // Create minimatch
          const minimatchOptions = {
              dot: true,
              nobrace: true,
              nocase: IS_WINDOWS,
              nocomment: true,
              noext: true,
              nonegate: true
          };
          pattern = IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern;
          this.minimatch = new minimatch_1.Minimatch(pattern, minimatchOptions);
      }
      /**
       * Matches the pattern against the specified path
       */
      match(itemPath) {
          // Last segment is globstar?
          if (this.segments[this.segments.length - 1] === '**') {
              // Normalize slashes
              itemPath = pathHelper.normalizeSeparators(itemPath);
              // Append a trailing slash. Otherwise Minimatch will not match the directory immediately
              // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns
              // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk.
              if (!itemPath.endsWith(path.sep) && this.isImplicitPattern === false) {
                  // Note, this is safe because the constructor ensures the pattern has an absolute root.
                  // For example, formats like C: and C:foo on Windows are resolved to an absolute root.
                  itemPath = `${itemPath}${path.sep}`;
              }
          }
          else {
              // Normalize slashes and trim unnecessary trailing slash
              itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
          }
          // Match
          if (this.minimatch.match(itemPath)) {
              return this.trailingSeparator ? internal_match_kind_1.MatchKind.Directory : internal_match_kind_1.MatchKind.All;
          }
          return internal_match_kind_1.MatchKind.None;
      }
      /**
       * Indicates whether the pattern may match descendants of the specified path
       */
      partialMatch(itemPath) {
          // Normalize slashes and trim unnecessary trailing slash
          itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
          // matchOne does not handle root path correctly
          if (pathHelper.dirname(itemPath) === itemPath) {
              return this.rootRegExp.test(itemPath);
          }
          return this.minimatch.matchOne(itemPath.split(IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true);
      }
      /**
       * Escapes glob patterns within a path
       */
      static globEscape(s) {
          return (IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS
              .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment
              .replace(/\?/g, '[?]') // escape '?'
              .replace(/\*/g, '[*]'); // escape '*'
      }
      /**
       * Normalizes slashes and ensures absolute root
       */
      static fixupPattern(pattern, homedir) {
          // Empty
          assert_1.default(pattern, 'pattern cannot be empty');
          // Must not contain `.` segment, unless first segment
          // Must not contain `..` segment
          const literalSegments = new internal_path_1.Path(pattern).segments.map(x => Pattern.getLiteral(x));
          assert_1.default(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
          // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r
          assert_1.default(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
          // Normalize slashes
          pattern = pathHelper.normalizeSeparators(pattern);
          // Replace leading `.` segment
          if (pattern === '.' || pattern.startsWith(`.${path.sep}`)) {
              pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1);
          }
          // Replace leading `~` segment
          else if (pattern === '~' || pattern.startsWith(`~${path.sep}`)) {
              homedir = homedir || os.homedir();
              assert_1.default(homedir, 'Unable to determine HOME directory');
              assert_1.default(pathHelper.hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
              pattern = Pattern.globEscape(homedir) + pattern.substr(1);
          }
          // Replace relative drive root, e.g. pattern is C: or C:foo
          else if (IS_WINDOWS &&
              (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
              let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2));
              if (pattern.length > 2 && !root.endsWith('\\')) {
                  root += '\\';
              }
              pattern = Pattern.globEscape(root) + pattern.substr(2);
          }
          // Replace relative root, e.g. pattern is \ or \foo
          else if (IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) {
              let root = pathHelper.ensureAbsoluteRoot('C:\\dummy-root', '\\');
              if (!root.endsWith('\\')) {
                  root += '\\';
              }
              pattern = Pattern.globEscape(root) + pattern.substr(1);
          }
          // Otherwise ensure absolute root
          else {
              pattern = pathHelper.ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern);
          }
          return pathHelper.normalizeSeparators(pattern);
      }
      /**
       * Attempts to unescape a pattern segment to create a literal path segment.
       * Otherwise returns empty string.
       */
      static getLiteral(segment) {
          let literal = '';
          for (let i = 0; i < segment.length; i++) {
              const c = segment[i];
              // Escape
              if (c === '\\' && !IS_WINDOWS && i + 1 < segment.length) {
                  literal += segment[++i];
                  continue;
              }
              // Wildcard
              else if (c === '*' || c === '?') {
                  return '';
              }
              // Character set
              else if (c === '[' && i + 1 < segment.length) {
                  let set = '';
                  let closed = -1;
                  for (let i2 = i + 1; i2 < segment.length; i2++) {
                      const c2 = segment[i2];
                      // Escape
                      if (c2 === '\\' && !IS_WINDOWS && i2 + 1 < segment.length) {
                          set += segment[++i2];
                          continue;
                      }
                      // Closed
                      else if (c2 === ']') {
                          closed = i2;
                          break;
                      }
                      // Otherwise
                      else {
                          set += c2;
                      }
                  }
                  // Closed?
                  if (closed >= 0) {
                      // Cannot convert
                      if (set.length > 1) {
                          return '';
                      }
                      // Convert to literal
                      if (set) {
                          literal += set;
                          i = closed;
                          continue;
                      }
                  }
                  // Otherwise fall thru
              }
              // Append
              literal += c;
          }
          return literal;
      }
      /**
       * Escapes regexp special characters
       * https://javascript.info/regexp-escaping
       */
      static regExpEscape(s) {
          return s.replace(/[[\\^$.|?*+()]/g, '\\$&');
      }
  }
  exports.Pattern = Pattern;
  //# sourceMappingURL=internal-pattern.js.map
  
  /***/ }),
  /* 924 */,
  /* 925 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _assertPromise =
  /*#__PURE__*/
  __webpack_require__(385);
  /**
   * Returns the result of applying the onFailure function to the value inside
   * a failed promise. This is useful for handling rejected promises
   * inside function compositions.
   *
   * @func
   * @memberOf R
   * @since v0.26.0
   * @category Function
   * @sig (e -> b) -> (Promise e a) -> (Promise e b)
   * @sig (e -> (Promise f b)) -> (Promise e a) -> (Promise f b)
   * @param {Function} onFailure The function to apply. Can return a value or a promise of a value.
   * @param {Promise} p
   * @return {Promise} The result of calling `p.then(null, onFailure)`
   * @see R.then
   * @example
   *
   *      var failedFetch = (id) => Promise.reject('bad ID');
   *      var useDefault = () => ({ firstName: 'Bob', lastName: 'Loblaw' })
   *
   *      //recoverFromFailure :: String -> Promise ({firstName, lastName})
   *      var recoverFromFailure = R.pipe(
   *        failedFetch,
   *        R.otherwise(useDefault),
   *        R.then(R.pick(['firstName', 'lastName'])),
   *      );
   *      recoverFromFailure(12345).then(console.log)
   */
  
  
  var otherwise =
  /*#__PURE__*/
  _curry2(function otherwise(f, p) {
    _assertPromise('otherwise', p);
  
    return p.then(null, f);
  });
  
  module.exports = otherwise;
  
  /***/ }),
  /* 926 */,
  /* 927 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  
  var mergeWithKey =
  /*#__PURE__*/
  __webpack_require__(681);
  /**
   * Creates a new object with the own properties of the two provided objects. If
   * a key exists in both objects, the provided function is applied to the values
   * associated with the key in each object, with the result being used as the
   * value associated with the key in the returned object.
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category Object
   * @sig ((a, a) -> a) -> {a} -> {a} -> {a}
   * @param {Function} fn
   * @param {Object} l
   * @param {Object} r
   * @return {Object}
   * @see R.mergeDeepWith, R.merge, R.mergeWithKey
   * @example
   *
   *      R.mergeWith(R.concat,
   *                  { a: true, values: [10, 20] },
   *                  { b: true, values: [15, 35] });
   *      //=> { a: true, b: true, values: [10, 20, 15, 35] }
   */
  
  
  var mergeWith =
  /*#__PURE__*/
  _curry3(function mergeWith(fn, l, r) {
    return mergeWithKey(function (_, _l, _r) {
      return fn(_l, _r);
    }, l, r);
  });
  
  module.exports = mergeWith;
  
  /***/ }),
  /* 928 */,
  /* 929 */,
  /* 930 */
  /***/ (function(module) {
  
  /**
   * Tests whether or not an object is an array.
   *
   * @private
   * @param {*} val The object to test.
   * @return {Boolean} `true` if `val` is an array, `false` otherwise.
   * @example
   *
   *      _isArray([]); //=> true
   *      _isArray(null); //=> false
   *      _isArray({}); //=> false
   */
  module.exports = Array.isArray || function _isArray(val) {
    return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';
  };
  
  /***/ }),
  /* 931 */,
  /* 932 */,
  /* 933 */,
  /* 934 */,
  /* 935 */,
  /* 936 */,
  /* 937 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Takes a function and two values, and returns whichever value produces the
   * larger result when passed to the provided function.
   *
   * @func
   * @memberOf R
   * @since v0.8.0
   * @category Relation
   * @sig Ord b => (a -> b) -> a -> a -> a
   * @param {Function} f
   * @param {*} a
   * @param {*} b
   * @return {*}
   * @see R.max, R.minBy
   * @example
   *
   *      //  square :: Number -> Number
   *      const square = n => n * n;
   *
   *      R.maxBy(square, -3, 2); //=> -3
   *
   *      R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5
   *      R.reduce(R.maxBy(square), 0, []); //=> 0
   */
  
  
  var maxBy =
  /*#__PURE__*/
  _curry3(function maxBy(f, a, b) {
    return f(b) > f(a) ? b : a;
  });
  
  module.exports = maxBy;
  
  /***/ }),
  /* 938 */
  /***/ (function(module) {
  
  function _reduced(x) {
    return x && x['@@transducer/reduced'] ? x : {
      '@@transducer/value': x,
      '@@transducer/reduced': true
    };
  }
  
  module.exports = _reduced;
  
  /***/ }),
  /* 939 */,
  /* 940 */,
  /* 941 */,
  /* 942 */,
  /* 943 */,
  /* 944 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var pipe =
  /*#__PURE__*/
  __webpack_require__(918);
  
  var reverse =
  /*#__PURE__*/
  __webpack_require__(528);
  /**
   * Performs right-to-left function composition. The last argument may have
   * any arity; the remaining arguments must be unary.
   *
   * **Note:** The result of compose is not automatically curried.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
   * @param {...Function} ...functions The functions to compose
   * @return {Function}
   * @see R.pipe
   * @example
   *
   *      const classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
   *      const yellGreeting = R.compose(R.toUpper, classyGreeting);
   *      yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
   *
   *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
   *
   * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
   */
  
  
  function compose() {
    if (arguments.length === 0) {
      throw new Error('compose requires at least one argument');
    }
  
    return pipe.apply(this, reverse(arguments));
  }
  
  module.exports = compose;
  
  /***/ }),
  /* 945 */
  /***/ (function(module) {
  
  function _isRegExp(x) {
    return Object.prototype.toString.call(x) === '[object RegExp]';
  }
  
  module.exports = _isRegExp;
  
  /***/ }),
  /* 946 */,
  /* 947 */,
  /* 948 */
  /***/ (function(module) {
  
  "use strict";
  
  
  /**
   * Tries to execute a function and discards any error that occurs.
   * @param {Function} fn - Function that might or might not throw an error.
   * @returns {?*} Return-value of the function when no error occurred.
   */
  module.exports = function(fn) {
  
  	try { return fn() } catch (e) {}
  
  }
  
  /***/ }),
  /* 949 */,
  /* 950 */
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  function getProxyUrl(reqUrl) {
      let usingSsl = reqUrl.protocol === 'https:';
      let proxyUrl;
      if (checkBypass(reqUrl)) {
          return proxyUrl;
      }
      let proxyVar;
      if (usingSsl) {
          proxyVar = process.env['https_proxy'] || process.env['HTTPS_PROXY'];
      }
      else {
          proxyVar = process.env['http_proxy'] || process.env['HTTP_PROXY'];
      }
      if (proxyVar) {
          proxyUrl = new URL(proxyVar);
      }
      return proxyUrl;
  }
  exports.getProxyUrl = getProxyUrl;
  function checkBypass(reqUrl) {
      if (!reqUrl.hostname) {
          return false;
      }
      let noProxy = process.env['no_proxy'] || process.env['NO_PROXY'] || '';
      if (!noProxy) {
          return false;
      }
      // Determine the request port
      let reqPort;
      if (reqUrl.port) {
          reqPort = Number(reqUrl.port);
      }
      else if (reqUrl.protocol === 'http:') {
          reqPort = 80;
      }
      else if (reqUrl.protocol === 'https:') {
          reqPort = 443;
      }
      // Format the request hostname and hostname with port
      let upperReqHosts = [reqUrl.hostname.toUpperCase()];
      if (typeof reqPort === 'number') {
          upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`);
      }
      // Compare request host against noproxy
      for (let upperNoProxyItem of noProxy
          .split(',')
          .map(x => x.trim().toUpperCase())
          .filter(x => x)) {
          if (upperReqHosts.some(x => x === upperNoProxyItem)) {
              return true;
          }
      }
      return false;
  }
  exports.checkBypass = checkBypass;
  
  
  /***/ }),
  /* 951 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var nth =
  /*#__PURE__*/
  __webpack_require__(653);
  /**
   * Returns the last element of the given list or string.
   *
   * @func
   * @memberOf R
   * @since v0.1.4
   * @category List
   * @sig [a] -> a | Undefined
   * @sig String -> String
   * @param {*} list
   * @return {*}
   * @see R.init, R.head, R.tail
   * @example
   *
   *      R.last(['fi', 'fo', 'fum']); //=> 'fum'
   *      R.last([]); //=> undefined
   *
   *      R.last('abc'); //=> 'c'
   *      R.last(''); //=> ''
   */
  
  
  var last =
  /*#__PURE__*/
  nth(-1);
  module.exports = last;
  
  /***/ }),
  /* 952 */,
  /* 953 */
  /***/ (function(module) {
  
  function _isPlaceholder(a) {
    return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;
  }
  
  module.exports = _isPlaceholder;
  
  /***/ }),
  /* 954 */,
  /* 955 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const path = __webpack_require__(622);
  const childProcess = __webpack_require__(129);
  const crossSpawn = __webpack_require__(71);
  const stripEof = __webpack_require__(639);
  const npmRunPath = __webpack_require__(512);
  const isStream = __webpack_require__(323);
  const _getStream = __webpack_require__(145);
  const pFinally = __webpack_require__(697);
  const onExit = __webpack_require__(800);
  const errname = __webpack_require__(427);
  const stdio = __webpack_require__(168);
  
  const TEN_MEGABYTES = 1000 * 1000 * 10;
  
  function handleArgs(cmd, args, opts) {
  	let parsed;
  
  	opts = Object.assign({
  		extendEnv: true,
  		env: {}
  	}, opts);
  
  	if (opts.extendEnv) {
  		opts.env = Object.assign({}, process.env, opts.env);
  	}
  
  	if (opts.__winShell === true) {
  		delete opts.__winShell;
  		parsed = {
  			command: cmd,
  			args,
  			options: opts,
  			file: cmd,
  			original: {
  				cmd,
  				args
  			}
  		};
  	} else {
  		parsed = crossSpawn._parse(cmd, args, opts);
  	}
  
  	opts = Object.assign({
  		maxBuffer: TEN_MEGABYTES,
  		buffer: true,
  		stripEof: true,
  		preferLocal: true,
  		localDir: parsed.options.cwd || process.cwd(),
  		encoding: 'utf8',
  		reject: true,
  		cleanup: true
  	}, parsed.options);
  
  	opts.stdio = stdio(opts);
  
  	if (opts.preferLocal) {
  		opts.env = npmRunPath.env(Object.assign({}, opts, {cwd: opts.localDir}));
  	}
  
  	if (opts.detached) {
  		// #115
  		opts.cleanup = false;
  	}
  
  	if (process.platform === 'win32' && path.basename(parsed.command) === 'cmd.exe') {
  		// #116
  		parsed.args.unshift('/q');
  	}
  
  	return {
  		cmd: parsed.command,
  		args: parsed.args,
  		opts,
  		parsed
  	};
  }
  
  function handleInput(spawned, input) {
  	if (input === null || input === undefined) {
  		return;
  	}
  
  	if (isStream(input)) {
  		input.pipe(spawned.stdin);
  	} else {
  		spawned.stdin.end(input);
  	}
  }
  
  function handleOutput(opts, val) {
  	if (val && opts.stripEof) {
  		val = stripEof(val);
  	}
  
  	return val;
  }
  
  function handleShell(fn, cmd, opts) {
  	let file = '/bin/sh';
  	let args = ['-c', cmd];
  
  	opts = Object.assign({}, opts);
  
  	if (process.platform === 'win32') {
  		opts.__winShell = true;
  		file = process.env.comspec || 'cmd.exe';
  		args = ['/s', '/c', `"${cmd}"`];
  		opts.windowsVerbatimArguments = true;
  	}
  
  	if (opts.shell) {
  		file = opts.shell;
  		delete opts.shell;
  	}
  
  	return fn(file, args, opts);
  }
  
  function getStream(process, stream, {encoding, buffer, maxBuffer}) {
  	if (!process[stream]) {
  		return null;
  	}
  
  	let ret;
  
  	if (!buffer) {
  		// TODO: Use `ret = util.promisify(stream.finished)(process[stream]);` when targeting Node.js 10
  		ret = new Promise((resolve, reject) => {
  			process[stream]
  				.once('end', resolve)
  				.once('error', reject);
  		});
  	} else if (encoding) {
  		ret = _getStream(process[stream], {
  			encoding,
  			maxBuffer
  		});
  	} else {
  		ret = _getStream.buffer(process[stream], {maxBuffer});
  	}
  
  	return ret.catch(err => {
  		err.stream = stream;
  		err.message = `${stream} ${err.message}`;
  		throw err;
  	});
  }
  
  function makeError(result, options) {
  	const {stdout, stderr} = result;
  
  	let err = result.error;
  	const {code, signal} = result;
  
  	const {parsed, joinedCmd} = options;
  	const timedOut = options.timedOut || false;
  
  	if (!err) {
  		let output = '';
  
  		if (Array.isArray(parsed.opts.stdio)) {
  			if (parsed.opts.stdio[2] !== 'inherit') {
  				output += output.length > 0 ? stderr : `\n${stderr}`;
  			}
  
  			if (parsed.opts.stdio[1] !== 'inherit') {
  				output += `\n${stdout}`;
  			}
  		} else if (parsed.opts.stdio !== 'inherit') {
  			output = `\n${stderr}${stdout}`;
  		}
  
  		err = new Error(`Command failed: ${joinedCmd}${output}`);
  		err.code = code < 0 ? errname(code) : code;
  	}
  
  	err.stdout = stdout;
  	err.stderr = stderr;
  	err.failed = true;
  	err.signal = signal || null;
  	err.cmd = joinedCmd;
  	err.timedOut = timedOut;
  
  	return err;
  }
  
  function joinCmd(cmd, args) {
  	let joinedCmd = cmd;
  
  	if (Array.isArray(args) && args.length > 0) {
  		joinedCmd += ' ' + args.join(' ');
  	}
  
  	return joinedCmd;
  }
  
  module.exports = (cmd, args, opts) => {
  	const parsed = handleArgs(cmd, args, opts);
  	const {encoding, buffer, maxBuffer} = parsed.opts;
  	const joinedCmd = joinCmd(cmd, args);
  
  	let spawned;
  	try {
  		spawned = childProcess.spawn(parsed.cmd, parsed.args, parsed.opts);
  	} catch (err) {
  		return Promise.reject(err);
  	}
  
  	let removeExitHandler;
  	if (parsed.opts.cleanup) {
  		removeExitHandler = onExit(() => {
  			spawned.kill();
  		});
  	}
  
  	let timeoutId = null;
  	let timedOut = false;
  
  	const cleanup = () => {
  		if (timeoutId) {
  			clearTimeout(timeoutId);
  			timeoutId = null;
  		}
  
  		if (removeExitHandler) {
  			removeExitHandler();
  		}
  	};
  
  	if (parsed.opts.timeout > 0) {
  		timeoutId = setTimeout(() => {
  			timeoutId = null;
  			timedOut = true;
  			spawned.kill(parsed.opts.killSignal);
  		}, parsed.opts.timeout);
  	}
  
  	const processDone = new Promise(resolve => {
  		spawned.on('exit', (code, signal) => {
  			cleanup();
  			resolve({code, signal});
  		});
  
  		spawned.on('error', err => {
  			cleanup();
  			resolve({error: err});
  		});
  
  		if (spawned.stdin) {
  			spawned.stdin.on('error', err => {
  				cleanup();
  				resolve({error: err});
  			});
  		}
  	});
  
  	function destroy() {
  		if (spawned.stdout) {
  			spawned.stdout.destroy();
  		}
  
  		if (spawned.stderr) {
  			spawned.stderr.destroy();
  		}
  	}
  
  	const handlePromise = () => pFinally(Promise.all([
  		processDone,
  		getStream(spawned, 'stdout', {encoding, buffer, maxBuffer}),
  		getStream(spawned, 'stderr', {encoding, buffer, maxBuffer})
  	]).then(arr => {
  		const result = arr[0];
  		result.stdout = arr[1];
  		result.stderr = arr[2];
  
  		if (result.error || result.code !== 0 || result.signal !== null) {
  			const err = makeError(result, {
  				joinedCmd,
  				parsed,
  				timedOut
  			});
  
  			// TODO: missing some timeout logic for killed
  			// https://github.com/nodejs/node/blob/master/lib/child_process.js#L203
  			// err.killed = spawned.killed || killed;
  			err.killed = err.killed || spawned.killed;
  
  			if (!parsed.opts.reject) {
  				return err;
  			}
  
  			throw err;
  		}
  
  		return {
  			stdout: handleOutput(parsed.opts, result.stdout),
  			stderr: handleOutput(parsed.opts, result.stderr),
  			code: 0,
  			failed: false,
  			killed: false,
  			signal: null,
  			cmd: joinedCmd,
  			timedOut: false
  		};
  	}), destroy);
  
  	crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
  
  	handleInput(spawned, parsed.opts.input);
  
  	spawned.then = (onfulfilled, onrejected) => handlePromise().then(onfulfilled, onrejected);
  	spawned.catch = onrejected => handlePromise().catch(onrejected);
  
  	return spawned;
  };
  
  // TODO: set `stderr: 'ignore'` when that option is implemented
  module.exports.stdout = (...args) => module.exports(...args).then(x => x.stdout);
  
  // TODO: set `stdout: 'ignore'` when that option is implemented
  module.exports.stderr = (...args) => module.exports(...args).then(x => x.stderr);
  
  module.exports.shell = (cmd, opts) => handleShell(module.exports, cmd, opts);
  
  module.exports.sync = (cmd, args, opts) => {
  	const parsed = handleArgs(cmd, args, opts);
  	const joinedCmd = joinCmd(cmd, args);
  
  	if (isStream(parsed.opts.input)) {
  		throw new TypeError('The `input` option cannot be a stream in sync mode');
  	}
  
  	const result = childProcess.spawnSync(parsed.cmd, parsed.args, parsed.opts);
  	result.code = result.status;
  
  	if (result.error || result.status !== 0 || result.signal !== null) {
  		const err = makeError(result, {
  			joinedCmd,
  			parsed
  		});
  
  		if (!parsed.opts.reject) {
  			return err;
  		}
  
  		throw err;
  	}
  
  	return {
  		stdout: handleOutput(parsed.opts, result.stdout),
  		stderr: handleOutput(parsed.opts, result.stderr),
  		code: 0,
  		failed: false,
  		signal: null,
  		cmd: joinedCmd,
  		timedOut: false
  	};
  };
  
  module.exports.shellSync = (cmd, opts) => handleShell(module.exports.sync, cmd, opts);
  
  
  /***/ }),
  /* 956 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Creates a new object out of a list of keys and a list of values.
   * Key/value pairing is truncated to the length of the shorter of the two lists.
   * Note: `zipObj` is equivalent to `pipe(zip, fromPairs)`.
   *
   * @func
   * @memberOf R
   * @since v0.3.0
   * @category List
   * @sig [String] -> [*] -> {String: *}
   * @param {Array} keys The array that will be properties on the output object.
   * @param {Array} values The list of values on the output object.
   * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.
   * @example
   *
   *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}
   */
  
  
  var zipObj =
  /*#__PURE__*/
  _curry2(function zipObj(keys, values) {
    var idx = 0;
    var len = Math.min(keys.length, values.length);
    var out = {};
  
    while (idx < len) {
      out[keys[idx]] = values[idx];
      idx += 1;
    }
  
    return out;
  });
  
  module.exports = zipObj;
  
  /***/ }),
  /* 957 */,
  /* 958 */,
  /* 959 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XFilter =
  /*#__PURE__*/
  function () {
    function XFilter(f, xf) {
      this.xf = xf;
      this.f = f;
    }
  
    XFilter.prototype['@@transducer/init'] = _xfBase.init;
    XFilter.prototype['@@transducer/result'] = _xfBase.result;
  
    XFilter.prototype['@@transducer/step'] = function (result, input) {
      return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;
    };
  
    return XFilter;
  }();
  
  var _xfilter =
  /*#__PURE__*/
  _curry2(function _xfilter(f, xf) {
    return new XFilter(f, xf);
  });
  
  module.exports = _xfilter;
  
  /***/ }),
  /* 960 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  
  var toString = Object.prototype.toString;
  
  var _isArguments =
  /*#__PURE__*/
  function () {
    return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {
      return toString.call(x) === '[object Arguments]';
    } : function _isArguments(x) {
      return _has('callee', x);
    };
  }();
  
  module.exports = _isArguments;
  
  /***/ }),
  /* 961 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  const char = function(a) {
    return String.fromCharCode(a);
  };
  
  const chars = {
    nilChar: char(176),
    missingChar: char(201),
    nilPremitive: char(175),
    missingPremitive: char(200),
  
    emptyChar: char(178),
    emptyValue: char(177), //empty Premitive
  
    boundryChar: char(179),
  
    objStart: char(198),
    arrStart: char(204),
    arrayEnd: char(185),
  };
  
  const charsArr = [
    chars.nilChar,
    chars.nilPremitive,
    chars.missingChar,
    chars.missingPremitive,
    chars.boundryChar,
    chars.emptyChar,
    chars.emptyValue,
    chars.arrayEnd,
    chars.objStart,
    chars.arrStart,
  ];
  
  const _e = function(node, e_schema, options) {
    if (typeof e_schema === 'string') {
      //premitive
      if (node && node[0] && node[0].val !== undefined) {
        return getValue(node[0].val, e_schema);
      } else {
        return getValue(node, e_schema);
      }
    } else {
      const hasValidData = hasData(node);
      if (hasValidData === true) {
        let str = '';
        if (Array.isArray(e_schema)) {
          //attributes can't be repeated. hence check in children tags only
          str += chars.arrStart;
          const itemSchema = e_schema[0];
          //var itemSchemaType = itemSchema;
          const arr_len = node.length;
  
          if (typeof itemSchema === 'string') {
            for (let arr_i = 0; arr_i < arr_len; arr_i++) {
              const r = getValue(node[arr_i].val, itemSchema);
              str = processValue(str, r);
            }
          } else {
            for (let arr_i = 0; arr_i < arr_len; arr_i++) {
              const r = _e(node[arr_i], itemSchema, options);
              str = processValue(str, r);
            }
          }
          str += chars.arrayEnd; //indicates that next item is not array item
        } else {
          //object
          str += chars.objStart;
          const keys = Object.keys(e_schema);
          if (Array.isArray(node)) {
            node = node[0];
          }
          for (let i in keys) {
            const key = keys[i];
            //a property defined in schema can be present either in attrsMap or children tags
            //options.textNodeName will not present in both maps, take it's value from val
            //options.attrNodeName will be present in attrsMap
            let r;
            if (!options.ignoreAttributes && node.attrsMap && node.attrsMap[key]) {
              r = _e(node.attrsMap[key], e_schema[key], options);
            } else if (key === options.textNodeName) {
              r = _e(node.val, e_schema[key], options);
            } else {
              r = _e(node.child[key], e_schema[key], options);
            }
            str = processValue(str, r);
          }
        }
        return str;
      } else {
        return hasValidData;
      }
    }
  };
  
  const getValue = function(a /*, type*/) {
    switch (a) {
      case undefined:
        return chars.missingPremitive;
      case null:
        return chars.nilPremitive;
      case '':
        return chars.emptyValue;
      default:
        return a;
    }
  };
  
  const processValue = function(str, r) {
    if (!isAppChar(r[0]) && !isAppChar(str[str.length - 1])) {
      str += chars.boundryChar;
    }
    return str + r;
  };
  
  const isAppChar = function(ch) {
    return charsArr.indexOf(ch) !== -1;
  };
  
  function hasData(jObj) {
    if (jObj === undefined) {
      return chars.missingChar;
    } else if (jObj === null) {
      return chars.nilChar;
    } else if (
      jObj.child &&
      Object.keys(jObj.child).length === 0 &&
      (!jObj.attrsMap || Object.keys(jObj.attrsMap).length === 0)
    ) {
      return chars.emptyChar;
    } else {
      return true;
    }
  }
  
  const x2j = __webpack_require__(170);
  const buildOptions = __webpack_require__(343).buildOptions;
  
  const convert2nimn = function(node, e_schema, options) {
    options = buildOptions(options, x2j.defaultOptions, x2j.props);
    return _e(node, e_schema, options);
  };
  
  exports.convert2nimn = convert2nimn;
  
  
  /***/ }),
  /* 962 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _checkForMethod =
  /*#__PURE__*/
  __webpack_require__(417);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  /**
   * Iterate over an input `list`, calling a provided function `fn` for each
   * element in the list.
   *
   * `fn` receives one argument: *(value)*.
   *
   * Note: `R.forEach` does not skip deleted or unassigned indices (sparse
   * arrays), unlike the native `Array.prototype.forEach` method. For more
   * details on this behavior, see:
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
   *
   * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns
   * the original array. In some libraries this function is named `each`.
   *
   * Dispatches to the `forEach` method of the second argument, if present.
   *
   * @func
   * @memberOf R
   * @since v0.1.1
   * @category List
   * @sig (a -> *) -> [a] -> [a]
   * @param {Function} fn The function to invoke. Receives one argument, `value`.
   * @param {Array} list The list to iterate over.
   * @return {Array} The original list.
   * @see R.addIndex
   * @example
   *
   *      const printXPlusFive = x => console.log(x + 5);
   *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
   *      // logs 6
   *      // logs 7
   *      // logs 8
   * @symb R.forEach(f, [a, b, c]) = [a, b, c]
   */
  
  
  var forEach =
  /*#__PURE__*/
  _curry2(
  /*#__PURE__*/
  _checkForMethod('forEach', function forEach(fn, list) {
    var len = list.length;
    var idx = 0;
  
    while (idx < len) {
      fn(list[idx]);
      idx += 1;
    }
  
    return list;
  }));
  
  module.exports = forEach;
  
  /***/ }),
  /* 963 */,
  /* 964 */
  /***/ (function(module) {
  
  function _complement(f) {
    return function () {
      return !f.apply(this, arguments);
    };
  }
  
  module.exports = _complement;
  
  /***/ }),
  /* 965 */,
  /* 966 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _reduced =
  /*#__PURE__*/
  __webpack_require__(938);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XFind =
  /*#__PURE__*/
  function () {
    function XFind(f, xf) {
      this.xf = xf;
      this.f = f;
      this.found = false;
    }
  
    XFind.prototype['@@transducer/init'] = _xfBase.init;
  
    XFind.prototype['@@transducer/result'] = function (result) {
      if (!this.found) {
        result = this.xf['@@transducer/step'](result, void 0);
      }
  
      return this.xf['@@transducer/result'](result);
    };
  
    XFind.prototype['@@transducer/step'] = function (result, input) {
      if (this.f(input)) {
        this.found = true;
        result = _reduced(this.xf['@@transducer/step'](result, input));
      }
  
      return result;
    };
  
    return XFind;
  }();
  
  var _xfind =
  /*#__PURE__*/
  _curry2(function _xfind(f, xf) {
    return new XFind(f, xf);
  });
  
  module.exports = _xfind;
  
  /***/ }),
  /* 967 */,
  /* 968 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _isArray =
  /*#__PURE__*/
  __webpack_require__(930);
  
  var _isTransformer =
  /*#__PURE__*/
  __webpack_require__(700);
  /**
   * Returns a function that dispatches with different strategies based on the
   * object in list position (last argument). If it is an array, executes [fn].
   * Otherwise, if it has a function with one of the given method names, it will
   * execute that function (functor case). Otherwise, if it is a transformer,
   * uses transducer [xf] to return a new transformer (transducer case).
   * Otherwise, it will default to executing [fn].
   *
   * @private
   * @param {Array} methodNames properties to check for a custom implementation
   * @param {Function} xf transducer to initialize if object is transformer
   * @param {Function} fn default ramda implementation
   * @return {Function} A function that dispatches on object in list position
   */
  
  
  function _dispatchable(methodNames, xf, fn) {
    return function () {
      if (arguments.length === 0) {
        return fn();
      }
  
      var args = Array.prototype.slice.call(arguments, 0);
      var obj = args.pop();
  
      if (!_isArray(obj)) {
        var idx = 0;
  
        while (idx < methodNames.length) {
          if (typeof obj[methodNames[idx]] === 'function') {
            return obj[methodNames[idx]].apply(obj, args);
          }
  
          idx += 1;
        }
  
        if (_isTransformer(obj)) {
          var transducer = xf.apply(null, args);
          return transducer(obj);
        }
      }
  
      return fn.apply(this, arguments);
    };
  }
  
  module.exports = _dispatchable;
  
  /***/ }),
  /* 969 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var wrappy = __webpack_require__(11)
  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
  }
  
  
  /***/ }),
  /* 970 */,
  /* 971 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  const util = __webpack_require__(343);
  
  const defaultOptions = {
    allowBooleanAttributes: false, //A tag can have attributes without any value
  };
  
  const props = ['allowBooleanAttributes'];
  
  //const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
  exports.validate = function (xmlData, options) {
    options = util.buildOptions(options, defaultOptions, props);
  
    //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
    //xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag
    //xmlData = xmlData.replace(/(<!DOCTYPE[\s\w\"\.\/\-\:]+(\[.*\])*\s*>)/g,"");//Remove DOCTYPE
    const tags = [];
    let tagFound = false;
  
    //indicates that the root tag has been closed (aka. depth 0 has been reached)
    let reachedRoot = false;
  
    if (xmlData[0] === '\ufeff') {
      // check for byte order mark (BOM)
      xmlData = xmlData.substr(1);
    }
  
    for (let i = 0; i < xmlData.length; i++) {
  
      if (xmlData[i] === '<' && xmlData[i+1] === '?') {
        i+=2;
        i = readPI(xmlData,i);
        if (i.err) return i;
      }else if (xmlData[i] === '<') {
        //starting of tag
        //read until you reach to '>' avoiding any '>' in attribute value
  
        i++;
        
        if (xmlData[i] === '!') {
          i = readCommentAndCDATA(xmlData, i);
          continue;
        } else {
          let closingTag = false;
          if (xmlData[i] === '/') {
            //closing tag
            closingTag = true;
            i++;
          }
          //read tagname
          let tagName = '';
          for (; i < xmlData.length &&
            xmlData[i] !== '>' &&
            xmlData[i] !== ' ' &&
            xmlData[i] !== '\t' &&
            xmlData[i] !== '\n' &&
            xmlData[i] !== '\r'; i++
          ) {
            tagName += xmlData[i];
          }
          tagName = tagName.trim();
          //console.log(tagName);
  
          if (tagName[tagName.length - 1] === '/') {
            //self closing tag without attributes
            tagName = tagName.substring(0, tagName.length - 1);
            //continue;
            i--;
          }
          if (!validateTagName(tagName)) {
            let msg;
            if (tagName.trim().length === 0) {
              msg = "There is an unnecessary space between tag name and backward slash '</ ..'.";
            } else {
              msg = "Tag '"+tagName+"' is an invalid name.";
            }
            return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));
          }
  
          const result = readAttributeStr(xmlData, i);
          if (result === false) {
            return getErrorObject('InvalidAttr', "Attributes for '"+tagName+"' have open quote.", getLineNumberForPosition(xmlData, i));
          }
          let attrStr = result.value;
          i = result.index;
  
          if (attrStr[attrStr.length - 1] === '/') {
            //self closing tag
            attrStr = attrStr.substring(0, attrStr.length - 1);
            const isValid = validateAttributeString(attrStr, options);
            if (isValid === true) {
              tagFound = true;
              //continue; //text may presents after self closing tag
            } else {
              //the result from the nested function returns the position of the error within the attribute
              //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
              //this gives us the absolute index in the entire xml, which we can use to find the line at last
              return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
            }
          } else if (closingTag) {
            if (!result.tagClosed) {
              return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
            } else if (attrStr.trim().length > 0) {
              return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, i));
            } else {
              const otg = tags.pop();
              if (tagName !== otg) {
                return getErrorObject('InvalidTag', "Closing tag '"+otg+"' is expected inplace of '"+tagName+"'.", getLineNumberForPosition(xmlData, i));
              }
  
              //when there are no more tags, we reached the root level.
              if (tags.length == 0) {
                reachedRoot = true;
              }
            }
          } else {
            const isValid = validateAttributeString(attrStr, options);
            if (isValid !== true) {
              //the result from the nested function returns the position of the error within the attribute
              //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
              //this gives us the absolute index in the entire xml, which we can use to find the line at last
              return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
            }
  
            //if the root level has been reached before ...
            if (reachedRoot === true) {
              return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
            } else {
              tags.push(tagName);
            }
            tagFound = true;
          }
  
          //skip tag text value
          //It may include comments and CDATA value
          for (i++; i < xmlData.length; i++) {
            if (xmlData[i] === '<') {
              if (xmlData[i + 1] === '!') {
                //comment or CADATA
                i++;
                i = readCommentAndCDATA(xmlData, i);
                continue;
              } else if (xmlData[i+1] === '?') {
                i = readPI(xmlData, ++i);
                if (i.err) return i;
              } else{
                break;
              }
            } else if (xmlData[i] === '&') {
              const afterAmp = validateAmpersand(xmlData, i);
              if (afterAmp == -1)
                return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
              i = afterAmp;
            }
          } //end of reading tag text value
          if (xmlData[i] === '<') {
            i--;
          }
        }
      } else {
        if (xmlData[i] === ' ' || xmlData[i] === '\t' || xmlData[i] === '\n' || xmlData[i] === '\r') {
          continue;
        }
        return getErrorObject('InvalidChar', "char '"+xmlData[i]+"' is not expected.", getLineNumberForPosition(xmlData, i));
      }
    }
  
    if (!tagFound) {
      return getErrorObject('InvalidXml', 'Start tag expected.', 1);
    } else if (tags.length > 0) {
      return getErrorObject('InvalidXml', "Invalid '"+JSON.stringify(tags, null, 4).replace(/\r?\n/g, '')+"' found.", 1);
    }
  
    return true;
  };
  
  /**
   * Read Processing insstructions and skip
   * @param {*} xmlData
   * @param {*} i
   */
  function readPI(xmlData, i) {
    var start = i;
    for (; i < xmlData.length; i++) {
      if (xmlData[i] == '?' || xmlData[i] == ' ') {
        //tagname
        var tagname = xmlData.substr(start, i - start);
        if (i > 5 && tagname === 'xml') {
          return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));
        } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {
          //check if valid attribut string
          i++;
          break;
        } else {
          continue;
        }
      }
    }
    return i;
  }
  
  function readCommentAndCDATA(xmlData, i) {
    if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {
      //comment
      for (i += 3; i < xmlData.length; i++) {
        if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {
          i += 2;
          break;
        }
      }
    } else if (
      xmlData.length > i + 8 &&
      xmlData[i + 1] === 'D' &&
      xmlData[i + 2] === 'O' &&
      xmlData[i + 3] === 'C' &&
      xmlData[i + 4] === 'T' &&
      xmlData[i + 5] === 'Y' &&
      xmlData[i + 6] === 'P' &&
      xmlData[i + 7] === 'E'
    ) {
      let angleBracketsCount = 1;
      for (i += 8; i < xmlData.length; i++) {
        if (xmlData[i] === '<') {
          angleBracketsCount++;
        } else if (xmlData[i] === '>') {
          angleBracketsCount--;
          if (angleBracketsCount === 0) {
            break;
          }
        }
      }
    } else if (
      xmlData.length > i + 9 &&
      xmlData[i + 1] === '[' &&
      xmlData[i + 2] === 'C' &&
      xmlData[i + 3] === 'D' &&
      xmlData[i + 4] === 'A' &&
      xmlData[i + 5] === 'T' &&
      xmlData[i + 6] === 'A' &&
      xmlData[i + 7] === '['
    ) {
      for (i += 8; i < xmlData.length; i++) {
        if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {
          i += 2;
          break;
        }
      }
    }
  
    return i;
  }
  
  var doubleQuote = '"';
  var singleQuote = "'";
  
  /**
   * Keep reading xmlData until '<' is found outside the attribute value.
   * @param {string} xmlData
   * @param {number} i
   */
  function readAttributeStr(xmlData, i) {
    let attrStr = '';
    let startChar = '';
    let tagClosed = false;
    for (; i < xmlData.length; i++) {
      if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
        if (startChar === '') {
          startChar = xmlData[i];
        } else if (startChar !== xmlData[i]) {
          //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa
          continue;
        } else {
          startChar = '';
        }
      } else if (xmlData[i] === '>') {
        if (startChar === '') {
          tagClosed = true;
          break;
        }
      }
      attrStr += xmlData[i];
    }
    if (startChar !== '') {
      return false;
    }
  
    return {
      value: attrStr,
      index: i,
      tagClosed: tagClosed
    };
  }
  
  /**
   * Select all the attributes whether valid or invalid.
   */
  const validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g');
  
  //attr, ="sd", a="amit's", a="sd"b="saf", ab  cd=""
  
  function validateAttributeString(attrStr, options) {
    //console.log("start:"+attrStr+":end");
  
    //if(attrStr.trim().length === 0) return true; //empty string
  
    const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
    const attrNames = {};
  
    for (let i = 0; i < matches.length; i++) {
      if (matches[i][1].length === 0) {
        //nospace before attribute name: a="sd"b="saf"
        return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(attrStr, matches[i][0]))
      } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
        //independent attribute: ab
        return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(attrStr, matches[i][0]));
      }
      /* else if(matches[i][6] === undefined){//attribute without value: ab=
                      return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}};
                  } */
      const attrName = matches[i][2];
      if (!validateAttrName(attrName)) {
        return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(attrStr, matches[i][0]));
      }
      if (!attrNames.hasOwnProperty(attrName)) {
        //check for duplicate attribute.
        attrNames[attrName] = 1;
      } else {
        return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(attrStr, matches[i][0]));
      }
    }
  
    return true;
  }
  
  function validateNumberAmpersand(xmlData, i) {
    let re = /\d/;
    if (xmlData[i] === 'x') {
      i++;
      re = /[\da-fA-F]/;
    }
    for (; i < xmlData.length; i++) {
      if (xmlData[i] === ';')
        return i;
      if (!xmlData[i].match(re))
        break;
    }
    return -1;
  }
  
  function validateAmpersand(xmlData, i) {
    // https://www.w3.org/TR/xml/#dt-charref
    i++;
    if (xmlData[i] === ';')
      return -1;
    if (xmlData[i] === '#') {
      i++;
      return validateNumberAmpersand(xmlData, i);
    }
    let count = 0;
    for (; i < xmlData.length; i++, count++) {
      if (xmlData[i].match(/\w/) && count < 20)
        continue;
      if (xmlData[i] === ';')
        break;
      return -1;
    }
    return i;
  }
  
  function getErrorObject(code, message, lineNumber) {
    return {
      err: {
        code: code,
        msg: message,
        line: lineNumber,
      },
    };
  }
  
  function validateAttrName(attrName) {
    return util.isName(attrName);
  }
  
  // const startsWithXML = /^xml/i;
  
  function validateTagName(tagname) {
    return util.isName(tagname) /* && !tagname.match(startsWithXML) */;
  }
  
  //this function returns the line number for the character at the given index
  function getLineNumberForPosition(xmlData, index) {
    var lines = xmlData.substring(0, index).split(/\r?\n/);
    return lines.length;
  }
  
  //this function returns the position of the last character of match within attrStr
  function getPositionFromMatch(attrStr, match) {
    return attrStr.indexOf(match) + match.length;
  }
  
  
  /***/ }),
  /* 972 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = void 0;
  const path = __importStar(__webpack_require__(622));
  const assert_1 = __importDefault(__webpack_require__(357));
  const IS_WINDOWS = process.platform === 'win32';
  /**
   * Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths.
   *
   * For example, on Linux/macOS:
   * - `/               => /`
   * - `/hello          => /`
   *
   * For example, on Windows:
   * - `C:\             => C:\`
   * - `C:\hello        => C:\`
   * - `C:              => C:`
   * - `C:hello         => C:`
   * - `\               => \`
   * - `\hello          => \`
   * - `\\hello         => \\hello`
   * - `\\hello\world   => \\hello\world`
   */
  function dirname(p) {
      // Normalize slashes and trim unnecessary trailing slash
      p = safeTrimTrailingSeparator(p);
      // Windows UNC root, e.g. \\hello or \\hello\world
      if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) {
          return p;
      }
      // Get dirname
      let result = path.dirname(p);
      // Trim trailing slash for Windows UNC root, e.g. \\hello\world\
      if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) {
          result = safeTrimTrailingSeparator(result);
      }
      return result;
  }
  exports.dirname = dirname;
  /**
   * Roots the path if not already rooted. On Windows, relative roots like `\`
   * or `C:` are expanded based on the current working directory.
   */
  function ensureAbsoluteRoot(root, itemPath) {
      assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`);
      assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`);
      // Already rooted
      if (hasAbsoluteRoot(itemPath)) {
          return itemPath;
      }
      // Windows
      if (IS_WINDOWS) {
          // Check for itemPath like C: or C:foo
          if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) {
              let cwd = process.cwd();
              assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
              // Drive letter matches cwd? Expand to cwd
              if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) {
                  // Drive only, e.g. C:
                  if (itemPath.length === 2) {
                      // Preserve specified drive letter case (upper or lower)
                      return `${itemPath[0]}:\\${cwd.substr(3)}`;
                  }
                  // Drive + path, e.g. C:foo
                  else {
                      if (!cwd.endsWith('\\')) {
                          cwd += '\\';
                      }
                      // Preserve specified drive letter case (upper or lower)
                      return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`;
                  }
              }
              // Different drive
              else {
                  return `${itemPath[0]}:\\${itemPath.substr(2)}`;
              }
          }
          // Check for itemPath like \ or \foo
          else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) {
              const cwd = process.cwd();
              assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`);
              return `${cwd[0]}:\\${itemPath.substr(1)}`;
          }
      }
      assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`);
      // Otherwise ensure root ends with a separator
      if (root.endsWith('/') || (IS_WINDOWS && root.endsWith('\\'))) {
          // Intentionally empty
      }
      else {
          // Append separator
          root += path.sep;
      }
      return root + itemPath;
  }
  exports.ensureAbsoluteRoot = ensureAbsoluteRoot;
  /**
   * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like:
   * `\\hello\share` and `C:\hello` (and using alternate separator).
   */
  function hasAbsoluteRoot(itemPath) {
      assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`);
      // Normalize separators
      itemPath = normalizeSeparators(itemPath);
      // Windows
      if (IS_WINDOWS) {
          // E.g. \\hello\share or C:\hello
          return itemPath.startsWith('\\\\') || /^[A-Z]:\\/i.test(itemPath);
      }
      // E.g. /hello
      return itemPath.startsWith('/');
  }
  exports.hasAbsoluteRoot = hasAbsoluteRoot;
  /**
   * On Linux/macOS, true if path starts with `/`. On Windows, true for paths like:
   * `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator).
   */
  function hasRoot(itemPath) {
      assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`);
      // Normalize separators
      itemPath = normalizeSeparators(itemPath);
      // Windows
      if (IS_WINDOWS) {
          // E.g. \ or \hello or \\hello
          // E.g. C: or C:\hello
          return itemPath.startsWith('\\') || /^[A-Z]:/i.test(itemPath);
      }
      // E.g. /hello
      return itemPath.startsWith('/');
  }
  exports.hasRoot = hasRoot;
  /**
   * Removes redundant slashes and converts `/` to `\` on Windows
   */
  function normalizeSeparators(p) {
      p = p || '';
      // Windows
      if (IS_WINDOWS) {
          // Convert slashes on Windows
          p = p.replace(/\//g, '\\');
          // Remove redundant slashes
          const isUnc = /^\\\\+[^\\]/.test(p); // e.g. \\hello
          return (isUnc ? '\\' : '') + p.replace(/\\\\+/g, '\\'); // preserve leading \\ for UNC
      }
      // Remove redundant slashes
      return p.replace(/\/\/+/g, '/');
  }
  exports.normalizeSeparators = normalizeSeparators;
  /**
   * Normalizes the path separators and trims the trailing separator (when safe).
   * For example, `/foo/ => /foo` but `/ => /`
   */
  function safeTrimTrailingSeparator(p) {
      // Short-circuit if empty
      if (!p) {
          return '';
      }
      // Normalize separators
      p = normalizeSeparators(p);
      // No trailing slash
      if (!p.endsWith(path.sep)) {
          return p;
      }
      // Check '/' on Linux/macOS and '\' on Windows
      if (p === path.sep) {
          return p;
      }
      // On Windows check if drive root. E.g. C:\
      if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) {
          return p;
      }
      // Otherwise trim trailing slash
      return p.substr(0, p.length - 1);
  }
  exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator;
  //# sourceMappingURL=internal-path-helper.js.map
  
  /***/ }),
  /* 973 */,
  /* 974 */,
  /* 975 */,
  /* 976 */,
  /* 977 */,
  /* 978 */,
  /* 979 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  
  var constructN =
  /*#__PURE__*/
  __webpack_require__(768);
  /**
   * Wraps a constructor function inside a curried function that can be called
   * with the same arguments and returns the same type.
   *
   * @func
   * @memberOf R
   * @since v0.1.0
   * @category Function
   * @sig (* -> {*}) -> (* -> {*})
   * @param {Function} fn The constructor function to wrap.
   * @return {Function} A wrapped, curried constructor function.
   * @see R.invoker
   * @example
   *
   *      // Constructor function
   *      function Animal(kind) {
   *        this.kind = kind;
   *      };
   *      Animal.prototype.sighting = function() {
   *        return "It's a " + this.kind + "!";
   *      }
   *
   *      const AnimalConstructor = R.construct(Animal)
   *
   *      // Notice we no longer need the 'new' keyword:
   *      AnimalConstructor('Pig'); //=> {"kind": "Pig", "sighting": function (){...}};
   *
   *      const animalTypes = ["Lion", "Tiger", "Bear"];
   *      const animalSighting = R.invoker(0, 'sighting');
   *      const sightNewAnimal = R.compose(animalSighting, AnimalConstructor);
   *      R.map(sightNewAnimal, animalTypes); //=> ["It's a Lion!", "It's a Tiger!", "It's a Bear!"]
   */
  
  
  var construct =
  /*#__PURE__*/
  _curry1(function construct(Fn) {
    return constructN(Fn.length, Fn);
  });
  
  module.exports = construct;
  
  /***/ }),
  /* 980 */,
  /* 981 */
  /***/ (function(module) {
  
  "use strict";
  
  
  // See http://www.robvanderwoude.com/escapechars.php
  const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
  
  function escapeCommand(arg) {
      // Escape meta chars
      arg = arg.replace(metaCharsRegExp, '^$1');
  
      return arg;
  }
  
  function escapeArgument(arg, doubleEscapeMetaChars) {
      // Convert to string
      arg = `${arg}`;
  
      // Algorithm below is based on https://qntm.org/cmd
  
      // Sequence of backslashes followed by a double quote:
      // double up all the backslashes and escape the double quote
      arg = arg.replace(/(\\*)"/g, '$1$1\\"');
  
      // Sequence of backslashes followed by the end of the string
      // (which will become a double quote later):
      // double up all the backslashes
      arg = arg.replace(/(\\*)$/, '$1$1');
  
      // All other backslashes occur literally
  
      // Quote the whole thing:
      arg = `"${arg}"`;
  
      // Escape meta chars
      arg = arg.replace(metaCharsRegExp, '^$1');
  
      // Double escape meta chars if necessary
      if (doubleEscapeMetaChars) {
          arg = arg.replace(metaCharsRegExp, '^$1');
      }
  
      return arg;
  }
  
  module.exports.command = escapeCommand;
  module.exports.argument = escapeArgument;
  
  
  /***/ }),
  /* 982 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _xfBase =
  /*#__PURE__*/
  __webpack_require__(60);
  
  var XFindLastIndex =
  /*#__PURE__*/
  function () {
    function XFindLastIndex(f, xf) {
      this.xf = xf;
      this.f = f;
      this.idx = -1;
      this.lastIdx = -1;
    }
  
    XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;
  
    XFindLastIndex.prototype['@@transducer/result'] = function (result) {
      return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));
    };
  
    XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {
      this.idx += 1;
  
      if (this.f(input)) {
        this.lastIdx = this.idx;
      }
  
      return result;
    };
  
    return XFindLastIndex;
  }();
  
  var _xfindLastIndex =
  /*#__PURE__*/
  _curry2(function _xfindLastIndex(f, xf) {
    return new XFindLastIndex(f, xf);
  });
  
  module.exports = _xfindLastIndex;
  
  /***/ }),
  /* 983 */,
  /* 984 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _pipeP =
  /*#__PURE__*/
  __webpack_require__(985);
  
  var reduce =
  /*#__PURE__*/
  __webpack_require__(46);
  
  var tail =
  /*#__PURE__*/
  __webpack_require__(193);
  /**
   * Performs left-to-right composition of one or more Promise-returning
   * functions. The first argument may have any arity; the remaining arguments
   * must be unary.
   *
   * @func
   * @memberOf R
   * @since v0.10.0
   * @category Function
   * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)
   * @param {...Function} functions
   * @return {Function}
   * @see R.composeP
   * @deprecated since v0.26.0
   * @example
   *
   *      //  followersForUser :: String -> Promise [User]
   *      const followersForUser = R.pipeP(db.getUserById, db.getFollowers);
   */
  
  
  function pipeP() {
    if (arguments.length === 0) {
      throw new Error('pipeP requires at least one argument');
    }
  
    return _arity(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));
  }
  
  module.exports = pipeP;
  
  /***/ }),
  /* 985 */
  /***/ (function(module) {
  
  function _pipeP(f, g) {
    return function () {
      var ctx = this;
      return f.apply(ctx, arguments).then(function (x) {
        return g.call(ctx, x);
      });
    };
  }
  
  module.exports = _pipeP;
  
  /***/ }),
  /* 986 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry3 =
  /*#__PURE__*/
  __webpack_require__(78);
  /**
   * Tests the final argument by passing it to the given predicate function. If
   * the predicate is not satisfied, the function will return the result of
   * calling the `whenFalseFn` function with the same argument. If the predicate
   * is satisfied, the argument is returned as is.
   *
   * @func
   * @memberOf R
   * @since v0.18.0
   * @category Logic
   * @sig (a -> Boolean) -> (a -> a) -> a -> a
   * @param {Function} pred        A predicate function
   * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates
   *                               to a falsy value.
   * @param {*}        x           An object to test with the `pred` function and
   *                               pass to `whenFalseFn` if necessary.
   * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.
   * @see R.ifElse, R.when, R.cond
   * @example
   *
   *      let safeInc = R.unless(R.isNil, R.inc);
   *      safeInc(null); //=> null
   *      safeInc(1); //=> 2
   */
  
  
  var unless =
  /*#__PURE__*/
  _curry3(function unless(pred, whenFalseFn, x) {
    return pred(x) ? x : whenFalseFn(x);
  });
  
  module.exports = unless;
  
  /***/ }),
  /* 987 */,
  /* 988 */,
  /* 989 */
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  const nodeToJson = __webpack_require__(727);
  const xmlToNodeobj = __webpack_require__(170);
  const x2xmlnode = __webpack_require__(170);
  const buildOptions = __webpack_require__(343).buildOptions;
  const validator = __webpack_require__(971);
  
  exports.parse = function(xmlData, options, validationOption) {
    if( validationOption){
      if(validationOption === true) validationOption = {}
      
      const result = validator.validate(xmlData, validationOption);
      if (result !== true) {
        throw Error( result.err.msg)
      }
    }
    options = buildOptions(options, x2xmlnode.defaultOptions, x2xmlnode.props);
    const traversableObj = xmlToNodeobj.getTraversalObj(xmlData, options)
    //print(traversableObj, "  ");
    return nodeToJson.convertToJson(traversableObj, options);
  };
  exports.convertTonimn = __webpack_require__(961).convert2nimn;
  exports.getTraversalObj = xmlToNodeobj.getTraversalObj;
  exports.convertToJson = nodeToJson.convertToJson;
  exports.convertToJsonString = __webpack_require__(207).convertToJsonString;
  exports.validate = validator.validate;
  exports.j2xParser = __webpack_require__(200);
  exports.parseToNimn = function(xmlData, schema, options) {
    return exports.convertTonimn(exports.getTraversalObj(xmlData, options), schema, options);
  };
  
  
  function print(xmlNode, indentation){
    if(xmlNode){
      console.log(indentation + "{")
      console.log(indentation + "  \"tagName\": \"" + xmlNode.tagname + "\", ");
      if(xmlNode.parent){
        console.log(indentation + "  \"parent\": \"" + xmlNode.parent.tagname  + "\", ");
      }
      console.log(indentation + "  \"val\": \"" + xmlNode.val  + "\", ");
      console.log(indentation + "  \"attrs\": " + JSON.stringify(xmlNode.attrsMap,null,4)  + ", ");
  
      if(xmlNode.child){
        console.log(indentation + "\"child\": {")
        const indentation2 = indentation + indentation;
        Object.keys(xmlNode.child).forEach( function(key) {
          const node = xmlNode.child[key];
  
          if(Array.isArray(node)){
            console.log(indentation +  "\""+key+"\" :[")
            node.forEach( function(item,index) {
              //console.log(indentation + " \""+index+"\" : [")
              print(item, indentation2);
            })
            console.log(indentation + "],")  
          }else{
            console.log(indentation + " \""+key+"\" : {")
            print(node, indentation2);
            console.log(indentation + "},")  
          }
        });
        console.log(indentation + "},")
      }
      console.log(indentation + "},")
    }
  }
  
  
  /***/ }),
  /* 990 */,
  /* 991 */,
  /* 992 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry1 =
  /*#__PURE__*/
  __webpack_require__(721);
  /**
   * Transposes the rows and columns of a 2D list.
   * When passed a list of `n` lists of length `x`,
   * returns a list of `x` lists of length `n`.
   *
   *
   * @func
   * @memberOf R
   * @since v0.19.0
   * @category List
   * @sig [[a]] -> [[a]]
   * @param {Array} list A 2D list
   * @return {Array} A 2D list
   * @example
   *
   *      R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]
   *      R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]
   *
   *      // If some of the rows are shorter than the following rows, their elements are skipped:
   *      R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]
   * @symb R.transpose([[a], [b], [c]]) = [a, b, c]
   * @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]]
   * @symb R.transpose([[a, b], [c]]) = [[a, c], [b]]
   */
  
  
  var transpose =
  /*#__PURE__*/
  _curry1(function transpose(outerlist) {
    var i = 0;
    var result = [];
  
    while (i < outerlist.length) {
      var innerlist = outerlist[i];
      var j = 0;
  
      while (j < innerlist.length) {
        if (typeof result[j] === 'undefined') {
          result[j] = [];
        }
  
        result[j].push(innerlist[j]);
        j += 1;
      }
  
      i += 1;
    }
  
    return result;
  });
  
  module.exports = transpose;
  
  /***/ }),
  /* 993 */,
  /* 994 */,
  /* 995 */,
  /* 996 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var equals =
  /*#__PURE__*/
  __webpack_require__(701);
  
  var take =
  /*#__PURE__*/
  __webpack_require__(498);
  /**
   * Checks if a list starts with the provided sublist.
   *
   * Similarly, checks if a string starts with the provided substring.
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category List
   * @sig [a] -> [a] -> Boolean
   * @sig String -> String -> Boolean
   * @param {*} prefix
   * @param {*} list
   * @return {Boolean}
   * @see R.endsWith
   * @example
   *
   *      R.startsWith('a', 'abc')                //=> true
   *      R.startsWith('b', 'abc')                //=> false
   *      R.startsWith(['a'], ['a', 'b', 'c'])    //=> true
   *      R.startsWith(['b'], ['a', 'b', 'c'])    //=> false
   */
  
  
  var startsWith =
  /*#__PURE__*/
  _curry2(function (prefix, list) {
    return equals(take(prefix.length, list), prefix);
  });
  
  module.exports = startsWith;
  
  /***/ }),
  /* 997 */,
  /* 998 */,
  /* 999 */
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var _arity =
  /*#__PURE__*/
  __webpack_require__(451);
  
  var _curry2 =
  /*#__PURE__*/
  __webpack_require__(830);
  
  var _has =
  /*#__PURE__*/
  __webpack_require__(390);
  /**
   * Creates a new function that, when invoked, caches the result of calling `fn`
   * for a given argument set and returns the result. Subsequent calls to the
   * memoized `fn` with the same argument set will not result in an additional
   * call to `fn`; instead, the cached result for that set of arguments will be
   * returned.
   *
   *
   * @func
   * @memberOf R
   * @since v0.24.0
   * @category Function
   * @sig (*... -> String) -> (*... -> a) -> (*... -> a)
   * @param {Function} fn The function to generate the cache key.
   * @param {Function} fn The function to memoize.
   * @return {Function} Memoized version of `fn`.
   * @example
   *
   *      let count = 0;
   *      const factorial = R.memoizeWith(R.identity, n => {
   *        count += 1;
   *        return R.product(R.range(1, n + 1));
   *      });
   *      factorial(5); //=> 120
   *      factorial(5); //=> 120
   *      factorial(5); //=> 120
   *      count; //=> 1
   */
  
  
  var memoizeWith =
  /*#__PURE__*/
  _curry2(function memoizeWith(mFn, fn) {
    var cache = {};
    return _arity(fn.length, function () {
      var key = mFn.apply(this, arguments);
  
      if (!_has(key, cache)) {
        cache[key] = fn.apply(this, arguments);
      }
  
      return cache[key];
    });
  });
  
  module.exports = memoizeWith;
  
  /***/ })
  /******/ ]);