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__(676);
  /******/ 	};
  /******/ 	// initialize runtime
  /******/ 	runtime(__webpack_require__);
  /******/
  /******/ 	// run startup
  /******/ 	return startup();
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const { requestLog } = __webpack_require__(916);
  const {
    restEndpointMethods
  } = __webpack_require__(842);
  
  const Core = __webpack_require__(529);
  
  const CORE_PLUGINS = [
    __webpack_require__(190),
    __webpack_require__(19), // deprecated: remove in v17
    requestLog,
    __webpack_require__(148),
    restEndpointMethods,
    __webpack_require__(430),
  
    __webpack_require__(850) // deprecated: remove in v17
  ];
  
  const OctokitRest = Core.plugin(CORE_PLUGINS);
  
  function DeprecatedOctokit(options) {
    const warn =
      options && options.log && options.log.warn
        ? options.log.warn
        : console.warn;
    warn(
      '[@octokit/rest] `const Octokit = require("@octokit/rest")` is deprecated. Use `const { Octokit } = require("@octokit/rest")` instead'
    );
    return new OctokitRest(options);
  }
  
  const Octokit = Object.assign(DeprecatedOctokit, {
    Octokit: OctokitRest
  });
  
  Object.keys(OctokitRest).forEach(key => {
    /* istanbul ignore else */
    if (OctokitRest.hasOwnProperty(key)) {
      Octokit[key] = OctokitRest[key];
    }
  });
  
  module.exports = Octokit;
  
  
  /***/ }),
  
  /***/ 1:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  /*
   * Dependencies.
   */
  
  var trim = __webpack_require__(860);
  var detab = __webpack_require__(224);
  var collapse = __webpack_require__(724);
  var normalizeURI = __webpack_require__(325);
  var trimLines = __webpack_require__(882);
  var visit = __webpack_require__(296);
  var h = __webpack_require__(602);
  
  /*
   * Constants.
   */
  
  var FIRST_WORD = /^[^\ \t]+(?=[\ \t]|$)/;
  
  /*
   * Compilers.
   */
  
  var visitors = {};
  
  /**
   * Return the content of a reference without definition
   * as markdown.
   *
   * @example
   *   failsafe({
   *     identifier: 'foo',
   *     referenceType: 'shortcut',
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }, {}); // '[foo]'
   *
   * @param {Node} node - Node to compile.
   * @param {Node?} definition
   * @param {HTMLCompiler} context
   * @return {string?} - If without definition, returns a
   *   string, returns nothing otherwise.
   */
  function failsafe(node, definition, context) {
      var result;
  
      if (node.referenceType === 'shortcut' && !definition.link) {
          result = node.children ? context.all(node).join('') : node.alt;
  
          return (node.type === 'imageReference' ? '!' : '') +
              '[' + result + ']';
      }
  
      return '';
  }
  
  /**
   * Stringify all footnote definitions, if any.
   *
   * @example
   *   generateFootnotes(); // '<div class="footnotes">\n<hr>\n...'
   *
   * @return {string} - Compiled footnotes, if any.
   * @this {HTMLCompiler}
   */
  function generateFootnotes() {
      var self = this;
      var definitions = self.footnotes;
      var length = definitions.length;
      var index = -1;
      var results = [];
      var def;
      var content;
  
      if (!length) {
          return '';
      }
  
      while (++index < length) {
          def = definitions[index];
  
          results[index] = self.listItem({
              'type': 'listItem',
              'attributes': {
                  'id': 'fn-' + def.identifier
              },
              'children': def.children.concat({
                  'type': 'link',
                  'href': '#fnref-' + def.identifier,
                  'attributes': {
                      'class': 'footnote-backref'
                  },
                  'children': [{
                      'type': 'text',
                      'value': '↩'
                  }]
              }),
              'position': def.position
          }, {});
      }
  
      content = h(self, null, 'hr') + '\n' +
          h(self, null, 'ol', results.join('\n'), true);
  
      return h(self, null, 'div', {
          'class': 'footnotes'
      }, content, true) + '\n';
  }
  
  /**
   * Stringify the children of `node`.
   *
   * @example
   *   all({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // 'foo'
   *
   * @param {Node} parent
   * @return {Array.<string>}
   * @this {HTMLCompiler}
   */
  function all(parent) {
      var self = this;
      var nodes = parent.children;
      var values = [];
      var index = -1;
      var length = nodes.length;
      var value;
      var prev;
  
      while (++index < length) {
          value = self.visit(nodes[index], parent);
  
          if (value) {
              if (
                  prev &&
                  (
                      prev.type === 'break' ||
                      (prev.type === 'escape' && prev.value === '\n')
                  )
              ) {
                  value = trim.left(value);
              }
  
              values.push(value);
          }
  
          prev = nodes[index];
      }
  
      return values;
  }
  
  /**
   * Stringify a root object.
   *
   * @example
   *   // This will additionally include defined footnotes,
   *   // when applicable.
   *   root({
   *     children: [
   *       {
   *         type: 'paragraph',
   *         children: [
   *           {
   *             type: 'text',
   *             value: 'foo'
   *           }
   *         ]
   *       }
   *     ]
   *   }); // '<p>foo</p>\n'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function root(node) {
      var self = this;
      var definitions = {};
      var footnotes = [];
      var result;
  
      self.definitions = definitions;
      self.footnotes = footnotes;
  
      visit(node, 'definition', function (definition) {
          definitions[definition.identifier.toUpperCase()] = definition;
      });
  
      visit(node, 'footnoteDefinition', function (definition) {
          footnotes.push(definition);
      });
  
      result = self.all(node).join('\n');
  
      return (result ? result + '\n' : '') + self.generateFootnotes();
  }
  
  /**
   * Stringify a block quote.
   *
   * @example
   *   blockquote({
   *     children: [
   *       {
   *         type: 'paragraph',
   *         children: [
   *           {
   *             type: 'text',
   *             value: 'foo'
   *           }
   *         ]
   *       }
   *     ]
   *   }); // '<blockquote>\n<p>foo</p>\n</blockquote>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function blockquote(node) {
      return h(this, node, 'blockquote', this.all(node).join('\n'), true);
  }
  
  /**
   * Stringify an inline footnote.
   *
   * @example
   *   // This additionally adds a definition at the bottem
   *   // of the document.
   *   footnote({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '<sup id="fnref-1"><a href="#fn-1">1</a></sup>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function footnote(node) {
      var self = this;
      var definitions = self.footnotes;
      var index = -1;
      var length = definitions.length;
      var identifiers = [];
      var identifier;
  
      while (++index < length) {
          identifiers[index] = definitions[index].identifier;
      }
  
      index = -1;
      identifier = 1;
  
      while (identifiers.indexOf(String(identifier)) !== -1) {
          identifier++;
      }
  
      identifier = String(identifier);
  
      self.footnotes.push({
          'type': 'footnoteDefinition',
          'identifier': identifier,
          'children': node.children,
          'position': node.position
      });
  
      return self.footnoteReference({
          'type': 'footnoteReference',
          'identifier': identifier,
          'position': node.position
      });
  }
  
  /**
   * Stringify a list.
   *
   * @example
   *   list({
   *     ordered: true
   *     loose: false
   *     children: [
   *       {
   *         type: 'listItem',
   *         children: [
   *           {
   *             type: 'paragraph',
   *             children: [
   *               {
   *                 type: 'text',
   *                 value: 'foo'
   *               }
   *             ]
   *           }
   *         ]
   *       }
   *     ]
   *   }); // '<ol>\n<li>foo</li>\n</ol>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function list(node) {
      return h(this, node, node.ordered ? 'ol' : 'ul', {
          'start': node.start !== 1 ? node.start : null
      }, this.all(node).join('\n'), true);
  }
  
  /**
   * Stringify a list-item.
   *
   * @example
   *   listItem({
   *     children: [
   *       {
   *         type: 'paragraph',
   *         children: [
   *           {
   *             type: 'text',
   *             value: 'foo'
   *           }
   *         ]
   *       }
   *     ]
   *   }, {
   *     loose: false
   *   }); // '<li>foo</li>'
   *
   * @param {Node} node - Node to compile.
   * @param {Node} parent - Parent of `node`.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function listItem(node, parent) {
      var item = node;
      var single;
      var result;
  
      single = !parent.loose &&
          node.children.length === 1 &&
          node.children[0].children;
  
      result = this.all(single ? item.children[0] : item)
          .join(single ? '' : '\n');
  
      return h(this, node, 'li', result, !single);
  }
  
  /**
   * Stringify a heading.
   *
   * @example
   *   heading({
   *     depth: 3,
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '<h3>foo</h3>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function heading(node) {
      return h(this, node, 'h' + node.depth, this.all(node).join(''));
  }
  
  /**
   * Stringify a paragraph.
   *
   * @example
   *   paragraph({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // 'foo'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function paragraph(node) {
      return h(this, node, 'p', trim(detab(this.all(node).join(''))), false);
  }
  
  /**
   * Stringify a code block.
   *
   * @example
   *   code({
   *     value: 'foo &amp; bar;'
   *   }); // '<pre><code>foo &amp;amp; bar\n</code></pre>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function code(node) {
      var self = this;
      var value = node.value ? detab(node.value + '\n') : '';
      var language = node.lang && node.lang.match(FIRST_WORD);
  
      return h(self, node, 'pre', h(self, node, 'code', {
          'class': language ? 'language-' + language[0] : null
      }, self.encode(value), false), false);
  }
  
  /**
   * Stringify a table.
   *
   * @example
   *   table({
   *     children: [
   *       {
   *         type: 'tableRow',
   *         ...
   *       }
   *     ]
   *   }); // '<table><thead>...'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function table(node) {
      var self = this;
      var rows = node.children;
      var index = rows.length;
      var align = node.align;
      var alignLength = align.length;
      var pos;
      var result = [];
      var row;
      var out;
      var name;
  
      while (index--) {
          pos = alignLength;
          row = rows[index].children;
          out = [];
          name = index === 0 ? 'th' : 'td';
  
          while (pos--) {
              out[pos] = h(self, row[pos], name, {
                  'align': align[pos]
              }, row[pos] ? self.all(row[pos]).join('\n') : '');
          }
  
          result[index] = h(self, rows[index], 'tr', out.join('\n'), true);
      }
  
      return h(self, node, 'table',
          h(self, node, 'thead', result[0], true) + '\n' +
          h(self, node, 'tbody', result.slice(1).join('\n'), true),
          true
      );
  }
  
  /**
   * Stringify a literal HTML.
   *
   * @example
   *   html({
   *     value: '<i>italic</i>'
   *   }); // '<i>italic</i>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function html(node) {
      return this.options.sanitize ? this.encode(node.value) : node.value;
  }
  
  /**
   * Stringify a horizontal rule.
   *
   * @example
   *   rule(); // '<hr>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function rule(node) {
      return h(this, node, 'hr');
  }
  
  /**
   * Stringify inline code.
   *
   * @example
   *   inlineCode({
   *     value: 'foo &amp; bar;'
   *   }); // '<code>foo &amp;amp; bar;</code>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function inlineCode(node) {
      return h(this, node, 'code', collapse(this.encode(node.value)));
  }
  
  /**
   * Stringify strongly emphasised content.
   *
   * @example
   *   strong({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '<strong>foo</strong>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function strong(node) {
      return h(this, node, 'strong', this.all(node).join(''));
  }
  
  /**
   * Stringify emphasised content.
   *
   * @example
   *   emphasis({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '<em>foo</em>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function emphasis(node) {
      return h(this, node, 'em', this.all(node).join(''));
  }
  
  /**
   * Stringify an inline break.
   *
   * @example
   *   hardBreak(); // '<br>\n'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function hardBreak(node) {
      return h(this, node, 'br') + '\n';
  }
  
  /**
   * Stringify a link.
   *
   * @example
   *   link({
   *     href: 'http://example.com',
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '<a href="http://example.com">foo</a>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function link(node) {
      return h(this, node, 'a', {
          'href': normalizeURI(node.href),
          'title': node.title
      }, this.all(node).join(''));
  }
  
  /**
   * Stringify a reference to a footnote.
   *
   * @example
   *   // If a definition was added previously:
   *   footnoteReference({
   *     identifier: 'foo'
   *   }); // '<sup id="fnref-foo"><a href="#fn-foo">foo</a></sup>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function footnoteReference(node) {
      var identifier = node.identifier;
  
      return h(this, node, 'sup', {
          'id': 'fnref-' + identifier
      }, h(this, node, 'a', {
          'href': '#fn-' + identifier,
          'class': 'footnote-ref'
      }, identifier));
  }
  
  /**
   * Stringify a reference to a link.
   *
   * @example
   *   // If a definition was added previously:
   *   linkReference({
   *     identifier: 'foo'
   *   }); // '<a href="http://example.com/fav.ico"></a>'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function linkReference(node) {
      var self = this;
      var def = self.definitions[node.identifier.toUpperCase()] || {};
  
      return failsafe(node, def, self) || h(self, node, 'a', {
          'href': normalizeURI(def.link || ''),
          'title': def.title
      }, self.all(node).join(''));
  }
  
  /**
   * Stringify a reference to an image.
   *
   * @example
   *   // If a definition was added previously:
   *   imageReference({
   *     identifier: 'foo'
   *   }); // '<img src="http://example.com/fav.ico" alt="">'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function imageReference(node) {
      var self = this;
      var def = self.definitions[node.identifier.toUpperCase()] || {};
  
      return failsafe(node, def, self) || h(self, node, 'img', {
          'src': normalizeURI(def.link || ''),
          'alt': node.alt || '',
          'title': def.title
      });
  }
  
  /**
   * Stringify an image.
   *
   * @example
   *   image({
   *     src: 'http://example.com/fav.ico'
   *   }); // '<img src="http://example.com/fav.ico" alt="">'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function image(node) {
      return h(this, node, 'img', {
          'src': normalizeURI(node.src),
          'alt': node.alt || '',
          'title': node.title
      });
  }
  
  /**
   * Stringify a deletion.
   *
   * @example
   *   strikethrough({
   *     children: [
   *       {
   *         type: 'text',
   *         value: 'foo'
   *       }
   *     ]
   *   }); // '~~foo~~'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function strikethrough(node) {
      return h(this, node, 'del', this.all(node).join(''));
  }
  
  /**
   * Stringify text.
   *
   * @example
   *   text({value: '&'}); // '&amp;'
   *
   *   text({value: 'foo'}); // 'foo'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function text(node) {
      return trimLines(this.encode(node.value));
  }
  
  /**
   * Stringify escaped text.
   *
   * @example
   *   escape({value: '\n'}); // '<br>\n'
   *
   *   escape({value: '|'}); // '\\|'
   *
   * @param {Node} node - Node to compile.
   * @return {string} - Compiled node.
   * @this {HTMLCompiler}
   */
  function escape(node) {
      return this[node.value === '\n' ? 'break' : 'text'](node);
  }
  
  /**
   * Return an empty string for nodes which are ignored.
   *
   * @example
   *   ignore(); // ''
   *
   * @return {string} - Empty string.
   * @this {HTMLCompiler}
   */
  function ignore() {
      return '';
  }
  
  /*
   * Helpers.
   */
  
  visitors.all = all;
  visitors.generateFootnotes = generateFootnotes;
  
  /*
   * Ignored nodes.
   */
  
  visitors.yaml = ignore;
  visitors.definition = ignore;
  visitors.footnoteDefinition = ignore;
  
  /*
   * Compilers.
   */
  
  visitors.footnote = footnote;
  visitors.root = root;
  visitors.blockquote = blockquote;
  visitors.list = list;
  visitors.listItem = listItem;
  visitors.paragraph = paragraph;
  visitors.heading = heading;
  visitors.table = table;
  visitors.code = code;
  visitors.html = html;
  visitors.horizontalRule = rule;
  visitors.inlineCode = inlineCode;
  visitors.strong = strong;
  visitors.emphasis = emphasis;
  visitors.break = hardBreak;
  visitors.link = link;
  visitors.image = image;
  visitors.footnoteReference = footnoteReference;
  visitors.linkReference = linkReference;
  visitors.imageReference = imageReference;
  visitors.delete = strikethrough;
  visitors.text = text;
  visitors.escape = escape;
  
  /*
   * Expose.
   */
  
  module.exports = visitors;
  
  
  /***/ }),
  
  /***/ 2:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  const macosRelease = __webpack_require__(118);
  const winRelease = __webpack_require__(49);
  
  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;
  
  
  /***/ }),
  
  /***/ 8:
  /***/ (function(module) {
  
  "use strict";
  /*!
   * repeat-string <https://github.com/jonschlinkert/repeat-string>
   *
   * Copyright (c) 2014-2015, Jon Schlinkert.
   * Licensed under the MIT License.
   */
  
  
  
  /**
   * Results cache
   */
  
  var res = '';
  var cache;
  
  /**
   * Expose `repeat`
   */
  
  module.exports = repeat;
  
  /**
   * Repeat the given `string` the specified `number`
   * of times.
   *
   * **Example:**
   *
   * ```js
   * var repeat = require('repeat-string');
   * repeat('A', 5);
   * //=> AAAAA
   * ```
   *
   * @param {String} `string` The string to repeat
   * @param {Number} `number` The number of times to repeat the string
   * @return {String} Repeated string
   * @api public
   */
  
  function repeat(str, num) {
    if (typeof str !== 'string') {
      throw new TypeError('expected a string');
    }
  
    // cover common, quick use cases
    if (num === 1) return str;
    if (num === 2) return str + str;
  
    var max = str.length * num;
    if (cache !== str || typeof cache === 'undefined') {
      cache = str;
      res = '';
    } else if (res.length >= max) {
      return res.substr(0, max);
    }
  
    while (max > res.length && num > 1) {
      if (num & 1) {
        res += str;
      }
  
      num >>= 1;
      str += str;
    }
  
    res += str;
    res = res.substr(0, max);
    return res;
  }
  
  
  /***/ }),
  
  /***/ 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;
  
  
  /***/ }),
  
  /***/ 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
    }
  }
  
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module) {
  
  module.exports = require("tls");
  
  /***/ }),
  
  /***/ 18:
  /***/ (function() {
  
  eval("require")("encoding");
  
  
  /***/ }),
  
  /***/ 19:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationPlugin;
  
  const { Deprecation } = __webpack_require__(692);
  const once = __webpack_require__(969);
  
  const deprecateAuthenticate = once((log, deprecation) => log.warn(deprecation));
  
  const authenticate = __webpack_require__(674);
  const beforeRequest = __webpack_require__(471);
  const requestError = __webpack_require__(349);
  
  function authenticationPlugin(octokit, options) {
    if (options.auth) {
      octokit.authenticate = () => {
        deprecateAuthenticate(
          octokit.log,
          new Deprecation(
            '[@octokit/rest] octokit.authenticate() is deprecated and has no effect when "auth" option is set on Octokit constructor'
          )
        );
      };
      return;
    }
    const state = {
      octokit,
      auth: false
    };
    octokit.authenticate = authenticate.bind(null, state);
    octokit.hook.before("request", beforeRequest.bind(null, state));
    octokit.hook.error("request", requestError.bind(null, state));
  }
  
  
  /***/ }),
  
  /***/ 20:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const cp = __webpack_require__(129);
  const parse = __webpack_require__(568);
  const enoent = __webpack_require__(881);
  
  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;
  
  
  /***/ }),
  
  /***/ 39:
  /***/ (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';
  };
  
  
  /***/ }),
  
  /***/ 47:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = factory;
  
  const Octokit = __webpack_require__(402);
  const registerPlugin = __webpack_require__(855);
  
  function factory(plugins) {
    const Api = Octokit.bind(null, plugins || []);
    Api.plugin = registerPlugin.bind(null, plugins || []);
    return Api;
  }
  
  
  /***/ }),
  
  /***/ 49:
  /***/ (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;
  
  
  /***/ }),
  
  /***/ 65:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module Utilities
   * @fileoverview Collection of tiny helpers useful for
   *   both parsing and compiling markdown.
   */
  
  
  
  /*
   * Methods.
   */
  
  var has = Object.prototype.hasOwnProperty;
  
  /*
   * Expressions.
   */
  
  var WHITE_SPACE_FINAL = /\s+$/;
  var NEW_LINES_FINAL = /\n+$/;
  var WHITE_SPACE_INITIAL = /^\s+/;
  var EXPRESSION_LINE_BREAKS = /\r\n|\r/g;
  var EXPRESSION_SYMBOL_FOR_NEW_LINE = /\u2424/g;
  var WHITE_SPACE_COLLAPSABLE = /[ \t\n]+/g;
  var EXPRESSION_BOM = /^\ufeff/;
  
  /**
   * Shallow copy `context` into `target`.
   *
   * @example
   *   var target = {};
   *   copy(target, {foo: 'bar'}); // target
   *
   * @param {Object} target - Object to copy into.
   * @param {Object} context - Object to copy from.
   * @return {Object} - `target`.
   */
  function copy(target, context) {
      var key;
  
      for (key in context) {
          if (has.call(context, key)) {
              target[key] = context[key];
          }
      }
  
      return target;
  }
  
  /**
   * Shallow clone `context`.
   *
   * @example
   *   clone({foo: 'bar'}) // {foo: 'bar'}
   *   clone(['foo', 'bar']) // ['foo', 'bar']
   *
   * @return {Object|Array} context - Object to clone.
   * @return {Object|Array} - Shallow clone of `context`.
   */
  function clone(context) {
      if ('concat' in context) {
          return context.concat();
      }
  
      return copy({}, context);
  }
  
  /**
   * Throw an exception with in its `message` `value`
   * and `name`.
   *
   * @param {*} value - Invalid value.
   * @param {string} name - Setting name.
   */
  function raise(value, name) {
      throw new Error(
          'Invalid value `' + value + '` ' +
          'for setting `' + name + '`'
      );
  }
  
  /**
   * Validate a value to be boolean. Defaults to `def`.
   * Raises an exception with `context[name]` when not
   * a boolean.
   *
   * @example
   *   validateBoolean({foo: null}, 'foo', true) // true
   *   validateBoolean({foo: false}, 'foo', true) // false
   *   validateBoolean({foo: 'bar'}, 'foo', true) // Throws
   *
   * @throws {Error} - When a setting is neither omitted nor
   *   a boolean.
   * @param {Object} context - Settings.
   * @param {string} name - Setting name.
   * @param {boolean} def - Default value.
   */
  function validateBoolean(context, name, def) {
      var value = context[name];
  
      if (value === null || value === undefined) {
          value = def;
      }
  
      if (typeof value !== 'boolean') {
          raise(value, 'options.' + name);
      }
  
      context[name] = value;
  }
  
  /**
   * Validate a value to be boolean. Defaults to `def`.
   * Raises an exception with `context[name]` when not
   * a boolean.
   *
   * @example
   *   validateNumber({foo: null}, 'foo', 1) // 1
   *   validateNumber({foo: 2}, 'foo', 1) // 2
   *   validateNumber({foo: 'bar'}, 'foo', 1) // Throws
   *
   * @throws {Error} - When a setting is neither omitted nor
   *   a number.
   * @param {Object} context - Settings.
   * @param {string} name - Setting name.
   * @param {number} def - Default value.
   */
  function validateNumber(context, name, def) {
      var value = context[name];
  
      if (value === null || value === undefined) {
          value = def;
      }
  
      if (typeof value !== 'number' || value !== value) {
          raise(value, 'options.' + name);
      }
  
      context[name] = value;
  }
  
  /**
   * Validate a value to be in `map`. Defaults to `def`.
   * Raises an exception with `context[name]` when not
   * not in `map`.
   *
   * @example
   *   var map = {bar: true, baz: true};
   *   validateString({foo: null}, 'foo', 'bar', map) // 'bar'
   *   validateString({foo: 'baz'}, 'foo', 'bar', map) // 'baz'
   *   validateString({foo: true}, 'foo', 'bar', map) // Throws
   *
   * @throws {Error} - When a setting is neither omitted nor
   *   in `map`.
   * @param {Object} context - Settings.
   * @param {string} name - Setting name.
   * @param {string} def - Default value.
   * @param {Object} map - Enum.
   */
  function validateString(context, name, def, map) {
      var value = context[name];
  
      if (value === null || value === undefined) {
          value = def;
      }
  
      if (!(value in map)) {
          raise(value, 'options.' + name);
      }
  
      context[name] = value;
  }
  
  /**
   * Remove final white space from `value`.
   *
   * @example
   *   trimRight('foo '); // 'foo'
   *
   * @param {string} value - Content to trim.
   * @return {string} - Trimmed content.
   */
  function trimRight(value) {
      return String(value).replace(WHITE_SPACE_FINAL, '');
  }
  
  /**
   * Remove final new line characters from `value`.
   *
   * @example
   *   trimRightLines('foo\n\n'); // 'foo'
   *
   * @param {string} value - Content to trim.
   * @return {string} - Trimmed content.
   */
  function trimRightLines(value) {
      return String(value).replace(NEW_LINES_FINAL, '');
  }
  
  /**
   * Remove initial white space from `value`.
   *
   * @example
   *   trimLeft(' foo'); // 'foo'
   *
   * @param {string} value - Content to trim.
   * @return {string} - Trimmed content.
   */
  function trimLeft(value) {
      return String(value).replace(WHITE_SPACE_INITIAL, '');
  }
  
  /**
   * Remove initial and final white space from `value`.
   *
   * @example
   *   trim(' foo '); // 'foo'
   *
   * @param {string} value - Content to trim.
   * @return {string} - Trimmed content.
   */
  function trim(value) {
      return trimLeft(trimRight(value));
  }
  
  /**
   * Collapse white space.
   *
   * @example
   *   collapse('foo\t bar'); // 'foo bar'
   *
   * @param {string} value - Content to collapse.
   * @return {string} - Collapsed content.
   */
  function collapse(value) {
      return String(value).replace(WHITE_SPACE_COLLAPSABLE, ' ');
  }
  
  /**
   * Clean a string in preperation of parsing.
   *
   * @example
   *   clean('\ufefffoo'); // 'foo'
   *   clean('foo\r\nbar'); // 'foo\nbar'
   *   clean('foo\u2424bar'); // 'foo\nbar'
   *
   * @param {string} value - Content to clean.
   * @return {string} - Cleaned content.
   */
  function clean(value) {
      return String(value)
          .replace(EXPRESSION_BOM, '')
          .replace(EXPRESSION_LINE_BREAKS, '\n')
          .replace(EXPRESSION_SYMBOL_FOR_NEW_LINE, '\n');
  }
  
  /**
   * Normalize an identifier.  Collapses multiple white space
   * characters into a single space, and removes casing.
   *
   * @example
   *   normalizeIdentifier('FOO\t bar'); // 'foo bar'
   *
   * @param {string} value - Content to normalize.
   * @return {string} - Normalized content.
   */
  function normalizeIdentifier(value) {
      return collapse(value).toLowerCase();
  }
  
  /**
   * Count how many characters `character` occur in `value`.
   *
   * @example
   *   countCharacter('foo(bar(baz)', '(') // 2
   *   countCharacter('foo(bar(baz)', ')') // 1
   *
   * @param {string} value - Content to search in.
   * @param {string} character - Character to search for.
   * @return {number} - Count.
   */
  function countCharacter(value, character) {
      var index = -1;
      var length = value.length;
      var count = 0;
  
      while (++index < length) {
          if (value.charAt(index) === character) {
              count++;
          }
      }
  
      return count;
  }
  
  /**
   * Create an empty object.
   *
   * @example
   *   objectObject(); // Same as `{}`.
   *
   * @return {Object}
   */
  function objectObject() {
      return {};
  }
  
  /*
   * Break coverage.
   */
  
  objectObject();
  
  /**
   * Create an object without prototype.
   *
   * @example
   *   objectNull(); // New object without prototype.
   *
   * @return {Object}
   */
  function objectNull() {
      return Object.create(null);
  }
  
  /*
   * Expose `validate`.
   */
  
  exports.validate = {
      'boolean': validateBoolean,
      'string': validateString,
      'number': validateNumber
  };
  
  /*
   * Expose.
   */
  
  exports.trim = trim;
  exports.trimLeft = trimLeft;
  exports.trimRight = trimRight;
  exports.trimRightLines = trimRightLines;
  exports.collapse = collapse;
  exports.normalizeIdentifier = normalizeIdentifier;
  exports.clean = clean;
  exports.raise = raise;
  exports.copy = copy;
  exports.clone = clone;
  exports.countCharacter = countCharacter;
  
  /* istanbul ignore else */
  if ('create' in Object) {
      exports.create = objectNull;
  } else {
      exports.create = objectObject;
  }
  
  
  /***/ }),
  
  /***/ 87:
  /***/ (function(module) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ 118:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__(87);
  
  const nameMap = new Map([
  	[19, 'Catalina'],
  	[18, 'Mojave'],
  	[17, 'High Sierra'],
  	[16, 'Sierra'],
  	[15, 'El Capitan'],
  	[14, 'Yosemite'],
  	[13, 'Mavericks'],
  	[12, 'Mountain Lion'],
  	[11, 'Lion'],
  	[10, 'Snow Leopard'],
  	[9, 'Leopard'],
  	[8, 'Tiger'],
  	[7, 'Panther'],
  	[6, 'Jaguar'],
  	[5, 'Puma']
  ]);
  
  const macosRelease = release => {
  	release = Number((release || os.release()).split('.')[0]);
  	return {
  		name: nameMap.get(release),
  		version: '10.' + (release - 4)
  	};
  };
  
  module.exports = macosRelease;
  // TODO: remove this in the next major version
  module.exports.default = macosRelease;
  
  
  /***/ }),
  
  /***/ 126:
  /***/ (function(module) {
  
  /**
   * lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="npm" -o ./`
   * Copyright jQuery Foundation and other contributors <https://jquery.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   */
  
  /** Used as the size to enable large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;
  
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0;
  
  /** `Object#toString` result references. */
  var funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]';
  
  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  
  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();
  
  /**
   * A specialized version of `_.includes` for arrays without support for
   * specifying an index to search from.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
  function arrayIncludes(array, value) {
    var length = array ? array.length : 0;
    return !!length && baseIndexOf(array, value, 0) > -1;
  }
  
  /**
   * This function is like `arrayIncludes` except that it accepts a comparator.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
  function arrayIncludesWith(array, value, comparator) {
    var index = -1,
        length = array ? array.length : 0;
  
    while (++index < length) {
      if (comparator(value, array[index])) {
        return true;
      }
    }
    return false;
  }
  
  /**
   * The base implementation of `_.findIndex` and `_.findLastIndex` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {number} fromIndex The index to search from.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseFindIndex(array, predicate, fromIndex, fromRight) {
    var length = array.length,
        index = fromIndex + (fromRight ? 1 : -1);
  
    while ((fromRight ? index-- : ++index < length)) {
      if (predicate(array[index], index, array)) {
        return index;
      }
    }
    return -1;
  }
  
  /**
   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function baseIndexOf(array, value, fromIndex) {
    if (value !== value) {
      return baseFindIndex(array, baseIsNaN, fromIndex);
    }
    var index = fromIndex - 1,
        length = array.length;
  
    while (++index < length) {
      if (array[index] === value) {
        return index;
      }
    }
    return -1;
  }
  
  /**
   * The base implementation of `_.isNaN` without support for number objects.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   */
  function baseIsNaN(value) {
    return value !== value;
  }
  
  /**
   * Checks if a cache value for `key` exists.
   *
   * @private
   * @param {Object} cache The cache to query.
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function cacheHas(cache, key) {
    return cache.has(key);
  }
  
  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }
  
  /**
   * Checks if `value` is a host object in IE < 9.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
   */
  function isHostObject(value) {
    // Many host objects are `Object` objects that can coerce to strings
    // despite having improperly defined `toString` methods.
    var result = false;
    if (value != null && typeof value.toString != 'function') {
      try {
        result = !!(value + '');
      } catch (e) {}
    }
    return result;
  }
  
  /**
   * Converts `set` to an array of its values.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the values.
   */
  function setToArray(set) {
    var index = -1,
        result = Array(set.size);
  
    set.forEach(function(value) {
      result[++index] = value;
    });
    return result;
  }
  
  /** Used for built-in method references. */
  var arrayProto = Array.prototype,
      funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to detect overreaching core-js shims. */
  var coreJsData = root['__core-js_shared__'];
  
  /** Used to detect methods masquerading as native. */
  var maskSrcKey = (function() {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
    return uid ? ('Symbol(src)_1.' + uid) : '';
  }());
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objectToString = objectProto.toString;
  
  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );
  
  /** Built-in value references. */
  var splice = arrayProto.splice;
  
  /* Built-in method references that are verified to be native. */
  var Map = getNative(root, 'Map'),
      Set = getNative(root, 'Set'),
      nativeCreate = getNative(Object, 'create');
  
  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
  }
  
  /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function hashDelete(key) {
    return this.has(key) && delete this.__data__[key];
  }
  
  /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function hashGet(key) {
    var data = this.__data__;
    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }
    return hasOwnProperty.call(data, key) ? data[key] : undefined;
  }
  
  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
  }
  
  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
    return this;
  }
  
  // Add methods to `Hash`.
  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;
  
  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
  }
  
  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    return true;
  }
  
  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    return index < 0 ? undefined : data[index][1];
  }
  
  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }
  
  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }
  
  // Add methods to `ListCache`.
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;
  
  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.__data__ = {
      'hash': new Hash,
      'map': new (Map || ListCache),
      'string': new Hash
    };
  }
  
  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    return getMapData(this, key)['delete'](key);
  }
  
  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }
  
  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }
  
  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    getMapData(this, key).set(key, value);
    return this;
  }
  
  // Add methods to `MapCache`.
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;
  
  /**
   *
   * Creates an array cache object to store unique values.
   *
   * @private
   * @constructor
   * @param {Array} [values] The values to cache.
   */
  function SetCache(values) {
    var index = -1,
        length = values ? values.length : 0;
  
    this.__data__ = new MapCache;
    while (++index < length) {
      this.add(values[index]);
    }
  }
  
  /**
   * Adds `value` to the array cache.
   *
   * @private
   * @name add
   * @memberOf SetCache
   * @alias push
   * @param {*} value The value to cache.
   * @returns {Object} Returns the cache instance.
   */
  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);
    return this;
  }
  
  /**
   * Checks if `value` is in the array cache.
   *
   * @private
   * @name has
   * @memberOf SetCache
   * @param {*} value The value to search for.
   * @returns {number} Returns `true` if `value` is found, else `false`.
   */
  function setCacheHas(value) {
    return this.__data__.has(value);
  }
  
  // Add methods to `SetCache`.
  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
  SetCache.prototype.has = setCacheHas;
  
  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }
  
  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }
  
  /**
   * The base implementation of `_.uniqBy` without support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   */
  function baseUniq(array, iteratee, comparator) {
    var index = -1,
        includes = arrayIncludes,
        length = array.length,
        isCommon = true,
        result = [],
        seen = result;
  
    if (comparator) {
      isCommon = false;
      includes = arrayIncludesWith;
    }
    else if (length >= LARGE_ARRAY_SIZE) {
      var set = iteratee ? null : createSet(array);
      if (set) {
        return setToArray(set);
      }
      isCommon = false;
      includes = cacheHas;
      seen = new SetCache;
    }
    else {
      seen = iteratee ? [] : result;
    }
    outer:
    while (++index < length) {
      var value = array[index],
          computed = iteratee ? iteratee(value) : value;
  
      value = (comparator || value !== 0) ? value : 0;
      if (isCommon && computed === computed) {
        var seenIndex = seen.length;
        while (seenIndex--) {
          if (seen[seenIndex] === computed) {
            continue outer;
          }
        }
        if (iteratee) {
          seen.push(computed);
        }
        result.push(value);
      }
      else if (!includes(seen, computed, comparator)) {
        if (seen !== result) {
          seen.push(computed);
        }
        result.push(value);
      }
    }
    return result;
  }
  
  /**
   * Creates a set object of `values`.
   *
   * @private
   * @param {Array} values The values to add to the set.
   * @returns {Object} Returns the new set.
   */
  var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
    return new Set(values);
  };
  
  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }
  
  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }
  
  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }
  
  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }
  
  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to process.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }
  
  /**
   * Creates a duplicate-free version of an array, using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons, in which only the first occurrence of each
   * element is kept.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.uniq([2, 1, 2]);
   * // => [2, 1]
   */
  function uniq(array) {
    return (array && array.length)
      ? baseUniq(array)
      : [];
  }
  
  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }
  
  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 8-9 which returns 'object' for typed array and other constructors.
    var tag = isObject(value) ? objectToString.call(value) : '';
    return tag == funcTag || tag == genTag;
  }
  
  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return !!value && (type == 'object' || type == 'function');
  }
  
  /**
   * This method returns `undefined`.
   *
   * @static
   * @memberOf _
   * @since 2.3.0
   * @category Util
   * @example
   *
   * _.times(2, _.noop);
   * // => [undefined, undefined]
   */
  function noop() {
    // No operation performed.
  }
  
  module.exports = uniq;
  
  
  /***/ }),
  
  /***/ 129:
  /***/ (function(module) {
  
  module.exports = require("child_process");
  
  /***/ }),
  
  /***/ 141:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  var net = __webpack_require__(631);
  var tls = __webpack_require__(16);
  var http = __webpack_require__(605);
  var https = __webpack_require__(211);
  var events = __webpack_require__(614);
  var assert = __webpack_require__(357);
  var util = __webpack_require__(669);
  
  
  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
  
  
  /***/ }),
  
  /***/ 143:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = withAuthorizationPrefix;
  
  const atob = __webpack_require__(368);
  
  const REGEX_IS_BASIC_AUTH = /^[\w-]+:/;
  
  function withAuthorizationPrefix(authorization) {
    if (/^(basic|bearer|token) /i.test(authorization)) {
      return authorization;
    }
  
    try {
      if (REGEX_IS_BASIC_AUTH.test(atob(authorization))) {
        return `basic ${authorization}`;
      }
    } catch (error) {}
  
    if (authorization.split(/\./).length === 3) {
      return `bearer ${authorization}`;
    }
  
    return `token ${authorization}`;
  }
  
  
  /***/ }),
  
  /***/ 145:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const pump = __webpack_require__(453);
  const bufferStream = __webpack_require__(966);
  
  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;
  
  
  /***/ }),
  
  /***/ 148:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = paginatePlugin;
  
  const { paginateRest } = __webpack_require__(299);
  
  function paginatePlugin(octokit) {
    Object.assign(octokit, paginateRest(octokit));
  }
  
  
  /***/ }),
  
  /***/ 161:
  /***/ (function(module) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module File
   * @fileoverview Virtual file format to attach additional
   *   information related to the processed input.  Similar
   *   to`wearefractal/vinyl`.  Additionally, File can be
   *   passed directly to an ESLint formatter to visualise
   *   warnings and errors relating to a file.
   */
  
  
  
  /**
   * ESLint's formatter API expects `filePath` to be a
   * string.  This hack supports invocation as well as
   * implicit coercion.
   *
   * @example
   *   var file = new File();
   *   filePath = filePathFactory(file);
   *
   * @param {File} file
   * @return {Function}
   */
  function filePathFactory(file) {
      /**
       * Get the location of `file`.
       *
       * Returns empty string when without `filename`.
       *
       * @example
       *   var file = new File({
       *     'directory': '~',
       *     'filename': 'example',
       *     'extension': 'markdown'
       *   });
       *
       *   String(file.filePath); // ~/example.markdown
       *   file.filePath() // ~/example.markdown
       *
       * @property {Function} toString - Itself.
       * @return {string}
       */
      function filePath() {
          var directory;
  
          if (file.filename) {
              directory = file.directory;
  
              if (directory.charAt(directory.length - 1) === '/') {
                  directory = directory.slice(0, -1);
              }
  
              if (directory === '.') {
                  directory = '';
              }
  
              return (directory ? directory + '/' : '') +
                  file.filename +
                  (file.extension ? '.' + file.extension : '');
          }
  
          return '';
      }
  
      filePath.toString = filePath;
  
      return filePath;
  }
  
  /**
   * Construct a new file.
   *
   * @example
   *   var file = new File({
   *     'directory': '~',
   *     'filename': 'example',
   *     'extension': 'markdown',
   *     'contents': 'Foo *bar* baz'
   *   });
   *
   *   file === File(file) // true
   *   file === new File(file) // true
   *   File('foo') instanceof File // true
   *
   * @constructor
   * @class {File}
   * @param {Object|File|string} [options] - either an
   *   options object, or the value of `contents` (both
   *   optional).  When a `file` is passed in, it's
   *   immediately returned.
   */
  function File(options) {
      var self = this;
  
      if (!(self instanceof File)) {
          return new File(options);
      }
  
      if (options instanceof File) {
          return options;
      }
  
      if (!options) {
          options = {};
      } else if (typeof options === 'string') {
          options = {
              'contents': options
          };
      }
  
      self.filename = options.filename || null;
      self.contents = options.contents || '';
  
      self.directory = options.directory === undefined ? '' : options.directory;
  
      self.extension = options.extension === undefined ?
          'md' : options.extension;
  
      self.messages = [];
  
      /*
       * Make sure eslint’s formatters stringify `filePath`
       * properly.
       */
  
      self.filePath = filePathFactory(self);
  }
  
  /**
   * Move a file by passing a new directory, filename,
   * and extension.  When these are not given, the default
   * values are kept.
   *
   * @example
   *   var file = new File({
   *     'directory': '~',
   *     'filename': 'example',
   *     'extension': 'markdown',
   *     'contents': 'Foo *bar* baz'
   *   });
   *
   *   file.move({'directory': '/var/www'});
   *   file.filePath(); // '/var/www/example.markdown'
   *
   *   file.move({'extension': 'md'});
   *   file.filePath(); // '/var/www/example.md'
   *
   * @this {File}
   * @param {Object} options
   */
  function move(options) {
      var self = this;
  
      if (!options) {
          options = {};
      }
  
      self.directory = options.directory || self.directory || '';
      self.filename = options.filename || self.filename || null;
      self.extension = options.extension || self.extension || 'md';
  }
  
  /**
   * Stringify a position.
   *
   * @example
   *   stringify({'line': 1, 'column': 3}) // '1:3'
   *   stringify({'line': 1}) // '1:1'
   *   stringify({'column': 3}) // '1:3'
   *   stringify() // '1:1'
   *
   * @param {Object?} [position] - Single position, like
   *   those available at `node.position.start`.
   * @return {string}
   */
  function stringify(position) {
      if (!position) {
          position = {};
      }
  
      return (position.line || 1) + ':' + (position.column || 1);
  }
  
  /**
   * Warn.
   *
   * Creates an exception (see `File#exception()`),
   * sets `fatal: false`, and adds it to the file's
   * `messages` list.
   *
   * @example
   *   var file = new File();
   *   file.warn('Something went wrong');
   *
   * @this {File}
   * @param {string|Error} reason - Reason for warning.
   * @param {Node|Location|Position} [position] - Location
   *   of warning in file.
   * @return {Error}
   */
  function warn(reason, position) {
      var err = this.exception(reason, position);
  
      err.fatal = false;
  
      this.messages.push(err);
  
      return err;
  }
  
  /**
   * Fail.
   *
   * Creates an exception (see `File#exception()`),
   * sets `fatal: true`, adds it to the file's
   * `messages` list.  If `quiet` is not true,
   * throws the error.
   *
   * @example
   *   var file = new File();
   *   file.fail('Something went wrong'); // throws
   *
   * @this {File}
   * @throws {Error} - When not `quiet: true`.
   * @param {string|Error} reason - Reason for failure.
   * @param {Node|Location|Position} [position] - Location
   *   of failure in file.
   * @return {Error} - Unless thrown, of course.
   */
  function fail(reason, position) {
      var err = this.exception(reason, position);
  
      err.fatal = true;
  
      this.messages.push(err);
  
      if (!this.quiet) {
          throw err;
      }
  
      return err;
  }
  
  /**
   * Create a pretty exception with `reason` at `position`.
   * When an error is passed in as `reason`, copies the
   * stack.  This does not add a message to `messages`.
   *
   * @example
   *   var file = new File();
   *   var err = file.exception('Something went wrong');
   *
   * @this {File}
   * @param {string|Error} reason - Reason for message.
   * @param {Node|Location|Position} [position] - Location
   *   of message in file.
   * @return {Error} - An object including file information,
   *   line and column indices.
   */
  function exception(reason, position) {
      var file = this.filePath();
      var message = reason.message || reason;
      var location;
      var err;
  
      /*
       * Node / location / position.
       */
  
      if (position && position.position) {
          position = position.position;
      }
  
      if (position && position.start) {
          location = stringify(position.start) + '-' + stringify(position.end);
          position = position.start;
      } else {
          location = stringify(position);
      }
  
      err = new Error(message);
  
      err.name = (file ? file + ':' : '') + location;
      err.file = file;
      err.reason = message;
      err.line = position ? position.line : null;
      err.column = position ? position.column : null;
  
      if (reason.stack) {
          err.stack = reason.stack;
      }
  
      return err;
  }
  
  /**
   * Check if `file` has a fatal message.
   *
   * @example
   *   var file = new File();
   *   file.quiet = true;
   *   file.hasFailed; // false
   *
   *   file.fail('Something went wrong');
   *   file.hasFailed; // true
   *
   * @this {File}
   * @return {boolean}
   */
  function hasFailed() {
      var messages = this.messages;
      var index = -1;
      var length = messages.length;
  
      while (++index < length) {
          if (messages[index].fatal) {
              return true;
          }
      }
  
      return false;
  }
  
  /**
   * Create a string representation of `file`.
   *
   * @example
   *   var file = new File('Foo');
   *   String(file); // 'Foo'
   *
   * @this {File}
   * @return {string} - value at the `contents` property
   *   in context.
   */
  function toString() {
      return this.contents;
  }
  
  /*
   * Methods.
   */
  
  File.prototype.move = move;
  File.prototype.exception = exception;
  File.prototype.toString = toString;
  File.prototype.warn = warn;
  File.prototype.fail = fail;
  File.prototype.hasFailed = hasFailed;
  
  /*
   * Expose.
   */
  
  module.exports = File;
  
  
  /***/ }),
  
  /***/ 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;
  };
  
  
  /***/ }),
  
  /***/ 190:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationPlugin;
  
  const { createTokenAuth } = __webpack_require__(813);
  const { Deprecation } = __webpack_require__(692);
  const once = __webpack_require__(969);
  
  const beforeRequest = __webpack_require__(863);
  const requestError = __webpack_require__(293);
  const validate = __webpack_require__(954);
  const withAuthorizationPrefix = __webpack_require__(143);
  
  const deprecateAuthBasic = once((log, deprecation) => log.warn(deprecation));
  const deprecateAuthObject = once((log, deprecation) => log.warn(deprecation));
  
  function authenticationPlugin(octokit, options) {
    // If `options.authStrategy` is set then use it and pass in `options.auth`
    if (options.authStrategy) {
      const auth = options.authStrategy(options.auth);
      octokit.hook.wrap("request", auth.hook);
      octokit.auth = auth;
      return;
    }
  
    // If neither `options.authStrategy` nor `options.auth` are set, the `octokit` instance
    // is unauthenticated. The `octokit.auth()` method is a no-op and no request hook is registred.
    if (!options.auth) {
      octokit.auth = () =>
        Promise.resolve({
          type: "unauthenticated"
        });
      return;
    }
  
    const isBasicAuthString =
      typeof options.auth === "string" &&
      /^basic/.test(withAuthorizationPrefix(options.auth));
  
    // If only `options.auth` is set to a string, use the default token authentication strategy.
    if (typeof options.auth === "string" && !isBasicAuthString) {
      const auth = createTokenAuth(options.auth);
      octokit.hook.wrap("request", auth.hook);
      octokit.auth = auth;
      return;
    }
  
    // Otherwise log a deprecation message
    const [deprecationMethod, deprecationMessapge] = isBasicAuthString
      ? [
          deprecateAuthBasic,
          'Setting the "new Octokit({ auth })" option to a Basic Auth string is deprecated. Use https://github.com/octokit/auth-basic.js instead. See (https://octokit.github.io/rest.js/#authentication)'
        ]
      : [
          deprecateAuthObject,
          'Setting the "new Octokit({ auth })" option to an object without also setting the "authStrategy" option is deprecated and will be removed in v17. See (https://octokit.github.io/rest.js/#authentication)'
        ];
    deprecationMethod(
      octokit.log,
      new Deprecation("[@octokit/rest] " + deprecationMessapge)
    );
  
    octokit.auth = () =>
      Promise.resolve({
        type: "deprecated",
        message: deprecationMessapge
      });
  
    validate(options.auth);
  
    const state = {
      octokit,
      auth: options.auth
    };
  
    octokit.hook.before("request", beforeRequest.bind(null, state));
    octokit.hook.error("request", requestError.bind(null, state));
  }
  
  
  /***/ }),
  
  /***/ 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
  }
  
  
  /***/ }),
  
  /***/ 211:
  /***/ (function(module) {
  
  module.exports = require("https");
  
  /***/ }),
  
  /***/ 215:
  /***/ (function(module) {
  
  module.exports = {"_from":"@octokit/rest@^16.43.1","_id":"@octokit/rest@16.43.2","_inBundle":false,"_integrity":"sha512-ngDBevLbBTFfrHZeiS7SAMAZ6ssuVmXuya+F/7RaVvlysgGa1JKJkKWY+jV6TCJYcW0OALfJ7nTIGXcBXzycfQ==","_location":"/@octokit/rest","_phantomChildren":{"@types/node":"14.0.14","deprecation":"2.3.1","once":"1.4.0","os-name":"3.1.0"},"_requested":{"type":"range","registry":true,"raw":"@octokit/rest@^16.43.1","name":"@octokit/rest","escapedName":"@octokit%2frest","scope":"@octokit","rawSpec":"^16.43.1","saveSpec":null,"fetchSpec":"^16.43.1"},"_requiredBy":["/@actions/github"],"_resolved":"https://registry.npmjs.org/@octokit/rest/-/rest-16.43.2.tgz","_shasum":"c53426f1e1d1044dee967023e3279c50993dd91b","_spec":"@octokit/rest@^16.43.1","_where":"C:\\Users\\anonymous\\Documents\\xbox\\auto-close-issues\\node_modules\\@actions\\github","author":{"name":"Gregor Martynus","url":"https://github.com/gr2m"},"bugs":{"url":"https://github.com/octokit/rest.js/issues"},"bundleDependencies":false,"bundlesize":[{"path":"./dist/octokit-rest.min.js.gz","maxSize":"33 kB"}],"contributors":[{"name":"Mike de Boer","email":"info@mikedeboer.nl"},{"name":"Fabian Jakobs","email":"fabian@c9.io"},{"name":"Joe Gallo","email":"joe@brassafrax.com"},{"name":"Gregor Martynus","url":"https://github.com/gr2m"}],"dependencies":{"@octokit/auth-token":"^2.4.0","@octokit/plugin-paginate-rest":"^1.1.1","@octokit/plugin-request-log":"^1.0.0","@octokit/plugin-rest-endpoint-methods":"2.4.0","@octokit/request":"^5.2.0","@octokit/request-error":"^1.0.2","atob-lite":"^2.0.0","before-after-hook":"^2.0.0","btoa-lite":"^1.0.0","deprecation":"^2.0.0","lodash.get":"^4.4.2","lodash.set":"^4.3.2","lodash.uniq":"^4.5.0","octokit-pagination-methods":"^1.1.0","once":"^1.4.0","universal-user-agent":"^4.0.0"},"deprecated":false,"description":"GitHub REST API client for Node.js","devDependencies":{"@gimenete/type-writer":"^0.1.3","@octokit/auth":"^1.1.1","@octokit/fixtures-server":"^5.0.6","@octokit/graphql":"^4.2.0","@types/node":"^13.1.0","bundlesize":"^0.18.0","chai":"^4.1.2","compression-webpack-plugin":"^3.1.0","cypress":"^4.0.0","glob":"^7.1.2","http-proxy-agent":"^4.0.0","lodash.camelcase":"^4.3.0","lodash.merge":"^4.6.1","lodash.upperfirst":"^4.3.1","lolex":"^6.0.0","mkdirp":"^1.0.0","mocha":"^7.0.1","mustache":"^4.0.0","nock":"^11.3.3","npm-run-all":"^4.1.2","nyc":"^15.0.0","prettier":"^1.14.2","proxy":"^1.0.0","semantic-release":"^17.0.0","sinon":"^8.0.0","sinon-chai":"^3.0.0","sort-keys":"^4.0.0","string-to-arraybuffer":"^1.0.0","string-to-jsdoc-comment":"^1.0.0","typescript":"^3.3.1","webpack":"^4.0.0","webpack-bundle-analyzer":"^3.0.0","webpack-cli":"^3.0.0"},"files":["index.js","index.d.ts","lib","plugins"],"homepage":"https://github.com/octokit/rest.js#readme","keywords":["octokit","github","rest","api-client"],"license":"MIT","name":"@octokit/rest","nyc":{"ignore":["test"]},"publishConfig":{"access":"public"},"release":{"publish":["@semantic-release/npm",{"path":"@semantic-release/github","assets":["dist/*","!dist/*.map.gz"]}]},"repository":{"type":"git","url":"git+https://github.com/octokit/rest.js.git"},"scripts":{"build":"npm-run-all build:*","build:browser":"npm-run-all build:browser:*","build:browser:development":"webpack --mode development --entry . --output-library=Octokit --output=./dist/octokit-rest.js --profile --json > dist/bundle-stats.json","build:browser:production":"webpack --mode production --entry . --plugin=compression-webpack-plugin --output-library=Octokit --output-path=./dist --output-filename=octokit-rest.min.js --devtool source-map","build:ts":"npm run -s update-endpoints:typescript","coverage":"nyc report --reporter=html && open coverage/index.html","generate-bundle-report":"webpack-bundle-analyzer dist/bundle-stats.json --mode=static --no-open --report dist/bundle-report.html","lint":"prettier --check '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","lint:fix":"prettier --write '{lib,plugins,scripts,test}/**/*.{js,json,ts}' 'docs/*.{js,json}' 'docs/src/**/*' index.js README.md package.json","postvalidate:ts":"tsc --noEmit --target es6 test/typescript-validate.ts","prebuild:browser":"mkdirp dist/","pretest":"npm run -s lint","prevalidate:ts":"npm run -s build:ts","start-fixtures-server":"octokit-fixtures-server","test":"nyc mocha test/mocha-node-setup.js \"test/*/**/*-test.js\"","test:browser":"cypress run --browser chrome","update-endpoints":"npm-run-all update-endpoints:*","update-endpoints:fetch-json":"node scripts/update-endpoints/fetch-json","update-endpoints:typescript":"node scripts/update-endpoints/typescript","validate:ts":"tsc --target es6 --noImplicitAny index.d.ts"},"types":"index.d.ts","version":"16.43.2"};
  
  /***/ }),
  
  /***/ 224:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  /*
   * Dependencies.
   */
  
  var repeat = __webpack_require__(8);
  
  /*
   * Constants.
   */
  
  var TAB = '\t';
  var NEWLINE = '\n';
  var SPACE = ' ';
  
  /**
   * Replace tabs with spaces, being smart about which
   * column the tab is at and which size should be used.
   *
   * @example
   *   detab('\tfoo\nbar\tbaz'); // '    foo\nbar baz'
   *   detab('\tfoo\nbar\tbaz', 2); // '  foo\nbar baz'
   *   detab('\tfoo\nbar\tbaz', 8); // '        foo\nbar     baz'
   *
   * @param {string} value - Value with tabs.
   * @param {number?} [size=4] - Tab-size.
   * @return {string} - Value without tabs.
   */
  function detab(value, size) {
      var string = typeof value === 'string';
      var length = string && value.length;
      var index = -1;
      var column = -1;
      var tabSize = size || 4;
      var result = '';
      var character;
      var add;
  
      if (!string) {
          throw new Error('detab expected string');
      }
  
      while (++index < length) {
          character = value.charAt(index);
  
          if (character === TAB) {
              add = tabSize - ((column + 1) % tabSize);
              result += repeat(SPACE, add);
              column += add;
              continue;
          }
  
          if (character === NEWLINE) {
              column = -1;
          } else {
              column++;
          }
  
          result += character;
      }
  
      return result;
  }
  
  /*
   * Expose.
   */
  
  module.exports = detab;
  
  
  /***/ }),
  
  /***/ 260:
  /***/ (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 isWin = /^win/i.test(process.platform)
  
  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 */
        if (isWin && sig === 'SIGHUP') {
          // "SIGHUP" throws an `ENOSYS` error on Windows,
          // so use a supported signal instead
          sig = 'SIGINT'
        }
        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)
    }
  }
  
  
  /***/ }),
  
  /***/ 262:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  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
  
  /***/ }),
  
  /***/ 265:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = getPage
  
  const deprecate = __webpack_require__(370)
  const getPageLinks = __webpack_require__(577)
  const HttpError = __webpack_require__(297)
  
  function getPage (octokit, link, which, headers) {
    deprecate(`octokit.get${which.charAt(0).toUpperCase() + which.slice(1)}Page() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`)
    const url = getPageLinks(link)[which]
  
    if (!url) {
      const urlError = new HttpError(`No ${which} page found`, 404)
      return Promise.reject(urlError)
    }
  
    const requestOptions = {
      url,
      headers: applyAcceptHeader(link, headers)
    }
  
    const promise = octokit.request(requestOptions)
  
    return promise
  }
  
  function applyAcceptHeader (res, headers) {
    const previous = res.headers && res.headers['x-github-media-type']
  
    if (!previous || (headers && headers.accept)) {
      return headers
    }
    headers = headers || {}
    headers.accept = 'application/vnd.' + previous
      .replace('; param=', '.')
      .replace('; format=', '+')
  
    return headers
  }
  
  
  /***/ }),
  
  /***/ 280:
  /***/ (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'))
  }
  
  
  /***/ }),
  
  /***/ 293:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationRequestError;
  
  const { RequestError } = __webpack_require__(497);
  
  function authenticationRequestError(state, error, options) {
    if (!error.headers) throw error;
  
    const otpRequired = /required/.test(error.headers["x-github-otp"] || "");
    // handle "2FA required" error only
    if (error.status !== 401 || !otpRequired) {
      throw error;
    }
  
    if (
      error.status === 401 &&
      otpRequired &&
      error.request &&
      error.request.headers["x-github-otp"]
    ) {
      if (state.otp) {
        delete state.otp; // no longer valid, request again
      } else {
        throw new RequestError(
          "Invalid one-time password for two-factor authentication",
          401,
          {
            headers: error.headers,
            request: options
          }
        );
      }
    }
  
    if (typeof state.auth.on2fa !== "function") {
      throw new RequestError(
        "2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication",
        401,
        {
          headers: error.headers,
          request: options
        }
      );
    }
  
    return Promise.resolve()
      .then(() => {
        return state.auth.on2fa();
      })
      .then(oneTimePassword => {
        const newOptions = Object.assign(options, {
          headers: Object.assign(options.headers, {
            "x-github-otp": oneTimePassword
          })
        });
        return state.octokit.request(newOptions).then(response => {
          // If OTP still valid, then persist it for following requests
          state.otp = oneTimePassword;
          return response;
        });
      });
  }
  
  
  /***/ }),
  
  /***/ 294:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = parseOptions;
  
  const { Deprecation } = __webpack_require__(692);
  const { getUserAgent } = __webpack_require__(619);
  const once = __webpack_require__(969);
  
  const pkg = __webpack_require__(215);
  
  const deprecateOptionsTimeout = once((log, deprecation) =>
    log.warn(deprecation)
  );
  const deprecateOptionsAgent = once((log, deprecation) => log.warn(deprecation));
  const deprecateOptionsHeaders = once((log, deprecation) =>
    log.warn(deprecation)
  );
  
  function parseOptions(options, log, hook) {
    if (options.headers) {
      options.headers = Object.keys(options.headers).reduce((newObj, key) => {
        newObj[key.toLowerCase()] = options.headers[key];
        return newObj;
      }, {});
    }
  
    const clientDefaults = {
      headers: options.headers || {},
      request: options.request || {},
      mediaType: {
        previews: [],
        format: ""
      }
    };
  
    if (options.baseUrl) {
      clientDefaults.baseUrl = options.baseUrl;
    }
  
    if (options.userAgent) {
      clientDefaults.headers["user-agent"] = options.userAgent;
    }
  
    if (options.previews) {
      clientDefaults.mediaType.previews = options.previews;
    }
  
    if (options.timeZone) {
      clientDefaults.headers["time-zone"] = options.timeZone;
    }
  
    if (options.timeout) {
      deprecateOptionsTimeout(
        log,
        new Deprecation(
          "[@octokit/rest] new Octokit({timeout}) is deprecated. Use {request: {timeout}} instead. See https://github.com/octokit/request.js#request"
        )
      );
      clientDefaults.request.timeout = options.timeout;
    }
  
    if (options.agent) {
      deprecateOptionsAgent(
        log,
        new Deprecation(
          "[@octokit/rest] new Octokit({agent}) is deprecated. Use {request: {agent}} instead. See https://github.com/octokit/request.js#request"
        )
      );
      clientDefaults.request.agent = options.agent;
    }
  
    if (options.headers) {
      deprecateOptionsHeaders(
        log,
        new Deprecation(
          "[@octokit/rest] new Octokit({headers}) is deprecated. Use {userAgent, previews} instead. See https://github.com/octokit/request.js#request"
        )
      );
    }
  
    const userAgentOption = clientDefaults.headers["user-agent"];
    const defaultUserAgent = `octokit.js/${pkg.version} ${getUserAgent()}`;
  
    clientDefaults.headers["user-agent"] = [userAgentOption, defaultUserAgent]
      .filter(Boolean)
      .join(" ");
  
    clientDefaults.request.hook = hook.bind(null, "request");
  
    return clientDefaults;
  }
  
  
  /***/ }),
  
  /***/ 296:
  /***/ (function(module) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module mdast-util-visit
   * @fileoverview Utility to recursively walk over mdast nodes.
   */
  
  
  
  /**
   * Walk forwards.
   *
   * @param {Array.<*>} values - Things to iterate over,
   *   forwards.
   * @param {function(*, number): boolean} callback - Function
   *   to invoke.
   * @return {boolean} - False if iteration stopped.
   */
  function forwards(values, callback) {
      var index = -1;
      var length = values.length;
  
      while (++index < length) {
          if (callback(values[index], index) === false) {
              return false;
          }
      }
  
      return true;
  }
  
  /**
   * Walk backwards.
   *
   * @param {Array.<*>} values - Things to iterate over,
   *   backwards.
   * @param {function(*, number): boolean} callback - Function
   *   to invoke.
   * @return {boolean} - False if iteration stopped.
   */
  function backwards(values, callback) {
      var index = values.length;
      var length = -1;
  
      while (--index > length) {
          if (callback(values[index], index) === false) {
              return false;
          }
      }
  
      return true;
  }
  
  /**
   * Visit.
   *
   * @param {Node} tree - Root node
   * @param {string} [type] - Node type.
   * @param {function(node): boolean?} callback - Invoked
   *   with each found node.  Can return `false` to stop.
   * @param {boolean} [reverse] - By default, `visit` will
   *   walk forwards, when `reverse` is `true`, `visit`
   *   walks backwards.
   */
  function visit(tree, type, callback, reverse) {
      var iterate;
      var one;
      var all;
  
      if (typeof type === 'function') {
          reverse = callback;
          callback = type;
          type = null;
      }
  
      iterate = reverse ? backwards : forwards;
  
      /**
       * Visit `children` in `parent`.
       */
      all = function (children, parent) {
          return iterate(children, function (child, index) {
              return child && one(child, index, parent);
          });
      };
  
      /**
       * Visit a single node.
       */
      one = function (node, index, parent) {
          var result;
  
          index = index || (parent ? 0 : null);
  
          if (!type || node.type === type) {
              result = callback(node, index, parent || null);
          }
  
          if (node.children && result !== false) {
              return all(node.children, node);
          }
  
          return result;
      };
  
      one(tree);
  }
  
  /*
   * Expose.
   */
  
  module.exports = visit;
  
  
  /***/ }),
  
  /***/ 297:
  /***/ (function(module) {
  
  module.exports = class HttpError extends Error {
    constructor (message, code, headers) {
      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.code = code
      this.headers = headers
    }
  }
  
  
  /***/ }),
  
  /***/ 299:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  const VERSION = "1.1.2";
  
  /**
   * 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:
   *
   * - https://developer.github.com/v3/search/#example (key `items`)
   * - https://developer.github.com/v3/checks/runs/#response-3 (key: `check_runs`)
   * - https://developer.github.com/v3/checks/suites/#response-1 (key: `check_suites`)
   * - https://developer.github.com/v3/apps/installations/#list-repositories (key: `repositories`)
   * - https://developer.github.com/v3/apps/installations/#list-installations-for-a-user (key `installations`)
   *
   * 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. For the exceptions with the namespace, a fallback check for the route
   * paths has to be added in order to normalize the response. We cannot check for the total_count
   * property because it also exists in the response of Get the combined status for a specific ref.
   */
  const REGEX = [/^\/search\//, /^\/repos\/[^/]+\/[^/]+\/commits\/[^/]+\/(check-runs|check-suites)([^/]|$)/, /^\/installation\/repositories([^/]|$)/, /^\/user\/installations([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/secrets([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/workflows(\/[^/]+\/runs)?([^/]|$)/, /^\/repos\/[^/]+\/[^/]+\/actions\/runs(\/[^/]+\/(artifacts|jobs))?([^/]|$)/];
  function normalizePaginatedListResponse(octokit, url, response) {
    const path = url.replace(octokit.request.endpoint.DEFAULTS.baseUrl, "");
    const responseNeedsNormalization = REGEX.find(regex => regex.test(path));
    if (!responseNeedsNormalization) return; // 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;
    Object.defineProperty(response.data, namespaceKey, {
      get() {
        octokit.log.warn(`[@octokit/paginate-rest] "response.data.${namespaceKey}" is deprecated for "GET ${path}". Get the results directly from "response.data"`);
        return Array.from(data);
      }
  
    });
  }
  
  function iterator(octokit, route, parameters) {
    const options = octokit.request.endpoint(route, parameters);
    const method = options.method;
    const headers = options.headers;
    let url = options.url;
    return {
      [Symbol.asyncIterator]: () => ({
        next() {
          if (!url) {
            return Promise.resolve({
              done: true
            });
          }
  
          return octokit.request({
            method,
            url,
            headers
          }).then(response => {
            normalizePaginatedListResponse(octokit, url, 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 = ((response.headers.link || "").match(/<([^>]+)>;\s*rel="next"/) || [])[1];
            return {
              value: response
            };
          });
        }
  
      })
    };
  }
  
  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);
    });
  }
  
  /**
   * @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.paginateRest = paginateRest;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 302:
  /***/ (function(module) {
  
  /* This file is generated by `script/build-expressions.js` */
  module.exports = {
    'rules': {
      'newline': /^\n([ \t]*\n)*/,
      'code': /^((?: {4}|\t)[^\n]*\n?([ \t]*\n)*)+/,
      'horizontalRule': /^[ \t]*([-*_])( *\1){2,} *(?=\n|$)/,
      'heading': /^([ \t]*)(#{1,6})(?:([ \t]+)([^\n]+?))??(?:[ \t]+#+)?[ \t]*(?=\n|$)/,
      'lineHeading': /^(\ {0,3})([^\n]+?)[ \t]*\n\ {0,3}(=|-){1,}[ \t]*(?=\n|$)/,
      'definition': /^[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$)/,
      'bullet': /(?:[*+-]|\d+\.)/,
      'indent': /^([ \t]*)((?:[*+-]|\d+\.))( {1,4}(?! )| |\t)/,
      'item': /([ \t]*)((?:[*+-]|\d+\.))( {1,4}(?! )| |\t)[^\n]*(?:\n(?!\1(?:[*+-]|\d+\.)[ \t])[^\n]*)*/gm,
      'list': /^([ \t]*)((?:[*+-]|\d+\.))[ \t][\s\S]+?(?:(?=\n+\1?(?:[-*_][ \t]*){3,}(?:\n|$))|(?=\n+[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))|\n{2,}(?![ \t])(?!\1(?:[*+-]|\d+\.)[ \t])|$)/,
      'blockquote': /^(?=[ \t]*>)(?:(?:(?:[ \t]*>[^\n]*\n)*(?:[ \t]*>[^\n]+(?=\n|$))|(?![ \t]*>)(?![ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))[^\n]+)(?:\n|$))*(?:[ \t]*>[ \t]*(?:\n[ \t]*>[ \t]*)*)?/,
      'html': /^(?:[ \t]*(?:(?:(?:<(?:article|header|aside|hgroup|blockquote|hr|iframe|body|li|map|button|object|canvas|ol|caption|output|col|p|colgroup|pre|dd|progress|div|section|dl|table|td|dt|tbody|embed|textarea|fieldset|tfoot|figcaption|th|figure|thead|footer|tr|form|ul|h1|h2|h3|h4|h5|h6|video|script|style)(?:(?:\s+)(?:[a-zA-Z_:][a-zA-Z0-9_.:-]*)(?:(?:\s+)?=(?:\s+)?(?:[^"'=<>`]+|'[^']*'|"[^"]*"))?)*(?:\s+)?\/?>?)|(?:<\/(?:article|header|aside|hgroup|blockquote|hr|iframe|body|li|map|button|object|canvas|ol|caption|output|col|p|colgroup|pre|dd|progress|div|section|dl|table|td|dt|tbody|embed|textarea|fieldset|tfoot|figcaption|th|figure|thead|footer|tr|form|ul|h1|h2|h3|h4|h5|h6|video|script|style)(?:\s+)?>))|(?:<!--(?!-?>)(?:[^-]|-(?!-))*-->)|(?:<\?(?:[^\?]|\?(?!>))+\?>)|(?:<![a-zA-Z]+\s+[\s\S]+?>)|(?:<!\[CDATA\[[\s\S]+?\]\]>))[\s\S]*?[ \t]*?(?:\n{2,}|\s*$))/i,
      'paragraph': /^(?:(?:[^\n]+\n?(?![ \t]*([-*_])( *\1){2,} *(?=\n|$)|([ \t]*)(#{1,6})(?:([ \t]+)([^\n]+?))??(?:[ \t]+#+)?[ \t]*(?=\n|$)|(\ {0,3})([^\n]+?)[ \t]*\n\ {0,3}(=|-){1,}[ \t]*(?=\n|$)|[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$)|(?=[ \t]*>)(?:(?:(?:[ \t]*>[^\n]*\n)*(?:[ \t]*>[^\n]+(?=\n|$))|(?![ \t]*>)(?![ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))[^\n]+)(?:\n|$))*(?:[ \t]*>[ \t]*(?:\n[ \t]*>[ \t]*)*)?|<(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\b)(?!mailto:)\w+(?!:\/|[^\w\s@]*@)\b))+)/,
      'escape': /^\\([\\`*{}\[\]()#+\-.!_>])/,
      'autoLink': /^<([^ >]+(@|:\/)[^ >]+)>/,
      'tag': /^(?:(?:<(?:[a-zA-Z][a-zA-Z0-9]*)(?:(?:\s+)(?:[a-zA-Z_:][a-zA-Z0-9_.:-]*)(?:(?:\s+)?=(?:\s+)?(?:[^"'=<>`]+|'[^']*'|"[^"]*"))?)*(?:\s+)?\/?>)|(?:<\/(?:[a-zA-Z][a-zA-Z0-9]*)(?:\s+)?>)|(?:<!--(?!-?>)(?:[^-]|-(?!-))*-->)|(?:<\?(?:[^\?]|\?(?!>))+\?>)|(?:<![a-zA-Z]+\s+[\s\S]+?>)|(?:<!\[CDATA\[[\s\S]+?\]\]>))/,
      'strong': /^(_)_((?:\\[\s\S]|[^\\])+?)__(?!_)|^(\*)\*((?:\\[\s\S]|[^\\])+?)\*\*(?!\*)/,
      'emphasis': /^\b(_)((?:__|\\[\s\S]|[^\\])+?)_\b|^(\*)((?:\*\*|\\[\s\S]|[^\\])+?)\*(?!\*)/,
      'inlineCode': /^(`+)((?!`)[\s\S]*?(?:`\s+|[^`]))?(\1)(?!`)/,
      'break': /^ {2,}\n(?!\s*$)/,
      'inlineText': /^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/,
      'link': /^(!?\[)((?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*)\]\(\s*(?:(?!<)((?:\((?:\\[\s\S]|[^\)])*?\)|\\[\s\S]|[\s\S])*?)|<([\s\S]*?)>)(?:\s+['"]([\s\S]*?)['"])?\s*\)/,
      'shortcutReference': /^(!?\[)((?:\\[\s\S]|[^\[\]])+?)\]/,
      'reference': /^(!?\[)((?:\[[^\]]*\]|[^\[\]]|\](?=[^\[]*\]))*)\]\s*\[((?:\\[\s\S]|[^\[\]])*)\]/
    },
    'gfm': {
      'fences': /^( *)(([`~])\3{2,})[ \t]*([^\n`~]+)?[ \t]*(?:\n([\s\S]*?))??(?:\n\ {0,3}\2\3*[ \t]*(?=\n|$)|$)/,
      'paragraph': /^(?:(?:[^\n]+\n?(?![ \t]*([-*_])( *\1){2,} *(?=\n|$)|( *)(([`~])\5{2,})[ \t]*([^\n`~]+)?[ \t]*(?:\n([\s\S]*?))??(?:\n\ {0,3}\4\5*[ \t]*(?=\n|$)|$)|([ \t]*)((?:[*+-]|\d+\.))[ \t][\s\S]+?(?:(?=\n+\8?(?:[-*_][ \t]*){3,}(?:\n|$))|(?=\n+[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))|\n{2,}(?![ \t])(?!\8(?:[*+-]|\d+\.)[ \t])|$)|([ \t]*)(#{1,6})(?:([ \t]+)([^\n]+?))??(?:[ \t]+#+)?[ \t]*(?=\n|$)|(\ {0,3})([^\n]+?)[ \t]*\n\ {0,3}(=|-){1,}[ \t]*(?=\n|$)|[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$)|(?=[ \t]*>)(?:(?:(?:[ \t]*>[^\n]*\n)*(?:[ \t]*>[^\n]+(?=\n|$))|(?![ \t]*>)(?![ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))[^\n]+)(?:\n|$))*(?:[ \t]*>[ \t]*(?:\n[ \t]*>[ \t]*)*)?|<(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\b)(?!mailto:)\w+(?!:\/|[^\w\s@]*@)\b))+)/,
      'table': /^( *\|(.+))\n( *\|( *[-:]+[-| :]*)\n)((?: *\|.*(?:\n|$))*)/,
      'looseTable': /^( *(\S.*\|.*))\n( *([-:]+ *\|[-| :]*)\n)((?:.*\|.*(?:\n|$))*)/,
      'escape': /^\\([\\`*{}\[\]()#+\-.!_>~|])/,
      'url': /^https?:\/\/[^\s<]+[^<.,:;"')\]\s]/,
      'deletion': /^~~(?=\S)([\s\S]*?\S)~~/,
      'inlineText': /^[\s\S]+?(?=[\\<!\[_*`~]|https?:\/\/| {2,}\n|$)/
    },
    'footnotes': {
      'footnoteDefinition': /^( *\[\^([^\]]+)\]: *)([^\n]+(\n+ +[^\n]+)*)/
    },
    'yaml': {
      'yamlFrontMatter': /^-{3}\n([\s\S]+?\n)?-{3}/
    },
    'pedantic': {
      'heading': /^([ \t]*)(#{1,6})([ \t]*)([^\n]*?)[ \t]*#*[ \t]*(?=\n|$)/,
      'strong': /^(_)_(?=\S)([\s\S]*?\S)__(?!_)|^(\*)\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
      'emphasis': /^(_)(?=\S)([\s\S]*?\S)_(?!_)|^(\*)(?=\S)([\s\S]*?\S)\*(?!\*)/
    },
    'commonmark': {
      'list': /^([ \t]*)((?:[*+-]|\d+[\.\)]))[ \t][\s\S]+?(?:(?=\n+\1?(?:[-*_][ \t]*){3,}(?:\n|$))|(?=\n+[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))|\n{2,}(?![ \t])(?!\1(?:[*+-]|\d+[\.\)])[ \t])|$)/,
      'item': /([ \t]*)((?:[*+-]|\d+[\.\)]))( {1,4}(?! )| |\t)[^\n]*(?:\n(?!\1(?:[*+-]|\d+[\.\)])[ \t])[^\n]*)*/gm,
      'bullet': /(?:[*+-]|\d+[\.\)])/,
      'indent': /^([ \t]*)((?:[*+-]|\d+[\.\)]))( {1,4}(?! )| |\t)/,
      'link': /^(!?\[)((?:(?:\[(?:\[(?:\\[\s\S]|[^\[\]])*?\]|\\[\s\S]|[^\[\]])*?\])|\\[\s\S]|[^\[\]])*?)\]\(\s*(?:(?!<)((?:\((?:\\[\s\S]|[^\(\)\s])*?\)|\\[\s\S]|[^\(\)\s])*?)|<([^\n]*?)>)(?:\s+(?:\'((?:\\[\s\S]|[^\'])*?)\'|"((?:\\[\s\S]|[^"])*?)"|\(((?:\\[\s\S]|[^\)])*?)\)))?\s*\)/,
      'reference': /^(!?\[)((?:(?:\[(?:\[(?:\\[\s\S]|[^\[\]])*?\]|\\[\s\S]|[^\[\]])*?\])|\\[\s\S]|[^\[\]])*?)\]\s*\[((?:\\[\s\S]|[^\[\]])*)\]/,
      'paragraph': /^(?:(?:[^\n]+\n?(?!\ {0,3}([-*_])( *\1){2,} *(?=\n|$)|(\ {0,3})(#{1,6})(?:([ \t]+)([^\n]+?))??(?:[ \t]+#+)?\ {0,3}(?=\n|$)|(?=\ {0,3}>)(?:(?:(?:\ {0,3}>[^\n]*\n)*(?:\ {0,3}>[^\n]+(?=\n|$))|(?!\ {0,3}>)(?!\ {0,3}\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?\ {0,3}(?=\n|$))[^\n]+)(?:\n|$))*(?:\ {0,3}>\ {0,3}(?:\n\ {0,3}>\ {0,3})*)?|<(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\b)(?!mailto:)\w+(?!:\/|[^\w\s@]*@)\b))+)/,
      'blockquote': /^(?=[ \t]*>)(?:(?:(?:[ \t]*>[^\n]*\n)*(?:[ \t]*>[^\n]+(?=\n|$))|(?![ \t]*>)(?![ \t]*([-*_])( *\1){2,} *(?=\n|$)|([ \t]*)((?:[*+-]|\d+\.))[ \t][\s\S]+?(?:(?=\n+\3?(?:[-*_][ \t]*){3,}(?:\n|$))|(?=\n+[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))|\n{2,}(?![ \t])(?!\3(?:[*+-]|\d+\.)[ \t])|$)|( *)(([`~])\10{2,})[ \t]*([^\n`~]+)?[ \t]*(?:\n([\s\S]*?))??(?:\n\ {0,3}\9\10*[ \t]*(?=\n|$)|$)|((?: {4}|\t)[^\n]*\n?([ \t]*\n)*)+|[ \t]*\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?[ \t]*(?=\n|$))[^\n]+)(?:\n|$))*(?:[ \t]*>[ \t]*(?:\n[ \t]*>[ \t]*)*)?/,
      'escape': /^\\(\n|[\\`*{}\[\]()#+\-.!_>"$%&',\/:;<=?@^~|])/
    },
    'commonmarkGFM': {
      'paragraph': /^(?:(?:[^\n]+\n?(?!\ {0,3}([-*_])( *\1){2,} *(?=\n|$)|( *)(([`~])\5{2,})\ {0,3}([^\n`~]+)?\ {0,3}(?:\n([\s\S]*?))??(?:\n\ {0,3}\4\5*\ {0,3}(?=\n|$)|$)|(\ {0,3})((?:[*+-]|\d+\.))[ \t][\s\S]+?(?:(?=\n+\8?(?:[-*_]\ {0,3}){3,}(?:\n|$))|(?=\n+\ {0,3}\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?\ {0,3}(?=\n|$))|\n{2,}(?![ \t])(?!\8(?:[*+-]|\d+\.)[ \t])|$)|(\ {0,3})(#{1,6})(?:([ \t]+)([^\n]+?))??(?:[ \t]+#+)?\ {0,3}(?=\n|$)|(?=\ {0,3}>)(?:(?:(?:\ {0,3}>[^\n]*\n)*(?:\ {0,3}>[^\n]+(?=\n|$))|(?!\ {0,3}>)(?!\ {0,3}\[((?:[^\\](?:\\|\\(?:\\{2})+)\]|[^\]])+)\]:[ \t\n]*(<[^>\[\]]+>|[^\s\[\]]+)(?:[ \t\n]+['"(]((?:[^\n]|\n(?!\n))*?)['")])?\ {0,3}(?=\n|$))[^\n]+)(?:\n|$))*(?:\ {0,3}>\ {0,3}(?:\n\ {0,3}>\ {0,3})*)?|<(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\b)(?!mailto:)\w+(?!:\/|[^\w\s@]*@)\b))+)/
    },
    'breaks': {
      'break': /^ *\n(?!\s*$)/,
      'inlineText': /^[\s\S]+?(?=[\\<!\[_*`]| *\n|$)/
    },
    'breaksGFM': {
      'inlineText': /^[\s\S]+?(?=[\\<!\[_*`~]|https?:\/\/| *\n|$)/
    }
  };
  
  
  /***/ }),
  
  /***/ 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';
  };
  
  
  /***/ }),
  
  /***/ 325:
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = identity
  
  try {
    normalize('')
    module.exports = normalize
  } catch (_) {}
  
  // Normalize `uri`.
  function normalize(uri) {
    return encodeURI(decodeURI(uri))
  }
  
  /* istanbul ignore next - Fallback, return input. */
  function identity(uri) {
    return uri
  }
  
  
  /***/ }),
  
  /***/ 336:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = hasLastPage
  
  const deprecate = __webpack_require__(370)
  const getPageLinks = __webpack_require__(577)
  
  function hasLastPage (link) {
    deprecate(`octokit.hasLastPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`)
    return getPageLinks(link).last
  }
  
  
  /***/ }),
  
  /***/ 348:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = validate;
  
  const { RequestError } = __webpack_require__(497);
  const get = __webpack_require__(854);
  const set = __webpack_require__(883);
  
  function validate(octokit, options) {
    if (!options.request.validate) {
      return;
    }
    const { validate: params } = options.request;
  
    Object.keys(params).forEach(parameterName => {
      const parameter = get(params, parameterName);
  
      const expectedType = parameter.type;
      let parentParameterName;
      let parentValue;
      let parentParamIsPresent = true;
      let parentParameterIsArray = false;
  
      if (/\./.test(parameterName)) {
        parentParameterName = parameterName.replace(/\.[^.]+$/, "");
        parentParameterIsArray = parentParameterName.slice(-2) === "[]";
        if (parentParameterIsArray) {
          parentParameterName = parentParameterName.slice(0, -2);
        }
        parentValue = get(options, parentParameterName);
        parentParamIsPresent =
          parentParameterName === "headers" ||
          (typeof parentValue === "object" && parentValue !== null);
      }
  
      const values = parentParameterIsArray
        ? (get(options, parentParameterName) || []).map(
            value => value[parameterName.split(/\./).pop()]
          )
        : [get(options, parameterName)];
  
      values.forEach((value, i) => {
        const valueIsPresent = typeof value !== "undefined";
        const valueIsNull = value === null;
        const currentParameterName = parentParameterIsArray
          ? parameterName.replace(/\[\]/, `[${i}]`)
          : parameterName;
  
        if (!parameter.required && !valueIsPresent) {
          return;
        }
  
        // if the parent parameter is of type object but allows null
        // then the child parameters can be ignored
        if (!parentParamIsPresent) {
          return;
        }
  
        if (parameter.allowNull && valueIsNull) {
          return;
        }
  
        if (!parameter.allowNull && valueIsNull) {
          throw new RequestError(
            `'${currentParameterName}' cannot be null`,
            400,
            {
              request: options
            }
          );
        }
  
        if (parameter.required && !valueIsPresent) {
          throw new RequestError(
            `Empty value for parameter '${currentParameterName}': ${JSON.stringify(
              value
            )}`,
            400,
            {
              request: options
            }
          );
        }
  
        // parse to integer before checking for enum
        // so that string "1" will match enum with number 1
        if (expectedType === "integer") {
          const unparsedValue = value;
          value = parseInt(value, 10);
          if (isNaN(value)) {
            throw new RequestError(
              `Invalid value for parameter '${currentParameterName}': ${JSON.stringify(
                unparsedValue
              )} is NaN`,
              400,
              {
                request: options
              }
            );
          }
        }
  
        if (parameter.enum && parameter.enum.indexOf(String(value)) === -1) {
          throw new RequestError(
            `Invalid value for parameter '${currentParameterName}': ${JSON.stringify(
              value
            )}`,
            400,
            {
              request: options
            }
          );
        }
  
        if (parameter.validation) {
          const regex = new RegExp(parameter.validation);
          if (!regex.test(value)) {
            throw new RequestError(
              `Invalid value for parameter '${currentParameterName}': ${JSON.stringify(
                value
              )}`,
              400,
              {
                request: options
              }
            );
          }
        }
  
        if (expectedType === "object" && typeof value === "string") {
          try {
            value = JSON.parse(value);
          } catch (exception) {
            throw new RequestError(
              `JSON parse error of value for parameter '${currentParameterName}': ${JSON.stringify(
                value
              )}`,
              400,
              {
                request: options
              }
            );
          }
        }
  
        set(options, parameter.mapTo || currentParameterName, value);
      });
    });
  
    return options;
  }
  
  
  /***/ }),
  
  /***/ 349:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationRequestError;
  
  const { RequestError } = __webpack_require__(497);
  
  function authenticationRequestError(state, error, options) {
    /* istanbul ignore next */
    if (!error.headers) throw error;
  
    const otpRequired = /required/.test(error.headers["x-github-otp"] || "");
    // handle "2FA required" error only
    if (error.status !== 401 || !otpRequired) {
      throw error;
    }
  
    if (
      error.status === 401 &&
      otpRequired &&
      error.request &&
      error.request.headers["x-github-otp"]
    ) {
      throw new RequestError(
        "Invalid one-time password for two-factor authentication",
        401,
        {
          headers: error.headers,
          request: options
        }
      );
    }
  
    if (typeof state.auth.on2fa !== "function") {
      throw new RequestError(
        "2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication",
        401,
        {
          headers: error.headers,
          request: options
        }
      );
    }
  
    return Promise.resolve()
      .then(() => {
        return state.auth.on2fa();
      })
      .then(oneTimePassword => {
        const newOptions = Object.assign(options, {
          headers: Object.assign(
            { "x-github-otp": oneTimePassword },
            options.headers
          )
        });
        return state.octokit.request(newOptions);
      });
  }
  
  
  /***/ }),
  
  /***/ 357:
  /***/ (function(module) {
  
  module.exports = require("assert");
  
  /***/ }),
  
  /***/ 363:
  /***/ (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)()
      })
  }
  
  
  /***/ }),
  
  /***/ 366:
  /***/ (function(module) {
  
  "use strict";
  
  
  /*
   * Useful expressions.
   */
  
  var EXPRESSION_DOT = /\./;
  var EXPRESSION_LAST_DOT = /\.[^.]*$/;
  
  /*
   * Allowed alignment values.
   */
  
  var LEFT = 'l';
  var RIGHT = 'r';
  var CENTER = 'c';
  var DOT = '.';
  var NULL = '';
  
  var ALLIGNMENT = [LEFT, RIGHT, CENTER, DOT, NULL];
  
  /*
   * Characters.
   */
  
  var COLON = ':';
  var DASH = '-';
  var PIPE = '|';
  var SPACE = ' ';
  var NEW_LINE = '\n';
  
  /**
   * Get the length of `value`.
   *
   * @param {string} value
   * @return {number}
   */
  function lengthNoop(value) {
      return String(value).length;
  }
  
  /**
   * Get a string consisting of `length` `character`s.
   *
   * @param {number} length
   * @param {string} [character=' ']
   * @return {string}
   */
  function pad(length, character) {
      return Array(length + 1).join(character || SPACE);
  }
  
  /**
   * Get the position of the last dot in `value`.
   *
   * @param {string} value
   * @return {number}
   */
  function dotindex(value) {
      var match = EXPRESSION_LAST_DOT.exec(value);
  
      return match ? match.index + 1 : value.length;
  }
  
  /**
   * Create a table from a matrix of strings.
   *
   * @param {Array.<Array.<string>>} table
   * @param {Object?} options
   * @param {boolean?} [options.rule=true]
   * @param {string?} [options.delimiter=" | "]
   * @param {string?} [options.start="| "]
   * @param {string?} [options.end=" |"]
   * @param {Array.<string>?} options.align
   * @param {function(string)?} options.stringLength
   * @return {string} Pretty table
   */
  function markdownTable(table, options) {
      var settings = options || {};
      var delimiter = settings.delimiter;
      var start = settings.start;
      var end = settings.end;
      var alignment = settings.align;
      var calculateStringLength = settings.stringLength || lengthNoop;
      var cellCount = 0;
      var rowIndex = -1;
      var rowLength = table.length;
      var sizes = [];
      var align;
      var rule;
      var rows;
      var row;
      var cells;
      var index;
      var position;
      var size;
      var value;
      var spacing;
      var before;
      var after;
  
      alignment = alignment ? alignment.concat() : [];
  
      if (delimiter === null || delimiter === undefined) {
          delimiter = SPACE + PIPE + SPACE;
      }
  
      if (start === null || start === undefined) {
          start = PIPE + SPACE;
      }
  
      if (end === null || end === undefined) {
          end = SPACE + PIPE;
      }
  
      while (++rowIndex < rowLength) {
          row = table[rowIndex];
  
          index = -1;
  
          if (row.length > cellCount) {
              cellCount = row.length;
          }
  
          while (++index < cellCount) {
              position = row[index] ? dotindex(row[index]) : null;
  
              if (!sizes[index]) {
                  sizes[index] = 3;
              }
  
              if (position > sizes[index]) {
                  sizes[index] = position;
              }
          }
      }
  
      if (typeof alignment === 'string') {
          alignment = pad(cellCount, alignment).split('');
      }
  
      /*
       * Make sure only valid alignments are used.
       */
  
      index = -1;
  
      while (++index < cellCount) {
          align = alignment[index];
  
          if (typeof align === 'string') {
              align = align.charAt(0).toLowerCase();
          }
  
          if (ALLIGNMENT.indexOf(align) === -1) {
              align = NULL;
          }
  
          alignment[index] = align;
      }
  
      rowIndex = -1;
      rows = [];
  
      while (++rowIndex < rowLength) {
          row = table[rowIndex];
  
          index = -1;
          cells = [];
  
          while (++index < cellCount) {
              value = row[index];
  
              if (value === null || value === undefined) {
                  value = '';
              } else {
                  value = String(value);
              }
  
              if (alignment[index] !== DOT) {
                  cells[index] = value;
              } else {
                  position = dotindex(value);
  
                  size = sizes[index] +
                      (EXPRESSION_DOT.test(value) ? 0 : 1) -
                      (calculateStringLength(value) - position);
  
                  cells[index] = value + pad(size - 1);
              }
          }
  
          rows[rowIndex] = cells;
      }
  
      sizes = [];
      rowIndex = -1;
  
      while (++rowIndex < rowLength) {
          cells = rows[rowIndex];
  
          index = -1;
  
          while (++index < cellCount) {
              value = cells[index];
  
              if (!sizes[index]) {
                  sizes[index] = 3;
              }
  
              size = calculateStringLength(value);
  
              if (size > sizes[index]) {
                  sizes[index] = size;
              }
          }
      }
  
      rowIndex = -1;
  
      while (++rowIndex < rowLength) {
          cells = rows[rowIndex];
  
          index = -1;
  
          while (++index < cellCount) {
              value = cells[index];
  
              position = sizes[index] - (calculateStringLength(value) || 0);
              spacing = pad(position);
  
              if (alignment[index] === RIGHT || alignment[index] === DOT) {
                  value = spacing + value;
              } else if (alignment[index] !== CENTER) {
                  value = value + spacing;
              } else {
                  position = position / 2;
  
                  if (position % 1 === 0) {
                      before = position;
                      after = position;
                  } else {
                      before = position + 0.5;
                      after = position - 0.5;
                  }
  
                  value = pad(before) + value + pad(after);
              }
  
              cells[index] = value;
          }
  
          rows[rowIndex] = cells.join(delimiter);
      }
  
      if (settings.rule !== false) {
          index = -1;
          rule = [];
  
          while (++index < cellCount) {
              align = alignment[index];
  
              /*
               * When `align` is left, don't add colons.
               */
  
              value = align === RIGHT || align === NULL ? DASH : COLON;
              value += pad(sizes[index] - 2, DASH);
              value += align !== LEFT && align !== NULL ? COLON : DASH;
  
              rule[index] = value;
          }
  
          rows.splice(1, 0, rule.join(delimiter));
      }
  
      return start + rows.join(end + NEW_LINE + start) + end;
  }
  
  /*
   * Expose `markdownTable`.
   */
  
  module.exports = markdownTable;
  
  
  /***/ }),
  
  /***/ 368:
  /***/ (function(module) {
  
  module.exports = function atob(str) {
    return Buffer.from(str, 'base64').toString('binary')
  }
  
  
  /***/ }),
  
  /***/ 370:
  /***/ (function(module) {
  
  module.exports = deprecate
  
  const loggedMessages = {}
  
  function deprecate (message) {
    if (loggedMessages[message]) {
      return
    }
  
    console.warn(`DEPRECATED (@octokit/rest): ${message}`)
    loggedMessages[message] = 1
  }
  
  
  /***/ }),
  
  /***/ 385:
  /***/ (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 isPlainObject = _interopDefault(__webpack_require__(626));
  var universalUserAgent = __webpack_require__(796);
  
  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(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 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);
    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 isBinaryRequset = /application\/octet-stream/i.test(headers.accept);
  
    if (!isBinaryRequset) {
      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.3";
  
  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
  
  
  /***/ }),
  
  /***/ 389:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const fs = __webpack_require__(747);
  const shebangCommand = __webpack_require__(866);
  
  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;
  
  
  /***/ }),
  
  /***/ 402:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = Octokit;
  
  const { request } = __webpack_require__(753);
  const Hook = __webpack_require__(523);
  
  const parseClientOptions = __webpack_require__(294);
  
  function Octokit(plugins, options) {
    options = options || {};
    const hook = new Hook.Collection();
    const log = Object.assign(
      {
        debug: () => {},
        info: () => {},
        warn: console.warn,
        error: console.error
      },
      options && options.log
    );
    const api = {
      hook,
      log,
      request: request.defaults(parseClientOptions(options, log, hook))
    };
  
    plugins.forEach(pluginFunction => pluginFunction(api, options));
  
    return api;
  }
  
  
  /***/ }),
  
  /***/ 413:
  /***/ (function(module) {
  
  module.exports = require("stream");
  
  /***/ }),
  
  /***/ 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__(669);
  
  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}`;
  }
  
  
  
  /***/ }),
  
  /***/ 430:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = octokitValidate;
  
  const validate = __webpack_require__(348);
  
  function octokitValidate(octokit) {
    octokit.hook.before("request", validate.bind(null, octokit));
  }
  
  
  /***/ }),
  
  /***/ 431:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const os = __importStar(__webpack_require__(87));
  /**
   * 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;
      }
  }
  /**
   * 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;
  function escapeData(s) {
      return toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 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:
  /***/ (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__(413));
  var http = _interopDefault(__webpack_require__(605));
  var Url = _interopDefault(__webpack_require__(835));
  var https = _interopDefault(__webpack_require__(211));
  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 = /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(`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
  						};
  
  						// 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;
  
  
  /***/ }),
  
  /***/ 462:
  /***/ (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;
  
  
  /***/ }),
  
  /***/ 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 logOnce = 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;
      Object.defineProperty(this, "code", {
        get() {
          logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
          return statusCode;
        }
  
      });
      this.headers = options.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;
    }
  
  }
  
  exports.RequestError = RequestError;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 469:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  // Originally pulled from https://github.com/JasonEtco/actions-toolkit/blob/master/src/github.ts
  const graphql_1 = __webpack_require__(898);
  const rest_1 = __webpack_require__(0);
  const Context = __importStar(__webpack_require__(262));
  const httpClient = __importStar(__webpack_require__(539));
  // We need this in order to extend Octokit
  rest_1.Octokit.prototype = new rest_1.Octokit();
  exports.context = new Context.Context();
  class GitHub extends rest_1.Octokit {
      constructor(token, opts) {
          super(GitHub.getOctokitOptions(GitHub.disambiguate(token, opts)));
          this.graphql = GitHub.getGraphQL(GitHub.disambiguate(token, opts));
      }
      /**
       * Disambiguates the constructor overload parameters
       */
      static disambiguate(token, opts) {
          return [
              typeof token === 'string' ? token : '',
              typeof token === 'object' ? token : opts || {}
          ];
      }
      static getOctokitOptions(args) {
          const token = args[0];
          const options = Object.assign({}, args[1]); // Shallow clone - don't mutate the object provided by the caller
          // Base URL - GHES or Dotcom
          options.baseUrl = options.baseUrl || this.getApiBaseUrl();
          // Auth
          const auth = GitHub.getAuthString(token, options);
          if (auth) {
              options.auth = auth;
          }
          // Proxy
          const agent = GitHub.getProxyAgent(options.baseUrl, options);
          if (agent) {
              // Shallow clone - don't mutate the object provided by the caller
              options.request = options.request ? Object.assign({}, options.request) : {};
              // Set the agent
              options.request.agent = agent;
          }
          return options;
      }
      static getGraphQL(args) {
          const defaults = {};
          defaults.baseUrl = this.getGraphQLBaseUrl();
          const token = args[0];
          const options = args[1];
          // Authorization
          const auth = this.getAuthString(token, options);
          if (auth) {
              defaults.headers = {
                  authorization: auth
              };
          }
          // Proxy
          const agent = GitHub.getProxyAgent(defaults.baseUrl, options);
          if (agent) {
              defaults.request = { agent };
          }
          return graphql_1.graphql.defaults(defaults);
      }
      static getAuthString(token, options) {
          // Validate args
          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}`;
      }
      static getProxyAgent(destinationUrl, options) {
          var _a;
          if (!((_a = options.request) === null || _a === void 0 ? void 0 : _a.agent)) {
              if (httpClient.getProxyUrl(destinationUrl)) {
                  const hc = new httpClient.HttpClient();
                  return hc.getAgent(destinationUrl);
              }
          }
          return undefined;
      }
      static getApiBaseUrl() {
          return process.env['GITHUB_API_URL'] || 'https://api.github.com';
      }
      static getGraphQLBaseUrl() {
          let url = process.env['GITHUB_GRAPHQL_URL'] || 'https://api.github.com/graphql';
          // Shouldn't be a trailing slash, but remove if so
          if (url.endsWith('/')) {
              url = url.substr(0, url.length - 1);
          }
          // Remove trailing "/graphql"
          if (url.toUpperCase().endsWith('/GRAPHQL')) {
              url = url.substr(0, url.length - '/graphql'.length);
          }
          return url;
      }
  }
  exports.GitHub = GitHub;
  //# sourceMappingURL=github.js.map
  
  /***/ }),
  
  /***/ 470:
  /***/ (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());
      });
  };
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const command_1 = __webpack_require__(431);
  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 = command_1.toCommandValue(val);
      process.env[name] = convertedVal;
      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) {
      command_1.issueCommand('add-path', {}, inputPath);
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.  The value is also trimmed.
   *
   * @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}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * 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) {
      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:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationBeforeRequest;
  
  const btoa = __webpack_require__(675);
  const uniq = __webpack_require__(126);
  
  function authenticationBeforeRequest(state, options) {
    if (!state.auth.type) {
      return;
    }
  
    if (state.auth.type === "basic") {
      const hash = btoa(`${state.auth.username}:${state.auth.password}`);
      options.headers.authorization = `Basic ${hash}`;
      return;
    }
  
    if (state.auth.type === "token") {
      options.headers.authorization = `token ${state.auth.token}`;
      return;
    }
  
    if (state.auth.type === "app") {
      options.headers.authorization = `Bearer ${state.auth.token}`;
      const acceptHeaders = options.headers.accept
        .split(",")
        .concat("application/vnd.github.machine-man-preview+json");
      options.headers.accept = uniq(acceptHeaders)
        .filter(Boolean)
        .join(",");
      return;
    }
  
    options.url += options.url.indexOf("?") === -1 ? "?" : "&";
  
    if (state.auth.token) {
      options.url += `access_token=${encodeURIComponent(state.auth.token)}`;
      return;
    }
  
    const key = encodeURIComponent(state.auth.key);
    const secret = encodeURIComponent(state.auth.secret);
    options.url += `client_id=${key}&client_secret=${secret}`;
  }
  
  
  /***/ }),
  
  /***/ 489:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(622);
  const which = __webpack_require__(814);
  const pathKey = __webpack_require__(39)();
  
  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;
  
  
  /***/ }),
  
  /***/ 497:
  /***/ (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 logOnce = 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;
      Object.defineProperty(this, "code", {
        get() {
          logOnce(new deprecation.Deprecation("[@octokit/request-error] `error.code` is deprecated, use `error.status`."));
          return statusCode;
        }
  
      });
      this.headers = options.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;
    }
  
  }
  
  exports.RequestError = RequestError;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 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
    })
  }
  
  
  /***/ }),
  
  /***/ 523:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var register = __webpack_require__(363)
  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
  
  
  /***/ }),
  
  /***/ 529:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const factory = __webpack_require__(47);
  
  module.exports = factory();
  
  
  /***/ }),
  
  /***/ 536:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = hasFirstPage
  
  const deprecate = __webpack_require__(370)
  const getPageLinks = __webpack_require__(577)
  
  function hasFirstPage (link) {
    deprecate(`octokit.hasFirstPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`)
    return getPageLinks(link).first
  }
  
  
  /***/ }),
  
  /***/ 539:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const url = __webpack_require__(835);
  const http = __webpack_require__(605);
  const https = __webpack_require__(211);
  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(url.parse(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 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 = url.parse(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 = url.parse(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 = url.parse(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 = url.parse(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__(856);
              }
              const agentOptions = {
                  maxSockets: maxSockets,
                  keepAlive: this._keepAlive,
                  proxy: {
                      proxyAuth: proxyUrl.auth,
                      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 Error(msg);
                  // attach statusCode and body obj (if available) to the error object
                  err['statusCode'] = statusCode;
                  if (response.result) {
                      err['result'] = response.result;
                  }
                  reject(err);
              }
              else {
                  resolve(response);
              }
          });
      }
  }
  exports.HttpClient = HttpClient;
  
  
  /***/ }),
  
  /***/ 548:
  /***/ (function(module) {
  
  "use strict";
  
  
  /*!
   * isobject <https://github.com/jonschlinkert/isobject>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObject(val) {
    return val != null && typeof val === 'object' && Array.isArray(val) === false;
  }
  
  /*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObjectObject(o) {
    return isObject(o) === true
      && Object.prototype.toString.call(o) === '[object Object]';
  }
  
  function isPlainObject(o) {
    var ctor,prot;
  
    if (isObjectObject(o) === false) return false;
  
    // If has modified constructor
    ctor = o.constructor;
    if (typeof ctor !== 'function') return false;
  
    // If has modified prototype
    prot = ctor.prototype;
    if (isObjectObject(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;
  }
  
  module.exports = isPlainObject;
  
  
  /***/ }),
  
  /***/ 550:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = getNextPage
  
  const getPage = __webpack_require__(265)
  
  function getNextPage (octokit, link, headers) {
    return getPage(octokit, link, 'next', headers)
  }
  
  
  /***/ }),
  
  /***/ 558:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = hasPreviousPage
  
  const deprecate = __webpack_require__(370)
  const getPageLinks = __webpack_require__(577)
  
  function hasPreviousPage (link) {
    deprecate(`octokit.hasPreviousPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`)
    return getPageLinks(link).prev
  }
  
  
  /***/ }),
  
  /***/ 563:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = getPreviousPage
  
  const getPage = __webpack_require__(265)
  
  function getPreviousPage (octokit, link, headers) {
    return getPage(octokit, link, 'prev', headers)
  }
  
  
  /***/ }),
  
  /***/ 568:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  const path = __webpack_require__(622);
  const niceTry = __webpack_require__(948);
  const resolveCommand = __webpack_require__(489);
  const escape = __webpack_require__(462);
  const readShebang = __webpack_require__(389);
  const semver = __webpack_require__(280);
  
  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;
  
  
  /***/ }),
  
  /***/ 575:
  /***/ (function(module) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module Defaults
   * @fileoverview Default values for parse and
   *  stringification settings.
   */
  
  
  
  /*
   * Note that `stringify.entities` is a string.
   */
  
  module.exports = {
      'parse': {
          'position': true,
          'gfm': true,
          'yaml': true,
          'commonmark': false,
          'footnotes': false,
          'pedantic': false,
          'breaks': false
      },
      'stringify': {
          'entities': 'false',
          'setext': false,
          'closeAtx': false,
          'looseTable': false,
          'spacedTable': true,
          'incrementListMarker': true,
          'fences': false,
          'fence': '`',
          'bullet': '-',
          'listItemIndent': 'tab',
          'rule': '*',
          'ruleSpaces': true,
          'ruleRepetition': 3,
          'strong': '*',
          'emphasis': '_'
      }
  };
  
  
  /***/ }),
  
  /***/ 577:
  /***/ (function(module) {
  
  module.exports = getPageLinks
  
  function getPageLinks (link) {
    link = link.link || link.headers.link || ''
  
    const links = {}
  
    // link format:
    // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
    link.replace(/<([^>]*)>;\s*rel="([\w]*)"/g, (m, uri, type) => {
      links[type] = uri
    })
  
    return links
  }
  
  
  /***/ }),
  
  /***/ 589:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  /**
   * Module Dependencies
   */
  
  var slice = [].slice;
  var wrap = __webpack_require__(986);
  
  /**
   * Expose `Ware`.
   */
  
  module.exports = Ware;
  
  /**
   * Throw an error.
   *
   * @param {Error} error
   */
  
  function fail (err) {
    throw err;
  }
  
  /**
   * Initialize a new `Ware` manager, with optional `fns`.
   *
   * @param {Function or Array or Ware} fn (optional)
   */
  
  function Ware (fn) {
    if (!(this instanceof Ware)) return new Ware(fn);
    this.fns = [];
    if (fn) this.use(fn);
  }
  
  /**
   * Use a middleware `fn`.
   *
   * @param {Function or Array or Ware} fn
   * @return {Ware}
   */
  
  Ware.prototype.use = function (fn) {
    if (fn instanceof Ware) {
      return this.use(fn.fns);
    }
  
    if (fn instanceof Array) {
      for (var i = 0, f; f = fn[i++];) this.use(f);
      return this;
    }
  
    this.fns.push(fn);
    return this;
  };
  
  /**
   * Run through the middleware with the given `args` and optional `callback`.
   *
   * @param {Mixed} args...
   * @param {Function} callback (optional)
   * @return {Ware}
   */
  
  Ware.prototype.run = function () {
    var fns = this.fns;
    var ctx = this;
    var i = 0;
    var last = arguments[arguments.length - 1];
    var done = 'function' == typeof last && last;
    var args = done
      ? slice.call(arguments, 0, arguments.length - 1)
      : slice.call(arguments);
  
    // next step
    function next (err) {
      if (err) return (done || fail)(err);
      var fn = fns[i++];
      var arr = slice.call(args);
  
      if (!fn) {
        return done && done.apply(null, [null].concat(args));
      }
  
      wrap(fn, next).apply(ctx, arr);
    }
  
    next();
  
    return this;
  };
  
  
  /***/ }),
  
  /***/ 602:
  /***/ (function(module) {
  
  "use strict";
  
  
  /*
   * Constants.
   */
  
  var LINE = '\n';
  var EMPTY = '';
  var SPACE = ' ';
  var GT = '>';
  var LT = '<';
  var SLASH = '/';
  var QUOTE = '"';
  var EQUALS = '=';
  
  /*
   * List of self-closing tags.
   */
  
  var CLOSING = ['hr', 'img', 'br'];
  
  /**
   * Compile attributes.
   *
   * @param {Object?} attributes - Map of attributes.
   * @param {function(string): string} encode - Strategy
   *   to use.
   * @param {Node} node - mdast node currently being
   *   compiled.
   * @return {string} - HTML attributes.
   */
  function toAttributes(attributes, encode, node) {
      var parameters = [];
      var key;
      var value;
  
      if (attributes) {
          for (key in attributes) {
              value = attributes[key];
  
              if (value !== null && value !== undefined) {
                  value = encode(String(value || EMPTY), node);
                  parameters.push(key + EQUALS + QUOTE + value + QUOTE);
              }
          }
      }
  
      return parameters.length ? parameters.join(SPACE) : EMPTY;
  }
  
  /**
   * Compile a `node`, in `context`, into HTML.
   *
   * @example
   *   h(compiler, {
   *     'type': 'break'
   *     'attributes': {
   *       'id': 'foo'
   *     }
   *   }, 'br') // '<br id="foo">'
   *
   *   h(compiler, {
   *     'type': 'break'
   *   }, 'br', {
   *     'id': 'foo'
   *   }) // '<br id="foo">'
   *
   * @param {HTMLCompiler} context
   * @param {Node} node - mdast node.  If `node` has an
   *   `attributes` hash, its properties are also stringified
   *   as HTML attributes on the resulting node.
   * @param {string} name - Tag name to compile as.
   * @param {Object?} [attributes] - Attributes to add to the
   *   resulting node.
   * @param {string?} [children] - HTML to insert inside
   *   the resulting node.
   * @param {boolean} [loose] - Whether to add an initial and
   *   a trailing newline character inside the opening and
   *   closing tags.
   * @return {string} - HTML representation of `node`, based
   *   on the given options.
   */
  function h(context, node, name, attributes, children, loose) {
      var closing = CLOSING.indexOf(name) !== -1;
      var value;
      var parameters;
  
      if (typeof children !== 'string' && typeof attributes === 'string') {
          loose = children;
          children = attributes;
          attributes = null;
      }
  
      parameters = toAttributes(attributes, context.encode, node);
  
      value = LT + name + (parameters ? SPACE + parameters : EMPTY);
  
      parameters = node && toAttributes(node.attributes, context.encode, node);
  
      value += parameters ? SPACE + parameters : EMPTY;
  
      if (closing) {
          return value + (context.options.xhtml ? SPACE + SLASH : EMPTY) + GT;
      }
  
      return value + GT +
          (loose ? LINE : EMPTY) +
          (children || EMPTY) +
          (loose && children ? LINE : EMPTY) +
          LT + SLASH + name + GT;
  }
  
  /*
   * Expose.
   */
  
  module.exports = h;
  
  
  /***/ }),
  
  /***/ 605:
  /***/ (function(module) {
  
  module.exports = require("http");
  
  /***/ }),
  
  /***/ 614:
  /***/ (function(module) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ 619:
  /***/ (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__(2));
  
  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>";
      }
  
      throw error;
    }
  }
  
  exports.getUserAgent = getUserAgent;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 621:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const path = __webpack_require__(622);
  const pathKey = __webpack_require__(39);
  
  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;
  };
  
  
  /***/ }),
  
  /***/ 622:
  /***/ (function(module) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ 626:
  /***/ (function(module) {
  
  "use strict";
  
  
  /*!
   * isobject <https://github.com/jonschlinkert/isobject>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObject(val) {
    return val != null && typeof val === 'object' && Array.isArray(val) === false;
  }
  
  /*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   */
  
  function isObjectObject(o) {
    return isObject(o) === true
      && Object.prototype.toString.call(o) === '[object Object]';
  }
  
  function isPlainObject(o) {
    var ctor,prot;
  
    if (isObjectObject(o) === false) return false;
  
    // If has modified constructor
    ctor = o.constructor;
    if (typeof ctor !== 'function') return false;
  
    // If has modified prototype
    prot = ctor.prototype;
    if (isObjectObject(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;
  }
  
  module.exports = isPlainObject;
  
  
  /***/ }),
  
  /***/ 631:
  /***/ (function(module) {
  
  module.exports = require("net");
  
  /***/ }),
  
  /***/ 649:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = getLastPage
  
  const getPage = __webpack_require__(265)
  
  function getLastPage (octokit, link, headers) {
    return getPage(octokit, link, 'last', headers)
  }
  
  
  /***/ }),
  
  /***/ 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'
    )
  }
  
  
  /***/ }),
  
  /***/ 669:
  /***/ (function(module) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ 674:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticate;
  
  const { Deprecation } = __webpack_require__(692);
  const once = __webpack_require__(969);
  
  const deprecateAuthenticate = once((log, deprecation) => log.warn(deprecation));
  
  function authenticate(state, options) {
    deprecateAuthenticate(
      state.octokit.log,
      new Deprecation(
        '[@octokit/rest] octokit.authenticate() is deprecated. Use "auth" constructor option instead.'
      )
    );
  
    if (!options) {
      state.auth = false;
      return;
    }
  
    switch (options.type) {
      case "basic":
        if (!options.username || !options.password) {
          throw new Error(
            "Basic authentication requires both a username and password to be set"
          );
        }
        break;
  
      case "oauth":
        if (!options.token && !(options.key && options.secret)) {
          throw new Error(
            "OAuth2 authentication requires a token or key & secret to be set"
          );
        }
        break;
  
      case "token":
      case "app":
        if (!options.token) {
          throw new Error("Token authentication requires a token to be set");
        }
        break;
  
      default:
        throw new Error(
          "Invalid authentication type, must be 'basic', 'oauth', 'token' or 'app'"
        );
    }
  
    state.auth = options;
  }
  
  
  /***/ }),
  
  /***/ 675:
  /***/ (function(module) {
  
  module.exports = function btoa(str) {
    return new Buffer(str).toString('base64')
  }
  
  
  /***/ }),
  
  /***/ 676:
  /***/ (function(__unusedmodule, __unusedexports, __webpack_require__) {
  
  const fs = __webpack_require__(747);
  const core = __webpack_require__(470);
  const github = __webpack_require__(469);
  const mdjson = __webpack_require__(690);
  
  const ISSUE_TEMPLATE_DIR = ".github/ISSUE_TEMPLATE";
  
  // Grab the closing message from params or fallback to a default message
  const getIssueCloseMessage = () => {
    const message =
      core.getInput("issue-close-message") ||
      "@${issue.user.login}: hello! :wave:\n\nThis issue is being automatically closed because it does not follow the issue template.";
  
    const { payload } = github.context;
  
    return Function(
      ...Object.keys(payload),
      `return \`${message}\``
    )(...Object.values(payload));
  };
  
  (async () => {
    const client = new github.GitHub(
      core.getInput("github-token", { required: true })
    );
  
    const { payload } = github.context;
  
    const issueBodyMarkdown = payload.issue.body;
    // Get all the markdown titles from the issue body
    const issueBodyTitles = Object.keys(mdjson(issueBodyMarkdown));
  
    // Get a list of the templates
    const issueTemplates = fs.readdirSync(ISSUE_TEMPLATE_DIR);
  
    // Compare template titles with issue body
    const doesIssueMatchAnyTemplate = issueTemplates.some(template => {
      if (!Boolean(template.localeCompare("config.yml"))) {
        return false;
      }
      const templateMarkdown = fs.readFileSync(
        `${ISSUE_TEMPLATE_DIR}/${template}`,
        "utf-8"
      );
      const templateTitles = Object.keys(mdjson(templateMarkdown));
  
      return templateTitles.every(title => issueBodyTitles.includes(title));
    });
  
    const { issue } = github.context;
    const closedIssueLabel = core.getInput("closed-issues-label");
  
    if (doesIssueMatchAnyTemplate || payload.action !== "opened") {
      // Only reopen the issue if there's a `closed-issues-label` so it knows that
      // it was previously closed because of the wrong template
      if (payload.issue.state === "closed" && closedIssueLabel) {
        const labels = (
          await client.issues.listLabelsOnIssue({
            owner: issue.owner,
            repo: issue.repo,
            issue_number: issue.number
          })
        ).data.map(({ name }) => name);
  
        if (!labels.includes(closedIssueLabel)) {
          return;
        }
  
        await client.issues.removeLabel({
          owner: issue.owner,
          repo: issue.repo,
          issue_number: issue.number,
          name: closedIssueLabel
        });
  
        await client.issues.update({
          owner: issue.owner,
          repo: issue.repo,
          issue_number: issue.number,
          state: "open"
        });
  
        return;
      }
  
      return;
    }
  
    // If an closed issue label was provided, add it to the issue
    if (closedIssueLabel) {
      await client.issues.addLabels({
        owner: issue.owner,
        repo: issue.repo,
        issue_number: issue.number,
        labels: [closedIssueLabel]
      });
    }
  
    // Add the issue closing comment
    await client.issues.createComment({
      owner: issue.owner,
      repo: issue.repo,
      issue_number: issue.number,
      body: getIssueCloseMessage()
    });
  
    // Close the issue
    await client.issues.update({
      owner: issue.owner,
      repo: issue.repo,
      issue_number: issue.number,
      state: "closed"
    });
  })();
  
  
  /***/ }),
  
  /***/ 681:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  /*
   * Dependencies.
   */
  
  var Ware = __webpack_require__(589);
  var parser = __webpack_require__(953);
  var stringifier = __webpack_require__(695);
  var File = __webpack_require__(161);
  var utilities = __webpack_require__(65);
  
  /*
   * Methods.
   */
  
  var clone = utilities.clone;
  var Parser = parser.Parser;
  var parseProto = Parser.prototype;
  var Compiler = stringifier.Compiler;
  var compileProto = Compiler.prototype;
  
  /**
   * Throws if passed an exception.
   *
   * Here until the following PR is merged into
   * segmentio/ware:
   *
   *   https://github.com/segmentio/ware/pull/21
   *
   * @param {Error?} exception
   */
  function fail(exception) {
      if (exception) {
          throw exception;
      }
  }
  
  /**
   * Create a custom, cloned, Parser.
   *
   * @return {Function}
   */
  function constructParser() {
      var customProto;
      var expressions;
      var key;
  
      /**
       * Extensible prototype.
       */
      function CustomProto() {}
  
      CustomProto.prototype = parseProto;
  
      customProto = new CustomProto();
  
      /**
       * Extensible constructor.
       */
      function CustomParser() {
          Parser.apply(this, arguments);
      }
  
      CustomParser.prototype = customProto;
  
      /*
       * Construct new objects for things that plugin's
       * might modify.
       */
  
      customProto.blockTokenizers = clone(parseProto.blockTokenizers);
      customProto.blockMethods = clone(parseProto.blockMethods);
      customProto.inlineTokenizers = clone(parseProto.inlineTokenizers);
      customProto.inlineMethods = clone(parseProto.inlineMethods);
  
      expressions = parseProto.expressions;
      customProto.expressions = {};
  
      for (key in expressions) {
          customProto.expressions[key] = clone(expressions[key]);
      }
  
      return CustomParser;
  }
  
  /**
   * Create a custom, cloned, Compiler.
   *
   * @return {Function}
   */
  function constructCompiler() {
      var customProto;
  
      /**
       * Extensible prototype.
       */
      function CustomProto() {}
  
      CustomProto.prototype = compileProto;
  
      customProto = new CustomProto();
  
      /**
       * Extensible constructor.
       */
      function CustomCompiler() {
          Compiler.apply(this, arguments);
      }
  
      CustomCompiler.prototype = customProto;
  
      return CustomCompiler;
  }
  
  /**
   * Construct an MDAST instance.
   *
   * @constructor {MDAST}
   */
  function MDAST() {
      var self = this;
  
      if (!(self instanceof MDAST)) {
          return new MDAST();
      }
  
      self.ware = new Ware();
      self.attachers = [];
  
      self.Parser = constructParser();
      self.Compiler = constructCompiler();
  }
  
  /**
   * Attach a plugin.
   *
   * @param {Function|Array.<Function>} attach
   * @param {Object?} options
   * @return {MDAST}
   */
  function use(attach, options) {
      var self = this;
      var index;
      var transformer;
  
      if (!(self instanceof MDAST)) {
          self = new MDAST();
      }
  
      /*
       * Multiple attachers.
       */
  
      if ('length' in attach && typeof attach !== 'function') {
          index = attach.length;
  
          while (attach[--index]) {
              self.use(attach[index]);
          }
  
          return self;
      }
  
      /*
       * Single plugin.
       */
  
      if (self.attachers.indexOf(attach) === -1) {
          transformer = attach(self, options);
  
          self.attachers.push(attach);
  
          if (transformer) {
              self.ware.use(transformer);
          }
      }
  
      return self;
  }
  
  /**
   * Apply transformers to `node`.
   *
   * @param {Node} ast
   * @param {File?} [file]
   * @param {Function?} [done]
   * @return {Node} - `ast`.
   */
  function run(ast, file, done) {
      var self = this;
  
      if (typeof file === 'function') {
          done = file;
          file = null;
      }
  
      file = new File(file);
  
      done = typeof done === 'function' ? done : fail;
  
      if (typeof ast !== 'object' && typeof ast.type !== 'string') {
          utilities.raise(ast, 'ast');
      }
  
      /*
       * Only run when this is an instance of MDAST.
       */
  
      if (self.ware) {
          self.ware.run(ast, file, done);
      } else {
          done(null, ast, file);
      }
  
      return ast;
  }
  
  /**
   * Wrapper to pass a file to `parser`.
   */
  function parse(value, options) {
      return parser.call(this, new File(value), options);
  }
  
  /**
   * Wrapper to pass a file to `stringifier`.
   */
  function stringify(ast, file, options) {
      if (options === null || options === undefined) {
          options = file;
          file = null;
      }
  
      return stringifier.call(this, ast, new File(file), options);
  }
  
  /**
   * Parse a value and apply transformers.
   *
   * @param {string|File} value
   * @param {Object?} [options]
   * @param {Function?} [done]
   * @return {string?}
   */
  function process(value, options, done) {
      var file = new File(value);
      var self = this instanceof MDAST ? this : new MDAST();
      var result = null;
      var ast;
  
      if (typeof options === 'function') {
          done = options;
          options = null;
      }
  
      if (!options) {
          options = {};
      }
  
      /**
       * Invoked when `run` completes. Hoists `result` into
       * the upper scope to return something for sync
       * operations.
       */
      function callback(exception) {
          if (exception) {
              (done || fail)(exception);
          } else {
              result = self.stringify(ast, file, options);
  
              if (done) {
                  done(null, result, file);
              }
          }
      }
  
      ast = self.parse(file, options);
      self.run(ast, file, callback);
  
      return result;
  }
  
  /*
   * Methods.
   */
  
  var proto = MDAST.prototype;
  
  proto.use = use;
  proto.parse = parse;
  proto.run = run;
  proto.stringify = stringify;
  proto.process = process;
  
  /*
   * Functions.
   */
  
  MDAST.use = use;
  MDAST.parse = parse;
  MDAST.run = run;
  MDAST.stringify = stringify;
  MDAST.process = process;
  
  /*
   * Expose `mdast`.
   */
  
  module.exports = MDAST;
  
  
  /***/ }),
  
  /***/ 690:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  const html = __webpack_require__(829)
  const assert = __webpack_require__(357)
  const mdast = __webpack_require__(681)
  
  module.exports = mdjson
  
  // map a markdown string to an object
  // with `html` and `raw` fields
  // str -> obj
  function mdjson (txt) {
    assert.equal(typeof txt, 'string', 'input should be a markdown string')
  
    const toHtml = mdast().use(html)
    const lexer = mdast()
    const tokens = lexer.parse(txt).children
    const res = {}
    var key = ''
  
    tokens.forEach(function (token, i) {
      if (token.type === 'heading') {
        key = token.children[0].value
        res[key] = []
        return
      }
  
      if (!key) return
  
      res[key].push(token)
    })
  
    Object.keys(res).forEach(function (key) {
      const tree = {
        type: 'root',
        children: res[key]
      }
  
      res[key] = {
        raw: trimRight(lexer.stringify(tree)),
        html: trimRight(toHtml.stringify(tree))
      }
    })
  
    return res
  }
  
  // trim whitespace at the
  // end of a string
  // str -> str
  function trimRight (value) {
    return value.replace(/\n+$/, '')
  }
  
  
  /***/ }),
  
  /***/ 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;
  
  
  /***/ }),
  
  /***/ 695:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module Stringify
   * @fileoverview Compile a an abstract syntax tree into
   *   a markdown document.
   */
  
  
  
  /*
   * Dependencies.
   */
  
  var he = __webpack_require__(903);
  var table = __webpack_require__(366);
  var repeat = __webpack_require__(8);
  var utilities = __webpack_require__(65);
  var defaultOptions = __webpack_require__(575).stringify;
  
  /*
   * Methods.
   */
  
  var clone = utilities.clone;
  var raise = utilities.raise;
  var validate = utilities.validate;
  var count = utilities.countCharacter;
  var objectCreate = utilities.create;
  
  /*
   * Constants.
   */
  
  var INDENT = 4;
  var MINIMUM_CODE_FENCE_LENGTH = 3;
  var YAML_FENCE_LENGTH = 3;
  var MINIMUM_RULE_LENGTH = 3;
  var MAILTO = 'mailto:';
  
  /*
   * Expressions.
   */
  
  var EXPRESSIONS_WHITE_SPACE = /\s/;
  
  /*
   * Expression for a protocol.
   *
   * @see http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax
   */
  
  var PROTOCOL = /^[a-z][a-z+.-]+:\/?/i;
  
  /*
   * Characters.
   */
  
  var ANGLE_BRACKET_CLOSE = '>';
  var ANGLE_BRACKET_OPEN = '<';
  var ASTERISK = '*';
  var CARET = '^';
  var COLON = ':';
  var DASH = '-';
  var DOT = '.';
  var EMPTY = '';
  var EQUALS = '=';
  var EXCLAMATION_MARK = '!';
  var HASH = '#';
  var LINE = '\n';
  var PARENTHESIS_OPEN = '(';
  var PARENTHESIS_CLOSE = ')';
  var PIPE = '|';
  var PLUS = '+';
  var QUOTE_DOUBLE = '"';
  var QUOTE_SINGLE = '\'';
  var SPACE = ' ';
  var SQUARE_BRACKET_OPEN = '[';
  var SQUARE_BRACKET_CLOSE = ']';
  var TICK = '`';
  var TILDE = '~';
  var UNDERSCORE = '_';
  
  /*
   * Character combinations.
   */
  
  var BREAK = LINE + LINE;
  var GAP = BREAK + LINE;
  var DOUBLE_TILDE = TILDE + TILDE;
  
  /*
   * Allowed entity options.
   */
  
  var ENTITY_OPTIONS = objectCreate();
  
  ENTITY_OPTIONS.true = true;
  ENTITY_OPTIONS.false = true;
  ENTITY_OPTIONS.numbers = true;
  ENTITY_OPTIONS.escape = true;
  
  /*
   * Allowed list-bullet characters.
   */
  
  var LIST_BULLETS = objectCreate();
  
  LIST_BULLETS[ASTERISK] = true;
  LIST_BULLETS[DASH] = true;
  LIST_BULLETS[PLUS] = true;
  
  /*
   * Allowed horizontal-rule bullet characters.
   */
  
  var HORIZONTAL_RULE_BULLETS = objectCreate();
  
  HORIZONTAL_RULE_BULLETS[ASTERISK] = true;
  HORIZONTAL_RULE_BULLETS[DASH] = true;
  HORIZONTAL_RULE_BULLETS[UNDERSCORE] = true;
  
  /*
   * Allowed emphasis characters.
   */
  
  var EMPHASIS_MARKERS = objectCreate();
  
  EMPHASIS_MARKERS[UNDERSCORE] = true;
  EMPHASIS_MARKERS[ASTERISK] = true;
  
  /*
   * Allowed fence markers.
   */
  
  var FENCE_MARKERS = objectCreate();
  
  FENCE_MARKERS[TICK] = true;
  FENCE_MARKERS[TILDE] = true;
  
  /*
   * Which method to use based on `list.ordered`.
   */
  
  var ORDERED_MAP = objectCreate();
  
  ORDERED_MAP.true = 'visitOrderedItems';
  ORDERED_MAP.false = 'visitUnorderedItems';
  
  /*
   * Allowed list-item-indent's.
   */
  
  var LIST_ITEM_INDENTS = objectCreate();
  
  var LIST_ITEM_TAB = 'tab';
  var LIST_ITEM_ONE = '1';
  var LIST_ITEM_MIXED = 'mixed';
  
  LIST_ITEM_INDENTS[LIST_ITEM_ONE] = true;
  LIST_ITEM_INDENTS[LIST_ITEM_TAB] = true;
  LIST_ITEM_INDENTS[LIST_ITEM_MIXED] = true;
  
  /*
   * Which checkbox to use.
   */
  
  var CHECKBOX_MAP = objectCreate();
  
  CHECKBOX_MAP.null = EMPTY;
  CHECKBOX_MAP.undefined = EMPTY;
  CHECKBOX_MAP.true = SQUARE_BRACKET_OPEN + 'x' + SQUARE_BRACKET_CLOSE + SPACE;
  CHECKBOX_MAP.false = SQUARE_BRACKET_OPEN + SPACE + SQUARE_BRACKET_CLOSE +
      SPACE;
  
  /**
   * Encode noop.
   * Simply returns the given value.
   *
   * @example
   *   var encode = encodeNoop();
   *   encode('AT&T') // 'AT&T'
   *
   * @param {string} value - Content.
   * @return {string} - Content, without any modifications.
   */
  function encodeNoop(value) {
      return value;
  }
  
  /**
   * Factory to encode HTML entities.
   * Creates a no-operation function when `type` is
   * `'false'`, a function which encodes using named
   * references when `type` is `'true'`, and a function
   * which encodes using numbered references when `type` is
   * `'numbers'`.
   *
   * By default this should not throw errors, but he does
   * throw an error when in `strict` mode:
   *
   *     he.encode.options.strict = true;
   *     encodeFactory('true')('\x01') // throws
   *
   * These are thrown on the currently compiled `File`.
   *
   * @example
   *   var file = new File();
   *
   *   var encode = encodeFactory('false', file);
   *   encode('AT&T') // 'AT&T'
   *
   *   encode = encodeFactory('true', file);
   *   encode('AT&T') // 'AT&amp;T'
   *
   *   encode = encodeFactory('numbers', file);
   *   encode('AT&T') // 'ATT&#x26;T'
   *
   * @param {string} type - Either `'true'`, `'false'`, or
   *   `numbers`.
   * @param {File} file - Currently compiled virtual file.
   * @return {function(string): string} - Function which
   *   takes a value and returns its encoded version.
   */
  function encodeFactory(type, file) {
      var options = {};
      var fn;
  
      if (type === 'false') {
          return encodeNoop;
      }
  
      if (type === 'true') {
          options.useNamedReferences = true;
      }
  
      fn = type === 'escape' ? 'escape' : 'encode';
  
      /**
       * Encode HTML entities using `he` using bound options.
       *
       * @see https://github.com/mathiasbynens/he#strict
       *
       * @example
       *   // When `type` is `'true'`.
       *   encode('AT&T'); // 'AT&amp;T'
       *
       *   // When `type` is `'numbers'`.
       *   encode('AT&T'); // 'ATT&#x26;T'
       *
       * @param {string} value - Content.
       * @param {Object} node - Node which is compiled.
       * @return {string} - Encoded content.
       * @throws {Error} - When `file.quiet` is not `true`.
       *   However, by default `he` does not throw on
       *   parse errors, but when
       *   `he.encode.options.strict: true`, they occur on
       *   invalid HTML.
       */
      function encode(value, node) {
          try {
              return he[fn](value, options);
          } catch (exception) {
              file.fail(exception, node.position);
          }
      }
  
      return encode;
  }
  
  /**
   * Checks if `url` needs to be enclosed by angle brackets.
   *
   * @example
   *   encloseURI('foo bar') // '<foo bar>'
   *   encloseURI('foo(bar(baz)') // '<foo(bar(baz)>'
   *   encloseURI('') // '<>'
   *   encloseURI('example.com') // 'example.com'
   *   encloseURI('example.com', true) // '<example.com>'
   *
   * @param {string} uri
   * @param {boolean?} [always] - Force enclosing.
   * @return {boolean} - Properly enclosed `uri`.
   */
  function encloseURI(uri, always) {
      if (
          always ||
          !uri.length ||
          EXPRESSIONS_WHITE_SPACE.test(uri) ||
          count(uri, PARENTHESIS_OPEN) !== count(uri, PARENTHESIS_CLOSE)
      ) {
          return ANGLE_BRACKET_OPEN + uri + ANGLE_BRACKET_CLOSE;
      }
  
      return uri;
  }
  
  /**
   * There is currently no way to support nested delimiters
   * across Markdown.pl, CommonMark, and GitHub (RedCarpet).
   * The following supports Markdown.pl, and GitHub.
   * CommonMark is not supported when mixing double- and
   * single quotes inside a title.
   *
   * @see https://github.com/vmg/redcarpet/issues/473
   * @see https://github.com/jgm/CommonMark/issues/308
   *
   * @example
   *   encloseTitle('foo') // '"foo"'
   *   encloseTitle('foo \'bar\' baz') // '"foo \'bar\' baz"'
   *   encloseTitle('foo "bar" baz') // '\'foo "bar" baz\''
   *   encloseTitle('foo "bar" \'baz\'') // '"foo "bar" \'baz\'"'
   *
   * @param {string} title - Content.
   * @return {string} - Properly enclosed title.
   */
  function encloseTitle(title) {
      var delimiter = QUOTE_DOUBLE;
  
      if (title.indexOf(delimiter) !== -1) {
          delimiter = QUOTE_SINGLE;
      }
  
      return delimiter + title + delimiter;
  }
  
  /**
   * Get the count of the longest repeating streak
   * of `character` in `value`.
   *
   * @example
   *   getLongestRepetition('` foo `` bar `', '`') // 2
   *
   * @param {string} value - Content.
   * @param {string} character - Single character to look
   *   for.
   * @return {number} - Number of characters at the place
   *   where `character` occurs in its longest streak in
   *   `value`.
   */
  function getLongestRepetition(value, character) {
      var highestCount = 0;
      var index = -1;
      var length = value.length;
      var currentCount = 0;
      var currentCharacter;
  
      while (++index < length) {
          currentCharacter = value.charAt(index);
  
          if (currentCharacter === character) {
              currentCount++;
  
              if (currentCount > highestCount) {
                  highestCount = currentCount;
              }
          } else {
              currentCount = 0;
          }
      }
  
      return highestCount;
  }
  
  /**
   * Pad `value` with `level * INDENT` spaces.  Respects
   * lines.
   *
   * @example
   *   pad('foo', 1) // '    foo'
   *
   * @param {string} value - Content.
   * @param {number} level - Indentation level.
   * @return {string} - Padded `value`.
   */
  function pad(value, level) {
      var index;
      var padding;
  
      value = value.split(LINE);
  
      index = value.length;
      padding = repeat(SPACE, level * INDENT);
  
      while (index--) {
          if (value[index].length !== 0) {
              value[index] = padding + value[index];
          }
      }
  
      return value.join(LINE);
  }
  
  /**
   * Construct a new compiler.
   *
   * @example
   *   var compiler = new Compiler(new File('> foo.'));
   *
   * @constructor
   * @class {Compiler}
   * @param {File} file - Virtual file.
   * @param {Object?} [options] - Passed to
   *   `Compiler#setOptions()`.
   */
  function Compiler(file, options) {
      var self = this;
  
      self.file = file;
  
      self.options = clone(self.options);
  
      self.setOptions(options);
  }
  
  /*
   * Cache prototype.
   */
  
  var compilerPrototype = Compiler.prototype;
  
  /*
   * Expose defaults.
   */
  
  compilerPrototype.options = defaultOptions;
  
  /*
   * Map of applicable enum's.
   */
  
  var maps = {
      'entities': ENTITY_OPTIONS,
      'bullet': LIST_BULLETS,
      'rule': HORIZONTAL_RULE_BULLETS,
      'listItemIndent': LIST_ITEM_INDENTS,
      'emphasis': EMPHASIS_MARKERS,
      'strong': EMPHASIS_MARKERS,
      'fence': FENCE_MARKERS
  };
  
  /**
   * Set options.  Does not overwrite previously set
   * options.
   *
   * @example
   *   var compiler = new Compiler();
   *   compiler.setOptions({bullet: '*'});
   *
   * @this {Compiler}
   * @throws {Error} - When an option is invalid.
   * @param {Object?} [options] - Stringify settings.
   * @return {Compiler} - `self`.
   */
  compilerPrototype.setOptions = function (options) {
      var self = this;
      var current = self.options;
      var ruleRepetition;
      var key;
  
      if (options === null || options === undefined) {
          options = {};
      } else if (typeof options === 'object') {
          options = clone(options);
      } else {
          raise(options, 'options');
      }
  
      for (key in defaultOptions) {
          validate[typeof current[key]](
              options, key, current[key], maps[key]
          );
      }
  
      ruleRepetition = options.ruleRepetition;
  
      if (ruleRepetition && ruleRepetition < MINIMUM_RULE_LENGTH) {
          raise(ruleRepetition, 'options.ruleRepetition');
      }
  
      self.encode = encodeFactory(String(options.entities), self.file);
  
      self.options = options;
  
      return self;
  };
  
  /**
   * Visit a token.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.visit({
   *     type: 'strong',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '**Foo**'
   *
   * @param {Object} token - Node.
   * @param {Object?} [parent] - `token`s parent node.
   * @return {string} - Compiled `token`.
   */
  compilerPrototype.visit = function (token, parent) {
      var self = this;
  
      if (typeof self[token.type] !== 'function') {
          self.file.fail(
              'Missing compiler for node of type `' +
              token.type + '`: ' + token,
              token
          );
      }
  
      return self[token.type](token, parent);
  };
  
  /**
   * Visit all tokens.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.all({
   *     type: 'strong',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     },
   *     {
   *       type: 'text',
   *       value: 'Bar'
   *     }]
   *   });
   *   // ['Foo', 'Bar']
   *
   * @param {Object} parent - Parent node of children.
   * @return {Array.<string>} - List of compiled children.
   */
  compilerPrototype.all = function (parent) {
      var self = this;
      var tokens = parent.children;
      var values = [];
      var index = -1;
      var length = tokens.length;
  
      while (++index < length) {
          values[index] = self.visit(tokens[index], parent);
      }
  
      return values;
  };
  
  /**
   * Visit ordered list items.
   *
   * Starts the list with
   * `token.start` and increments each following list item
   * bullet by one:
   *
   *     2. foo
   *     3. bar
   *
   * In `incrementListMarker: false` mode, does not increment
   * each marker ans stays on `token.start`:
   *
   *     1. foo
   *     1. bar
   *
   * Adds an extra line after an item if it has
   * `loose: true`.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.visitOrderedItems({
   *     type: 'list',
   *     ordered: true,
   *     children: [{
   *       type: 'listItem',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '1.  bar'
   *
   * @param {Object} token - `list` node with
   *   `ordered: true`.
   * @return {string} - Markdown list.
   */
  compilerPrototype.visitOrderedItems = function (token) {
      var self = this;
      var increment = self.options.incrementListMarker;
      var values = [];
      var tokens = token.children;
      var index = -1;
      var length = tokens.length;
      var start = token.start;
      var bullet;
  
      while (++index < length) {
          bullet = (increment ? start + index : start) + DOT;
          values[index] = self.listItem(tokens[index], token, index, bullet);
      }
  
      return values.join(LINE);
  };
  
  /**
   * Visit unordered list items.
   *
   * Uses `options.bullet` as each item's bullet.
   *
   * Adds an extra line after an item if it has
   * `loose: true`.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.visitUnorderedItems({
   *     type: 'list',
   *     ordered: false,
   *     children: [{
   *       type: 'listItem',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '-   bar'
   *
   * @param {Object} token - `list` node with
   *   `ordered: false`.
   * @return {string} - Markdown list.
   */
  compilerPrototype.visitUnorderedItems = function (token) {
      var self = this;
      var values = [];
      var tokens = token.children;
      var length = tokens.length;
      var index = -1;
      var bullet = self.options.bullet;
  
      while (++index < length) {
          values[index] = self.listItem(tokens[index], token, index, bullet);
      }
  
      return values.join(LINE);
  };
  
  /**
   * Stringify a block node with block children (e.g., `root`
   * or `blockquote`).
   *
   * Knows about code following a list, or adjacent lists
   * with similar bullets, and places an extra newline
   * between them.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.block({
   *     type: 'root',
   *     children: [{
   *       type: 'paragraph',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // 'bar'
   *
   * @param {Object} token - `root` node.
   * @return {string} - Markdown block content.
   */
  compilerPrototype.block = function (token) {
      var self = this;
      var values = [];
      var tokens = token.children;
      var index = -1;
      var length = tokens.length;
      var child;
      var prev;
  
      while (++index < length) {
          child = tokens[index];
  
          if (prev) {
              /*
               * Duplicate tokens, such as a list
               * directly following another list,
               * often need multiple new lines.
               *
               * Additionally, code blocks following a list
               * might easily be mistaken for a paragraph
               * in the list itself.
               */
  
              if (child.type === prev.type && prev.type === 'list') {
                  values.push(prev.ordered === child.ordered ? GAP : BREAK);
              } else if (
                  prev.type === 'list' &&
                  child.type === 'code' &&
                  !child.lang
              ) {
                  values.push(GAP);
              } else {
                  values.push(BREAK);
              }
          }
  
          values.push(self.visit(child, token));
  
          prev = child;
      }
  
      return values.join(EMPTY);
  };
  
  /**
   * Stringify a root.
   *
   * Adds a final newline to ensure valid POSIX files.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.root({
   *     type: 'root',
   *     children: [{
   *       type: 'paragraph',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // 'bar'
   *
   * @param {Object} token - `root` node.
   * @return {string} - Markdown document.
   */
  compilerPrototype.root = function (token) {
      return this.block(token) + LINE;
  };
  
  /**
   * Stringify a heading.
   *
   * In `setext: true` mode and when `depth` is smaller than
   * three, creates a setext header:
   *
   *     Foo
   *     ===
   *
   * Otherwise, an ATX header is generated:
   *
   *     ### Foo
   *
   * In `closeAtx: true` mode, the header is closed with
   * hashes:
   *
   *     ### Foo ###
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.heading({
   *     type: 'heading',
   *     depth: 2,
   *     children: [{
   *       type: 'strong',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '## **bar**'
   *
   * @param {Object} token - `heading` node.
   * @return {string} - Markdown heading.
   */
  compilerPrototype.heading = function (token) {
      var self = this;
      var setext = self.options.setext;
      var closeAtx = self.options.closeAtx;
      var depth = token.depth;
      var content = self.all(token).join(EMPTY);
      var prefix;
  
      if (setext && depth < 3) {
          return content + LINE +
              repeat(depth === 1 ? EQUALS : DASH, content.length);
      }
  
      prefix = repeat(HASH, token.depth);
      content = prefix + SPACE + content;
  
      if (closeAtx) {
          content += SPACE + prefix;
      }
  
      return content;
  };
  
  /**
   * Stringify text.
   *
   * Supports named entities in `settings.encode: true` mode:
   *
   *     AT&amp;T
   *
   * Supports numbered entities in `settings.encode: numbers`
   * mode:
   *
   *     AT&#x26;T
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.text({
   *     type: 'text',
   *     value: 'foo'
   *   });
   *   // 'foo'
   *
   * @param {Object} token - `text` node.
   * @return {string} - Raw markdown text.
   */
  compilerPrototype.text = function (token) {
      return this.encode(token.value, token);
  };
  
  /**
   * Stringify escaped text.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.escape({
   *     type: 'escape',
   *     value: '\n'
   *   });
   *   // '\\\n'
   *
   * @param {Object} token - `escape` node.
   * @return {string} - Markdown escape.
   */
  compilerPrototype.escape = function (token) {
      return '\\' + token.value;
  };
  
  /**
   * Stringify a paragraph.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.paragraph({
   *     type: 'paragraph',
   *     children: [{
   *       type: 'strong',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '**bar**'
   *
   * @param {Object} token - `paragraph` node.
   * @return {string} - Markdown paragraph.
   */
  compilerPrototype.paragraph = function (token) {
      return this.all(token).join(EMPTY);
  };
  
  /**
   * Stringify a block quote.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.paragraph({
   *     type: 'blockquote',
   *     children: [{
   *       type: 'paragraph',
   *       children: [{
   *         type: 'strong',
   *         children: [{
   *           type: 'text',
   *           value: 'bar'
   *         }]
   *       }]
   *     }]
   *   });
   *   // '> **bar**'
   *
   * @param {Object} token - `blockquote` node.
   * @return {string} - Markdown block quote.
   */
  compilerPrototype.blockquote = function (token) {
      var indent = ANGLE_BRACKET_CLOSE + SPACE;
  
      return indent + this.block(token).split(LINE).join(LINE + indent);
  };
  
  /**
   * Stringify a list. See `Compiler#visitOrderedList()` and
   * `Compiler#visitUnorderedList()` for internal working.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.visitUnorderedItems({
   *     type: 'list',
   *     ordered: false,
   *     children: [{
   *       type: 'listItem',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '-   bar'
   *
   * @param {Object} token - `list` node.
   * @return {string} - Markdown list.
   */
  compilerPrototype.list = function (token) {
      return this[ORDERED_MAP[token.ordered]](token);
  };
  
  /**
   * Stringify a list item.
   *
   * Prefixes the content with a checked checkbox when
   * `checked: true`:
   *
   *     [x] foo
   *
   * Prefixes the content with an unchecked checkbox when
   * `checked: false`:
   *
   *     [ ] foo
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.listItem({
   *     type: 'listItem',
   *     checked: true,
   *     children: [{
   *       type: 'text',
   *       value: 'bar'
   *     }]
   *   }, {
   *     type: 'list',
   *     ordered: false,
   *     children: [{
   *       type: 'listItem',
   *       checked: true,
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   }, 0, '*');
   *   '-   [x] bar'
   *
   * @param {Object} token - `listItem` node.
   * @param {Object} parent - `list` node.
   * @param {number} position - Index of `token` in `parent`.
   * @param {string} bullet - Bullet to use.  This, and the
   *   `listItemIndent` setting define the used indent.
   * @return {string} - Markdown list item.
   */
  compilerPrototype.listItem = function (token, parent, position, bullet) {
      var self = this;
      var style = self.options.listItemIndent;
      var tokens = token.children;
      var values = [];
      var index = -1;
      var length = tokens.length;
      var loose = token.loose;
      var value;
      var indent;
      var spacing;
  
      while (++index < length) {
          values[index] = self.visit(tokens[index], token);
      }
  
      value = CHECKBOX_MAP[token.checked] + values.join(loose ? BREAK : LINE);
  
      if (
          style === LIST_ITEM_ONE ||
          (style === LIST_ITEM_MIXED && value.indexOf(LINE) === -1)
      ) {
          indent = bullet.length + 1;
          spacing = SPACE;
      } else {
          indent = Math.ceil((bullet.length + 1) / INDENT) * INDENT;
          spacing = repeat(SPACE, indent - bullet.length);
      }
  
      value = bullet + spacing + pad(value, indent / INDENT).slice(indent);
  
      if (loose && parent.children.length - 1 !== position) {
          value += LINE;
      }
  
      return value;
  };
  
  /**
   * Stringify inline code.
   *
   * Knows about internal ticks (`\``), and ensures one more
   * tick is used to enclose the inline code:
   *
   *     ```foo ``bar`` baz```
   *
   * Even knows about inital and final ticks:
   *
   *     `` `foo ``
   *     `` foo` ``
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.inlineCode({
   *     type: 'inlineCode',
   *     value: 'foo(); `bar`; baz()'
   *   });
   *   // '``foo(); `bar`; baz()``'
   *
   * @param {Object} token - `inlineCode` node.
   * @return {string} - Markdown inline code.
   */
  compilerPrototype.inlineCode = function (token) {
      var value = token.value;
      var ticks = repeat(TICK, getLongestRepetition(value, TICK) + 1);
      var start = ticks;
      var end = ticks;
  
      if (value.charAt(0) === TICK) {
          start += SPACE;
      }
  
      if (value.charAt(value.length - 1) === TICK) {
          end = SPACE + end;
      }
  
      return start + token.value + end;
  };
  
  /**
   * Stringify YAML front matter.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.yaml({
   *     type: 'yaml',
   *     value: 'foo: bar'
   *   });
   *   // '---\nfoo: bar\n---'
   *
   * @param {Object} token - `yaml` node.
   * @return {string} - Markdown YAML document.
   */
  compilerPrototype.yaml = function (token) {
      var delimiter = repeat(DASH, YAML_FENCE_LENGTH);
      var value = token.value ? LINE + token.value : EMPTY;
  
      return delimiter + value + LINE + delimiter;
  };
  
  /**
   * Stringify a code block.
   *
   * Creates indented code when:
   *
   * - No language tag exists;
   * - Not in `fences: true` mode;
   * - A non-empty value exists.
   *
   * Otherwise, GFM fenced code is created:
   *
   *     ```js
   *     foo();
   *     ```
   *
   * When in ``fence: `~` `` mode, uses tildes as fences:
   *
   *     ~~~js
   *     foo();
   *     ~~~
   *
   * Knows about internal fences (Note: GitHub/Kramdown does
   * not support this):
   *
   *     ````javascript
   *     ```markdown
   *     foo
   *     ```
   *     ````
   *
   * Supports named entities in the language flag with
   * `settings.encode` mode.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.code({
   *     type: 'code',
   *     lang: 'js',
   *     value: 'fooo();'
   *   });
   *   // '```js\nfooo();\n```'
   *
   * @param {Object} token - `code` node.
   * @return {string} - Markdown code block.
   */
  compilerPrototype.code = function (token) {
      var value = token.value;
      var marker = this.options.fence;
      var language = this.encode(token.lang || EMPTY, token);
      var fence;
  
      /*
       * Probably pedantic.
       */
  
      if (!language && !this.options.fences && value) {
          return pad(value, 1);
      }
  
      fence = getLongestRepetition(value, marker) + 1;
  
      fence = repeat(marker, Math.max(fence, MINIMUM_CODE_FENCE_LENGTH));
  
      return fence + language + LINE + value + LINE + fence;
  };
  
  /**
   * Stringify HTML.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.html({
   *     type: 'html',
   *     value: '<div>bar</div>'
   *   });
   *   // '<div>bar</div>'
   *
   * @param {Object} token - `html` node.
   * @return {string} - Markdown HTML.
   */
  compilerPrototype.html = function (token) {
      return token.value;
  };
  
  /**
   * Stringify a horizontal rule.
   *
   * The character used is configurable by `rule`: (`'_'`)
   *
   *     ___
   *
   * The number of repititions is defined through
   * `ruleRepetition`: (`6`)
   *
   *     ******
   *
   * Whether spaces delimit each character, is configured
   * through `ruleSpaces`: (`true`)
   *
   *     * * *
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.horizontalRule({
   *     type: 'horizontalRule'
   *   });
   *   // '***'
   *
   * @return {string} - Markdown rule.
   */
  compilerPrototype.horizontalRule = function () {
      var options = this.options;
      var rule = repeat(options.rule, options.ruleRepetition);
  
      if (options.ruleSpaces) {
          rule = rule.split(EMPTY).join(SPACE);
      }
  
      return rule;
  };
  
  /**
   * Stringify a strong.
   *
   * The marker used is configurable by `strong`, which
   * defaults to an asterisk (`'*'`) but also accepts an
   * underscore (`'_'`):
   *
   *     _foo_
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.strong({
   *     type: 'strong',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '**Foo**'
   *
   * @param {Object} token - `strong` node.
   * @return {string} - Markdown strong-emphasised text.
   */
  compilerPrototype.strong = function (token) {
      var marker = this.options.strong;
  
      marker = marker + marker;
  
      return marker + this.all(token).join(EMPTY) + marker;
  };
  
  /**
   * Stringify an emphasis.
   *
   * The marker used is configurable by `emphasis`, which
   * defaults to an underscore (`'_'`) but also accepts an
   * asterisk (`'*'`):
   *
   *     *foo*
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.emphasis({
   *     type: 'emphasis',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '_Foo_'
   *
   * @param {Object} token - `emphasis` node.
   * @return {string} - Markdown emphasised text.
   */
  compilerPrototype.emphasis = function (token) {
      var marker = this.options.emphasis;
  
      return marker + this.all(token).join(EMPTY) + marker;
  };
  
  /**
   * Stringify a hard break.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.break({
   *     type: 'break'
   *   });
   *   // '  \n'
   *
   * @return {string} - Hard markdown break.
   */
  compilerPrototype.break = function () {
      return SPACE + SPACE + LINE;
  };
  
  /**
   * Stringify a delete.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.delete({
   *     type: 'delete',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '~~Foo~~'
   *
   * @param {Object} token - `delete` node.
   * @return {string} - Markdown strike-through.
   */
  compilerPrototype.delete = function (token) {
      return DOUBLE_TILDE + this.all(token).join(EMPTY) + DOUBLE_TILDE;
  };
  
  /**
   * Stringify a link.
   *
   * When no title exists, the compiled `children` equal
   * `href`, and `href` starts with a protocol, an auto
   * link is created:
   *
   *     <http://example.com>
   *
   * Otherwise, is smart about enclosing `href` (see
   * `encloseURI()`) and `title` (see `encloseTitle()`).
   *
   *    [foo](<foo at bar dot com> 'An "example" e-mail')
   *
   * Supports named entities in the `href` and `title` when
   * in `settings.encode` mode.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.link({
   *     type: 'link',
   *     href: 'http://example.com',
   *     title: 'Example Domain',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '[Foo](http://example.com "Example Domain")'
   *
   * @param {Object} token - `link` node.
   * @return {string} - Markdown link.
   */
  compilerPrototype.link = function (token) {
      var self = this;
      var url = self.encode(token.href, token);
      var value = self.all(token).join(EMPTY);
  
      if (
          token.title === null &&
          PROTOCOL.test(url) &&
          (url === value || url === MAILTO + value)
      ) {
          return encloseURI(url, true);
      }
  
      url = encloseURI(url);
  
      if (token.title) {
          url += SPACE + encloseTitle(self.encode(token.title, token));
      }
  
      value = SQUARE_BRACKET_OPEN + value + SQUARE_BRACKET_CLOSE;
  
      value += PARENTHESIS_OPEN + url + PARENTHESIS_CLOSE;
  
      return value;
  };
  
  /**
   * Stringify a link label.
   *
   * Because link references are easily, mistakingly,
   * created (for example, `[foo]`), reference nodes have
   * an extra property depicting how it looked in the
   * original document, so stringification can cause minimal
   * changes.
   *
   * @example
   *   label({
   *     type: 'referenceImage',
   *     referenceType: 'full',
   *     identifier: 'foo'
   *   });
   *   // '[foo]'
   *
   *   label({
   *     type: 'referenceImage',
   *     referenceType: 'collapsed',
   *     identifier: 'foo'
   *   });
   *   // '[]'
   *
   *   label({
   *     type: 'referenceImage',
   *     referenceType: 'shortcut',
   *     identifier: 'foo'
   *   });
   *   // ''
   *
   * @param {Object} token - `linkReference` or
   *   `imageReference` node.
   * @return {string} - Markdown label reference.
   */
  function label(token) {
      var value = EMPTY;
      var type = token.referenceType;
  
      if (type === 'full') {
          value = token.identifier;
      }
  
      if (type !== 'shortcut') {
          value = SQUARE_BRACKET_OPEN + value + SQUARE_BRACKET_CLOSE;
      }
  
      return value;
  }
  
  /**
   * Stringify a link reference.
   *
   * See `label()` on how reference labels are created.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.linkReference({
   *     type: 'linkReference',
   *     referenceType: 'collapsed',
   *     identifier: 'foo',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '[Foo][]'
   *
   * @param {Object} token - `linkReference` node.
   * @return {string} - Markdown link reference.
   */
  compilerPrototype.linkReference = function (token) {
      return SQUARE_BRACKET_OPEN +
          this.all(token).join(EMPTY) + SQUARE_BRACKET_CLOSE +
          label(token);
  };
  
  /**
   * Stringify an image reference.
   *
   * See `label()` on how reference labels are created.
   *
   * Supports named entities in the `alt` when
   * in `settings.encode` mode.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.imageReference({
   *     type: 'imageReference',
   *     referenceType: 'full',
   *     identifier: 'foo',
   *     alt: 'Foo'
   *   });
   *   // '![Foo][foo]'
   *
   * @param {Object} token - `imageReference` node.
   * @return {string} - Markdown image reference.
   */
  compilerPrototype.imageReference = function (token) {
      var alt = this.encode(token.alt, token);
  
      return EXCLAMATION_MARK +
          SQUARE_BRACKET_OPEN + alt + SQUARE_BRACKET_CLOSE +
          label(token);
  };
  
  /**
   * Stringify a footnote reference.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.footnoteReference({
   *     type: 'footnoteReference',
   *     identifier: 'foo'
   *   });
   *   // '[^foo]'
   *
   * @param {Object} token - `footnoteReference` node.
   * @return {string} - Markdown footnote reference.
   */
  compilerPrototype.footnoteReference = function (token) {
      return SQUARE_BRACKET_OPEN + CARET + token.identifier +
          SQUARE_BRACKET_CLOSE;
  };
  
  /**
   * Stringify an link- or image definition.
   *
   * Is smart about enclosing `href` (see `encloseURI()`) and
   * `title` (see `encloseTitle()`).
   *
   *    [foo]: <foo at bar dot com> 'An "example" e-mail'
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.definition({
   *     type: 'definition',
   *     link: 'http://example.com',
   *     title: 'Example Domain',
   *     identifier: 'foo'
   *   });
   *   // '[foo]: http://example.com "Example Domain"'
   *
   * @param {Object} token - `definition` node.
   * @return {string} - Markdown link- or image definition.
   */
  compilerPrototype.definition = function (token) {
      var value = SQUARE_BRACKET_OPEN + token.identifier + SQUARE_BRACKET_CLOSE;
      var url = encloseURI(token.link);
  
      if (token.title) {
          url += SPACE + encloseTitle(token.title);
      }
  
      return value + COLON + SPACE + url;
  };
  
  /**
   * Stringify an image.
   *
   * Is smart about enclosing `href` (see `encloseURI()`) and
   * `title` (see `encloseTitle()`).
   *
   *    ![foo](</fav icon.png> 'My "favourite" icon')
   *
   * Supports named entities in `src`, `alt`, and `title`
   * when in `settings.encode` mode.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.image({
   *     type: 'image',
   *     href: 'http://example.png/favicon.png',
   *     title: 'Example Icon',
   *     alt: 'Foo'
   *   });
   *   // '![Foo](http://example.png/favicon.png "Example Icon")'
   *
   * @param {Object} token - `image` node.
   * @return {string} - Markdown image.
   */
  compilerPrototype.image = function (token) {
      var encode = this.encode;
      var url = encloseURI(encode(token.src, token));
      var value;
  
      if (token.title) {
          url += SPACE + encloseTitle(encode(token.title, token));
      }
  
      value = EXCLAMATION_MARK +
          SQUARE_BRACKET_OPEN + encode(token.alt || EMPTY, token) +
          SQUARE_BRACKET_CLOSE;
  
      value += PARENTHESIS_OPEN + url + PARENTHESIS_CLOSE;
  
      return value;
  };
  
  /**
   * Stringify a footnote.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.footnote({
   *     type: 'footnote',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   });
   *   // '[^Foo]'
   *
   * @param {Object} token - `footnote` node.
   * @return {string} - Markdown footnote.
   */
  compilerPrototype.footnote = function (token) {
      return SQUARE_BRACKET_OPEN + CARET + this.all(token).join(EMPTY) +
          SQUARE_BRACKET_CLOSE;
  };
  
  /**
   * Stringify a footnote definition.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.footnoteDefinition({
   *     type: 'footnoteDefinition',
   *     identifier: 'foo',
   *     children: [{
   *       type: 'paragraph',
   *       children: [{
   *         type: 'text',
   *         value: 'bar'
   *       }]
   *     }]
   *   });
   *   // '[^foo]: bar'
   *
   * @param {Object} token - `footnoteDefinition` node.
   * @return {string} - Markdown footnote definition.
   */
  compilerPrototype.footnoteDefinition = function (token) {
      var id = token.identifier.toLowerCase();
  
      return SQUARE_BRACKET_OPEN + CARET + id +
          SQUARE_BRACKET_CLOSE + COLON + SPACE +
          this.all(token).join(BREAK + repeat(SPACE, INDENT));
  };
  
  /**
   * Stringify table.
   *
   * Creates a fenced table by default, but not in
   * `looseTable: true` mode:
   *
   *     Foo | Bar
   *     :-: | ---
   *     Baz | Qux
   *
   * NOTE: Be careful with `looseTable: true` mode, as a
   * loose table inside an indented code block on GitHub
   * renders as an actual table!
   *
   * Creates a spaces table by default, but not in
   * `spacedTable: false`:
   *
   *     |Foo|Bar|
   *     |:-:|---|
   *     |Baz|Qux|
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.table({
   *     type: 'table',
   *     align: ['center', null],
   *     children: [
   *       {
   *         type: 'tableHeader',
   *         children: [
   *           {
   *             type: 'tableCell'
   *             children: [{
   *               type: 'text'
   *               value: 'Foo'
   *             }]
   *           },
   *           {
   *             type: 'tableCell'
   *             children: [{
   *               type: 'text'
   *               value: 'Bar'
   *             }]
   *           }
   *         ]
   *       },
   *       {
   *         type: 'tableRow',
   *         children: [
   *           {
   *             type: 'tableCell'
   *             children: [{
   *               type: 'text'
   *               value: 'Baz'
   *             }]
   *           },
   *           {
   *             type: 'tableCell'
   *             children: [{
   *               type: 'text'
   *               value: 'Qux'
   *             }]
   *           }
   *         ]
   *       }
   *     ]
   *   });
   *   // '| Foo | Bar |\n| :-: | --- |\n| Baz | Qux |'
   *
   * @param {Object} token - `table` node.
   * @return {string} - Markdown table.
   */
  compilerPrototype.table = function (token) {
      var self = this;
      var loose = self.options.looseTable;
      var spaced = self.options.spacedTable;
      var rows = token.children;
      var index = rows.length;
      var result = [];
      var start;
  
      while (index--) {
          result[index] = self.all(rows[index]);
      }
  
      start = loose ? EMPTY : spaced ? PIPE + SPACE : PIPE;
  
      return table(result, {
          'align': token.align,
          'start': start,
          'end': start.split(EMPTY).reverse().join(EMPTY),
          'delimiter': spaced ? SPACE + PIPE + SPACE : PIPE
      });
  };
  
  /**
   * Stringify a table cell.
   *
   * @example
   *   var compiler = new Compiler();
   *
   *   compiler.tableCell({
   *     type: 'tableCell',
   *     children: [{
   *       type: 'text'
   *       value: 'Qux'
   *     }]
   *   });
   *   // 'Qux'
   *
   * @param {Object} token - `tableCell` node.
   * @return {string} - Markdown table cell.
   */
  compilerPrototype.tableCell = function (token) {
      return this.all(token).join(EMPTY);
  };
  
  /**
   * Stringify an abstract syntax tree.
   *
   * @example
   *   stringify({
   *     type: 'strong',
   *     children: [{
   *       type: 'text',
   *       value: 'Foo'
   *     }]
   *   }, new File());
   *   // '**Foo**'
   *
   * @param {Object} ast - A node, most commonly, `root`.
   * @param {File} file - Virtual file.
   * @param {Object?} [options] - Passed to
   *   `Compiler#setOptions()`.
   * @return {string} - Markdown document.
   */
  function stringify(ast, file, options) {
      var CustomCompiler = this.Compiler || Compiler;
  
      return new CustomCompiler(file, options).visit(ast);
  }
  
  /*
   * Expose `Compiler` on `stringify`.
   */
  
  stringify.Compiler = Compiler;
  
  /*
   * Expose `stringify` on `module.exports`.
   */
  
  module.exports = stringify;
  
  
  /***/ }),
  
  /***/ 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;
  		})
  	);
  };
  
  
  /***/ }),
  
  /***/ 724:
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = collapse
  
  // `collapse(' \t\nbar \nbaz\t') // ' bar baz '`
  function collapse(value) {
    return String(value).replace(/\s+/g, ' ')
  }
  
  
  /***/ }),
  
  /***/ 742:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  var fs = __webpack_require__(747)
  var core
  if (process.platform === 'win32' || global.TESTING_WINDOWS) {
    core = __webpack_require__(818)
  } 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
      }
    }
  }
  
  
  /***/ }),
  
  /***/ 747:
  /***/ (function(module) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ 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__(385);
  var universalUserAgent = __webpack_require__(796);
  var isPlainObject = _interopDefault(__webpack_require__(548));
  var nodeFetch = _interopDefault(__webpack_require__(454));
  var requestError = __webpack_require__(463);
  
  const VERSION = "5.4.5";
  
  function getBufferResponse(response) {
    return response.arrayBuffer();
  }
  
  function fetchWrapper(requestOptions) {
    if (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)).then(response => {
      url = response.url;
      status = response.status;
  
      for (const keyAndValue of response.headers) {
        headers[keyAndValue[0]] = keyAndValue[1];
      }
  
      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, {
          headers,
          request: requestOptions
        });
      }
  
      if (status === 304) {
        throw new requestError.RequestError("Not modified", status, {
          headers,
          request: requestOptions
        });
      }
  
      if (status >= 400) {
        return response.text().then(message => {
          const error = new requestError.RequestError(message, status, {
            headers,
            request: requestOptions
          });
  
          try {
            let responseBody = JSON.parse(error.message);
            Object.assign(error, responseBody);
            let errors = responseBody.errors; // Assumption `errors` would always be in Array format
  
            error.message = error.message + ": " + errors.map(JSON.stringify).join(", ");
          } catch (e) {// ignore, see octokit/rest.js#684
          }
  
          throw error;
        });
      }
  
      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);
    }).then(data => {
      return {
        status,
        url,
        headers,
        data
      };
    }).catch(error => {
      if (error instanceof requestError.RequestError) {
        throw error;
      }
  
      throw new requestError.RequestError(error.message, 500, {
        headers,
        request: requestOptions
      });
    });
  }
  
  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
  
  
  /***/ }),
  
  /***/ 761:
  /***/ (function(module) {
  
  module.exports = require("zlib");
  
  /***/ }),
  
  /***/ 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)
  }
  
  
  /***/ }),
  
  /***/ 768:
  /***/ (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;
  };
  
  
  /***/ }),
  
  /***/ 777:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = getFirstPage
  
  const getPage = __webpack_require__(265)
  
  function getFirstPage (octokit, link, headers) {
    return getPage(octokit, link, 'first', headers)
  }
  
  
  /***/ }),
  
  /***/ 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__(2));
  
  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
  
  
  /***/ }),
  
  /***/ 813:
  /***/ (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
  
  
  /***/ }),
  
  /***/ 814:
  /***/ (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__(742)
  
  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)
  }
  
  
  /***/ }),
  
  /***/ 816:
  /***/ (function(module) {
  
  "use strict";
  
  module.exports = /^#!.*/;
  
  
  /***/ }),
  
  /***/ 818:
  /***/ (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)
  }
  
  
  /***/ }),
  
  /***/ 829:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  
  /*
   * Dependencies.
   */
  
  var compilers = __webpack_require__(1);
  
  /**
   * Attach an HTML compiler.
   *
   * @param {MDAST} mdast
   * @param {Object?} [options]
   */
  function plugin(mdast, options) {
      var MarkdownCompiler = mdast.Compiler;
      var ancestor = MarkdownCompiler.prototype;
      var proto;
      var key;
  
      /**
       * Extensible prototype.
       */
      function HTMLCompilerPrototype() {}
  
      HTMLCompilerPrototype.prototype = ancestor;
  
      proto = new HTMLCompilerPrototype();
  
      proto.options.xhtml = false;
      proto.options.sanitize = false;
      proto.options.entities = 'true';
  
      /**
       * Extensible constructor.
       */
      function HTMLCompiler(file) {
          file.extension = 'html';
  
          MarkdownCompiler.apply(this, [file, options]);
      }
  
      HTMLCompiler.prototype = proto;
  
      /*
       * Expose compilers.
       */
  
      for (key in compilers) {
          proto[key] = compilers[key];
      }
  
      mdast.Compiler = HTMLCompiler;
  }
  
  /*
   * Expose `plugin`.
   */
  
  module.exports = plugin;
  
  
  /***/ }),
  
  /***/ 835:
  /***/ (function(module) {
  
  module.exports = require("url");
  
  /***/ }),
  
  /***/ 842:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var deprecation = __webpack_require__(692);
  
  var endpointsByScope = {
    actions: {
      cancelWorkflowRun: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id/cancel"
      },
      createOrUpdateSecretForRepo: {
        method: "PUT",
        params: {
          encrypted_value: {
            type: "string"
          },
          key_id: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/secrets/:name"
      },
      createRegistrationToken: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/runners/registration-token"
      },
      createRemoveToken: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/runners/remove-token"
      },
      deleteArtifact: {
        method: "DELETE",
        params: {
          artifact_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/artifacts/:artifact_id"
      },
      deleteSecretFromRepo: {
        method: "DELETE",
        params: {
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/secrets/:name"
      },
      downloadArtifact: {
        method: "GET",
        params: {
          archive_format: {
            required: true,
            type: "string"
          },
          artifact_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/artifacts/:artifact_id/:archive_format"
      },
      getArtifact: {
        method: "GET",
        params: {
          artifact_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/artifacts/:artifact_id"
      },
      getPublicKey: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/secrets/public-key"
      },
      getSecret: {
        method: "GET",
        params: {
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/secrets/:name"
      },
      getSelfHostedRunner: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          runner_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runners/:runner_id"
      },
      getWorkflow: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          workflow_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/workflows/:workflow_id"
      },
      getWorkflowJob: {
        method: "GET",
        params: {
          job_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/jobs/:job_id"
      },
      getWorkflowRun: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id"
      },
      listDownloadsForSelfHostedRunnerApplication: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/runners/downloads"
      },
      listJobsForWorkflowRun: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id/jobs"
      },
      listRepoWorkflowRuns: {
        method: "GET",
        params: {
          actor: {
            type: "string"
          },
          branch: {
            type: "string"
          },
          event: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          status: {
            enum: ["completed", "status", "conclusion"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/runs"
      },
      listRepoWorkflows: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/workflows"
      },
      listSecretsForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/secrets"
      },
      listSelfHostedRunnersForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/runners"
      },
      listWorkflowJobLogs: {
        method: "GET",
        params: {
          job_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/actions/jobs/:job_id/logs"
      },
      listWorkflowRunArtifacts: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id/artifacts"
      },
      listWorkflowRunLogs: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id/logs"
      },
      listWorkflowRuns: {
        method: "GET",
        params: {
          actor: {
            type: "string"
          },
          branch: {
            type: "string"
          },
          event: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          status: {
            enum: ["completed", "status", "conclusion"],
            type: "string"
          },
          workflow_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/workflows/:workflow_id/runs"
      },
      reRunWorkflow: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          run_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runs/:run_id/rerun"
      },
      removeSelfHostedRunner: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          runner_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/actions/runners/:runner_id"
      }
    },
    activity: {
      checkStarringRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/user/starred/:owner/:repo"
      },
      deleteRepoSubscription: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/subscription"
      },
      deleteThreadSubscription: {
        method: "DELETE",
        params: {
          thread_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/notifications/threads/:thread_id/subscription"
      },
      getRepoSubscription: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/subscription"
      },
      getThread: {
        method: "GET",
        params: {
          thread_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/notifications/threads/:thread_id"
      },
      getThreadSubscription: {
        method: "GET",
        params: {
          thread_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/notifications/threads/:thread_id/subscription"
      },
      listEventsForOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/events/orgs/:org"
      },
      listEventsForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/events"
      },
      listFeeds: {
        method: "GET",
        params: {},
        url: "/feeds"
      },
      listNotifications: {
        method: "GET",
        params: {
          all: {
            type: "boolean"
          },
          before: {
            type: "string"
          },
          page: {
            type: "integer"
          },
          participating: {
            type: "boolean"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          }
        },
        url: "/notifications"
      },
      listNotificationsForRepo: {
        method: "GET",
        params: {
          all: {
            type: "boolean"
          },
          before: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          participating: {
            type: "boolean"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/notifications"
      },
      listPublicEvents: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/events"
      },
      listPublicEventsForOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/events"
      },
      listPublicEventsForRepoNetwork: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/networks/:owner/:repo/events"
      },
      listPublicEventsForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/events/public"
      },
      listReceivedEventsForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/received_events"
      },
      listReceivedPublicEventsForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/received_events/public"
      },
      listRepoEvents: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/events"
      },
      listReposStarredByAuthenticatedUser: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/user/starred"
      },
      listReposStarredByUser: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/starred"
      },
      listReposWatchedByUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/subscriptions"
      },
      listStargazersForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stargazers"
      },
      listWatchedReposForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/subscriptions"
      },
      listWatchersForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/subscribers"
      },
      markAsRead: {
        method: "PUT",
        params: {
          last_read_at: {
            type: "string"
          }
        },
        url: "/notifications"
      },
      markNotificationsAsReadForRepo: {
        method: "PUT",
        params: {
          last_read_at: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/notifications"
      },
      markThreadAsRead: {
        method: "PATCH",
        params: {
          thread_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/notifications/threads/:thread_id"
      },
      setRepoSubscription: {
        method: "PUT",
        params: {
          ignored: {
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          subscribed: {
            type: "boolean"
          }
        },
        url: "/repos/:owner/:repo/subscription"
      },
      setThreadSubscription: {
        method: "PUT",
        params: {
          ignored: {
            type: "boolean"
          },
          thread_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/notifications/threads/:thread_id/subscription"
      },
      starRepo: {
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/user/starred/:owner/:repo"
      },
      unstarRepo: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/user/starred/:owner/:repo"
      }
    },
    apps: {
      addRepoToInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "PUT",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          },
          repository_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/installations/:installation_id/repositories/:repository_id"
      },
      checkAccountIsAssociatedWithAny: {
        method: "GET",
        params: {
          account_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/marketplace_listing/accounts/:account_id"
      },
      checkAccountIsAssociatedWithAnyStubbed: {
        method: "GET",
        params: {
          account_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/marketplace_listing/stubbed/accounts/:account_id"
      },
      checkAuthorization: {
        deprecated: "octokit.apps.checkAuthorization() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#check-an-authorization",
        method: "GET",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      checkToken: {
        headers: {
          accept: "application/vnd.github.doctor-strange-preview+json"
        },
        method: "POST",
        params: {
          access_token: {
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/token"
      },
      createContentAttachment: {
        headers: {
          accept: "application/vnd.github.corsair-preview+json"
        },
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          content_reference_id: {
            required: true,
            type: "integer"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/content_references/:content_reference_id/attachments"
      },
      createFromManifest: {
        headers: {
          accept: "application/vnd.github.fury-preview+json"
        },
        method: "POST",
        params: {
          code: {
            required: true,
            type: "string"
          }
        },
        url: "/app-manifests/:code/conversions"
      },
      createInstallationToken: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "POST",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          },
          permissions: {
            type: "object"
          },
          repository_ids: {
            type: "integer[]"
          }
        },
        url: "/app/installations/:installation_id/access_tokens"
      },
      deleteAuthorization: {
        headers: {
          accept: "application/vnd.github.doctor-strange-preview+json"
        },
        method: "DELETE",
        params: {
          access_token: {
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/grant"
      },
      deleteInstallation: {
        headers: {
          accept: "application/vnd.github.gambit-preview+json,application/vnd.github.machine-man-preview+json"
        },
        method: "DELETE",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/app/installations/:installation_id"
      },
      deleteToken: {
        headers: {
          accept: "application/vnd.github.doctor-strange-preview+json"
        },
        method: "DELETE",
        params: {
          access_token: {
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/token"
      },
      findOrgInstallation: {
        deprecated: "octokit.apps.findOrgInstallation() has been renamed to octokit.apps.getOrgInstallation() (2019-04-10)",
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/installation"
      },
      findRepoInstallation: {
        deprecated: "octokit.apps.findRepoInstallation() has been renamed to octokit.apps.getRepoInstallation() (2019-04-10)",
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/installation"
      },
      findUserInstallation: {
        deprecated: "octokit.apps.findUserInstallation() has been renamed to octokit.apps.getUserInstallation() (2019-04-10)",
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/installation"
      },
      getAuthenticated: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {},
        url: "/app"
      },
      getBySlug: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          app_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/apps/:app_slug"
      },
      getInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/app/installations/:installation_id"
      },
      getOrgInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/installation"
      },
      getRepoInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/installation"
      },
      getUserInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/installation"
      },
      listAccountsUserOrOrgOnPlan: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          plan_id: {
            required: true,
            type: "integer"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/marketplace_listing/plans/:plan_id/accounts"
      },
      listAccountsUserOrOrgOnPlanStubbed: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          plan_id: {
            required: true,
            type: "integer"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/marketplace_listing/stubbed/plans/:plan_id/accounts"
      },
      listInstallationReposForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/installations/:installation_id/repositories"
      },
      listInstallations: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/app/installations"
      },
      listInstallationsForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/installations"
      },
      listMarketplacePurchasesForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/marketplace_purchases"
      },
      listMarketplacePurchasesForAuthenticatedUserStubbed: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/marketplace_purchases/stubbed"
      },
      listPlans: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/marketplace_listing/plans"
      },
      listPlansStubbed: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/marketplace_listing/stubbed/plans"
      },
      listRepos: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/installation/repositories"
      },
      removeRepoFromInstallation: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "DELETE",
        params: {
          installation_id: {
            required: true,
            type: "integer"
          },
          repository_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/installations/:installation_id/repositories/:repository_id"
      },
      resetAuthorization: {
        deprecated: "octokit.apps.resetAuthorization() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#reset-an-authorization",
        method: "POST",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      resetToken: {
        headers: {
          accept: "application/vnd.github.doctor-strange-preview+json"
        },
        method: "PATCH",
        params: {
          access_token: {
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/token"
      },
      revokeAuthorizationForApplication: {
        deprecated: "octokit.apps.revokeAuthorizationForApplication() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#revoke-an-authorization-for-an-application",
        method: "DELETE",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      revokeGrantForApplication: {
        deprecated: "octokit.apps.revokeGrantForApplication() is deprecated, see https://developer.github.com/v3/apps/oauth_applications/#revoke-a-grant-for-an-application",
        method: "DELETE",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/grants/:access_token"
      },
      revokeInstallationToken: {
        headers: {
          accept: "application/vnd.github.gambit-preview+json"
        },
        method: "DELETE",
        params: {},
        url: "/installation/token"
      }
    },
    checks: {
      create: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "POST",
        params: {
          actions: {
            type: "object[]"
          },
          "actions[].description": {
            required: true,
            type: "string"
          },
          "actions[].identifier": {
            required: true,
            type: "string"
          },
          "actions[].label": {
            required: true,
            type: "string"
          },
          completed_at: {
            type: "string"
          },
          conclusion: {
            enum: ["success", "failure", "neutral", "cancelled", "timed_out", "action_required"],
            type: "string"
          },
          details_url: {
            type: "string"
          },
          external_id: {
            type: "string"
          },
          head_sha: {
            required: true,
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          output: {
            type: "object"
          },
          "output.annotations": {
            type: "object[]"
          },
          "output.annotations[].annotation_level": {
            enum: ["notice", "warning", "failure"],
            required: true,
            type: "string"
          },
          "output.annotations[].end_column": {
            type: "integer"
          },
          "output.annotations[].end_line": {
            required: true,
            type: "integer"
          },
          "output.annotations[].message": {
            required: true,
            type: "string"
          },
          "output.annotations[].path": {
            required: true,
            type: "string"
          },
          "output.annotations[].raw_details": {
            type: "string"
          },
          "output.annotations[].start_column": {
            type: "integer"
          },
          "output.annotations[].start_line": {
            required: true,
            type: "integer"
          },
          "output.annotations[].title": {
            type: "string"
          },
          "output.images": {
            type: "object[]"
          },
          "output.images[].alt": {
            required: true,
            type: "string"
          },
          "output.images[].caption": {
            type: "string"
          },
          "output.images[].image_url": {
            required: true,
            type: "string"
          },
          "output.summary": {
            required: true,
            type: "string"
          },
          "output.text": {
            type: "string"
          },
          "output.title": {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          started_at: {
            type: "string"
          },
          status: {
            enum: ["queued", "in_progress", "completed"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-runs"
      },
      createSuite: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "POST",
        params: {
          head_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-suites"
      },
      get: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          check_run_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-runs/:check_run_id"
      },
      getSuite: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          check_suite_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-suites/:check_suite_id"
      },
      listAnnotations: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          check_run_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-runs/:check_run_id/annotations"
      },
      listForRef: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          check_name: {
            type: "string"
          },
          filter: {
            enum: ["latest", "all"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          status: {
            enum: ["queued", "in_progress", "completed"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref/check-runs"
      },
      listForSuite: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          check_name: {
            type: "string"
          },
          check_suite_id: {
            required: true,
            type: "integer"
          },
          filter: {
            enum: ["latest", "all"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          status: {
            enum: ["queued", "in_progress", "completed"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-suites/:check_suite_id/check-runs"
      },
      listSuitesForRef: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "GET",
        params: {
          app_id: {
            type: "integer"
          },
          check_name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref/check-suites"
      },
      rerequestSuite: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "POST",
        params: {
          check_suite_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-suites/:check_suite_id/rerequest"
      },
      setSuitesPreferences: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "PATCH",
        params: {
          auto_trigger_checks: {
            type: "object[]"
          },
          "auto_trigger_checks[].app_id": {
            required: true,
            type: "integer"
          },
          "auto_trigger_checks[].setting": {
            required: true,
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-suites/preferences"
      },
      update: {
        headers: {
          accept: "application/vnd.github.antiope-preview+json"
        },
        method: "PATCH",
        params: {
          actions: {
            type: "object[]"
          },
          "actions[].description": {
            required: true,
            type: "string"
          },
          "actions[].identifier": {
            required: true,
            type: "string"
          },
          "actions[].label": {
            required: true,
            type: "string"
          },
          check_run_id: {
            required: true,
            type: "integer"
          },
          completed_at: {
            type: "string"
          },
          conclusion: {
            enum: ["success", "failure", "neutral", "cancelled", "timed_out", "action_required"],
            type: "string"
          },
          details_url: {
            type: "string"
          },
          external_id: {
            type: "string"
          },
          name: {
            type: "string"
          },
          output: {
            type: "object"
          },
          "output.annotations": {
            type: "object[]"
          },
          "output.annotations[].annotation_level": {
            enum: ["notice", "warning", "failure"],
            required: true,
            type: "string"
          },
          "output.annotations[].end_column": {
            type: "integer"
          },
          "output.annotations[].end_line": {
            required: true,
            type: "integer"
          },
          "output.annotations[].message": {
            required: true,
            type: "string"
          },
          "output.annotations[].path": {
            required: true,
            type: "string"
          },
          "output.annotations[].raw_details": {
            type: "string"
          },
          "output.annotations[].start_column": {
            type: "integer"
          },
          "output.annotations[].start_line": {
            required: true,
            type: "integer"
          },
          "output.annotations[].title": {
            type: "string"
          },
          "output.images": {
            type: "object[]"
          },
          "output.images[].alt": {
            required: true,
            type: "string"
          },
          "output.images[].caption": {
            type: "string"
          },
          "output.images[].image_url": {
            required: true,
            type: "string"
          },
          "output.summary": {
            required: true,
            type: "string"
          },
          "output.text": {
            type: "string"
          },
          "output.title": {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          started_at: {
            type: "string"
          },
          status: {
            enum: ["queued", "in_progress", "completed"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/check-runs/:check_run_id"
      }
    },
    codesOfConduct: {
      getConductCode: {
        headers: {
          accept: "application/vnd.github.scarlet-witch-preview+json"
        },
        method: "GET",
        params: {
          key: {
            required: true,
            type: "string"
          }
        },
        url: "/codes_of_conduct/:key"
      },
      getForRepo: {
        headers: {
          accept: "application/vnd.github.scarlet-witch-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/community/code_of_conduct"
      },
      listConductCodes: {
        headers: {
          accept: "application/vnd.github.scarlet-witch-preview+json"
        },
        method: "GET",
        params: {},
        url: "/codes_of_conduct"
      }
    },
    emojis: {
      get: {
        method: "GET",
        params: {},
        url: "/emojis"
      }
    },
    gists: {
      checkIsStarred: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/star"
      },
      create: {
        method: "POST",
        params: {
          description: {
            type: "string"
          },
          files: {
            required: true,
            type: "object"
          },
          "files.content": {
            type: "string"
          },
          public: {
            type: "boolean"
          }
        },
        url: "/gists"
      },
      createComment: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/comments"
      },
      delete: {
        method: "DELETE",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id"
      },
      deleteComment: {
        method: "DELETE",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/comments/:comment_id"
      },
      fork: {
        method: "POST",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/forks"
      },
      get: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id"
      },
      getComment: {
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/comments/:comment_id"
      },
      getRevision: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          },
          sha: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/:sha"
      },
      list: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          }
        },
        url: "/gists"
      },
      listComments: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/gists/:gist_id/comments"
      },
      listCommits: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/gists/:gist_id/commits"
      },
      listForks: {
        method: "GET",
        params: {
          gist_id: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/gists/:gist_id/forks"
      },
      listPublic: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          }
        },
        url: "/gists/public"
      },
      listPublicForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/gists"
      },
      listStarred: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          }
        },
        url: "/gists/starred"
      },
      star: {
        method: "PUT",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/star"
      },
      unstar: {
        method: "DELETE",
        params: {
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/star"
      },
      update: {
        method: "PATCH",
        params: {
          description: {
            type: "string"
          },
          files: {
            type: "object"
          },
          "files.content": {
            type: "string"
          },
          "files.filename": {
            type: "string"
          },
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id"
      },
      updateComment: {
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_id: {
            required: true,
            type: "integer"
          },
          gist_id: {
            required: true,
            type: "string"
          }
        },
        url: "/gists/:gist_id/comments/:comment_id"
      }
    },
    git: {
      createBlob: {
        method: "POST",
        params: {
          content: {
            required: true,
            type: "string"
          },
          encoding: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/blobs"
      },
      createCommit: {
        method: "POST",
        params: {
          author: {
            type: "object"
          },
          "author.date": {
            type: "string"
          },
          "author.email": {
            type: "string"
          },
          "author.name": {
            type: "string"
          },
          committer: {
            type: "object"
          },
          "committer.date": {
            type: "string"
          },
          "committer.email": {
            type: "string"
          },
          "committer.name": {
            type: "string"
          },
          message: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          parents: {
            required: true,
            type: "string[]"
          },
          repo: {
            required: true,
            type: "string"
          },
          signature: {
            type: "string"
          },
          tree: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/commits"
      },
      createRef: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/refs"
      },
      createTag: {
        method: "POST",
        params: {
          message: {
            required: true,
            type: "string"
          },
          object: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          tag: {
            required: true,
            type: "string"
          },
          tagger: {
            type: "object"
          },
          "tagger.date": {
            type: "string"
          },
          "tagger.email": {
            type: "string"
          },
          "tagger.name": {
            type: "string"
          },
          type: {
            enum: ["commit", "tree", "blob"],
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/tags"
      },
      createTree: {
        method: "POST",
        params: {
          base_tree: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          tree: {
            required: true,
            type: "object[]"
          },
          "tree[].content": {
            type: "string"
          },
          "tree[].mode": {
            enum: ["100644", "100755", "040000", "160000", "120000"],
            type: "string"
          },
          "tree[].path": {
            type: "string"
          },
          "tree[].sha": {
            allowNull: true,
            type: "string"
          },
          "tree[].type": {
            enum: ["blob", "tree", "commit"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/trees"
      },
      deleteRef: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/refs/:ref"
      },
      getBlob: {
        method: "GET",
        params: {
          file_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/blobs/:file_sha"
      },
      getCommit: {
        method: "GET",
        params: {
          commit_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/commits/:commit_sha"
      },
      getRef: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/ref/:ref"
      },
      getTag: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          tag_sha: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/tags/:tag_sha"
      },
      getTree: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          recursive: {
            enum: ["1"],
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          tree_sha: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/trees/:tree_sha"
      },
      listMatchingRefs: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/matching-refs/:ref"
      },
      listRefs: {
        method: "GET",
        params: {
          namespace: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/refs/:namespace"
      },
      updateRef: {
        method: "PATCH",
        params: {
          force: {
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/git/refs/:ref"
      }
    },
    gitignore: {
      getTemplate: {
        method: "GET",
        params: {
          name: {
            required: true,
            type: "string"
          }
        },
        url: "/gitignore/templates/:name"
      },
      listTemplates: {
        method: "GET",
        params: {},
        url: "/gitignore/templates"
      }
    },
    interactions: {
      addOrUpdateRestrictionsForOrg: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "PUT",
        params: {
          limit: {
            enum: ["existing_users", "contributors_only", "collaborators_only"],
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/interaction-limits"
      },
      addOrUpdateRestrictionsForRepo: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "PUT",
        params: {
          limit: {
            enum: ["existing_users", "contributors_only", "collaborators_only"],
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/interaction-limits"
      },
      getRestrictionsForOrg: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/interaction-limits"
      },
      getRestrictionsForRepo: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/interaction-limits"
      },
      removeRestrictionsForOrg: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/interaction-limits"
      },
      removeRestrictionsForRepo: {
        headers: {
          accept: "application/vnd.github.sombra-preview+json"
        },
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/interaction-limits"
      }
    },
    issues: {
      addAssignees: {
        method: "POST",
        params: {
          assignees: {
            type: "string[]"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/assignees"
      },
      addLabels: {
        method: "POST",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          labels: {
            required: true,
            type: "string[]"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/labels"
      },
      checkAssignee: {
        method: "GET",
        params: {
          assignee: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/assignees/:assignee"
      },
      create: {
        method: "POST",
        params: {
          assignee: {
            type: "string"
          },
          assignees: {
            type: "string[]"
          },
          body: {
            type: "string"
          },
          labels: {
            type: "string[]"
          },
          milestone: {
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues"
      },
      createComment: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/comments"
      },
      createLabel: {
        method: "POST",
        params: {
          color: {
            required: true,
            type: "string"
          },
          description: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/labels"
      },
      createMilestone: {
        method: "POST",
        params: {
          description: {
            type: "string"
          },
          due_on: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["open", "closed"],
            type: "string"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones"
      },
      deleteComment: {
        method: "DELETE",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments/:comment_id"
      },
      deleteLabel: {
        method: "DELETE",
        params: {
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/labels/:name"
      },
      deleteMilestone: {
        method: "DELETE",
        params: {
          milestone_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "milestone_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones/:milestone_number"
      },
      get: {
        method: "GET",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number"
      },
      getComment: {
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments/:comment_id"
      },
      getEvent: {
        method: "GET",
        params: {
          event_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/events/:event_id"
      },
      getLabel: {
        method: "GET",
        params: {
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/labels/:name"
      },
      getMilestone: {
        method: "GET",
        params: {
          milestone_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "milestone_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones/:milestone_number"
      },
      list: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          filter: {
            enum: ["assigned", "created", "mentioned", "subscribed", "all"],
            type: "string"
          },
          labels: {
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated", "comments"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/issues"
      },
      listAssignees: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/assignees"
      },
      listComments: {
        method: "GET",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/comments"
      },
      listCommentsForRepo: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments"
      },
      listEvents: {
        method: "GET",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/events"
      },
      listEventsForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/events"
      },
      listEventsForTimeline: {
        headers: {
          accept: "application/vnd.github.mockingbird-preview+json"
        },
        method: "GET",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/timeline"
      },
      listForAuthenticatedUser: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          filter: {
            enum: ["assigned", "created", "mentioned", "subscribed", "all"],
            type: "string"
          },
          labels: {
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated", "comments"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/user/issues"
      },
      listForOrg: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          filter: {
            enum: ["assigned", "created", "mentioned", "subscribed", "all"],
            type: "string"
          },
          labels: {
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated", "comments"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/orgs/:org/issues"
      },
      listForRepo: {
        method: "GET",
        params: {
          assignee: {
            type: "string"
          },
          creator: {
            type: "string"
          },
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          labels: {
            type: "string"
          },
          mentioned: {
            type: "string"
          },
          milestone: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated", "comments"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues"
      },
      listLabelsForMilestone: {
        method: "GET",
        params: {
          milestone_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "milestone_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones/:milestone_number/labels"
      },
      listLabelsForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/labels"
      },
      listLabelsOnIssue: {
        method: "GET",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/labels"
      },
      listMilestonesForRepo: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["due_on", "completeness"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones"
      },
      lock: {
        method: "PUT",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          lock_reason: {
            enum: ["off-topic", "too heated", "resolved", "spam"],
            type: "string"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/lock"
      },
      removeAssignees: {
        method: "DELETE",
        params: {
          assignees: {
            type: "string[]"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/assignees"
      },
      removeLabel: {
        method: "DELETE",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          name: {
            required: true,
            type: "string"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/labels/:name"
      },
      removeLabels: {
        method: "DELETE",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/labels"
      },
      replaceLabels: {
        method: "PUT",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          labels: {
            type: "string[]"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/labels"
      },
      unlock: {
        method: "DELETE",
        params: {
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/lock"
      },
      update: {
        method: "PATCH",
        params: {
          assignee: {
            type: "string"
          },
          assignees: {
            type: "string[]"
          },
          body: {
            type: "string"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          labels: {
            type: "string[]"
          },
          milestone: {
            allowNull: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["open", "closed"],
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number"
      },
      updateComment: {
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments/:comment_id"
      },
      updateLabel: {
        method: "PATCH",
        params: {
          color: {
            type: "string"
          },
          current_name: {
            required: true,
            type: "string"
          },
          description: {
            type: "string"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/labels/:current_name"
      },
      updateMilestone: {
        method: "PATCH",
        params: {
          description: {
            type: "string"
          },
          due_on: {
            type: "string"
          },
          milestone_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "milestone_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["open", "closed"],
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/milestones/:milestone_number"
      }
    },
    licenses: {
      get: {
        method: "GET",
        params: {
          license: {
            required: true,
            type: "string"
          }
        },
        url: "/licenses/:license"
      },
      getForRepo: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/license"
      },
      list: {
        deprecated: "octokit.licenses.list() has been renamed to octokit.licenses.listCommonlyUsed() (2019-03-05)",
        method: "GET",
        params: {},
        url: "/licenses"
      },
      listCommonlyUsed: {
        method: "GET",
        params: {},
        url: "/licenses"
      }
    },
    markdown: {
      render: {
        method: "POST",
        params: {
          context: {
            type: "string"
          },
          mode: {
            enum: ["markdown", "gfm"],
            type: "string"
          },
          text: {
            required: true,
            type: "string"
          }
        },
        url: "/markdown"
      },
      renderRaw: {
        headers: {
          "content-type": "text/plain; charset=utf-8"
        },
        method: "POST",
        params: {
          data: {
            mapTo: "data",
            required: true,
            type: "string"
          }
        },
        url: "/markdown/raw"
      }
    },
    meta: {
      get: {
        method: "GET",
        params: {},
        url: "/meta"
      }
    },
    migrations: {
      cancelImport: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import"
      },
      deleteArchiveForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "DELETE",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/migrations/:migration_id/archive"
      },
      deleteArchiveForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "DELETE",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/migrations/:migration_id/archive"
      },
      downloadArchiveForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/migrations/:migration_id/archive"
      },
      getArchiveForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/migrations/:migration_id/archive"
      },
      getArchiveForOrg: {
        deprecated: "octokit.migrations.getArchiveForOrg() has been renamed to octokit.migrations.downloadArchiveForOrg() (2020-01-27)",
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/migrations/:migration_id/archive"
      },
      getCommitAuthors: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import/authors"
      },
      getImportProgress: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import"
      },
      getLargeFiles: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import/large_files"
      },
      getStatusForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/migrations/:migration_id"
      },
      getStatusForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/migrations/:migration_id"
      },
      listForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/migrations"
      },
      listForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/migrations"
      },
      listReposForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/migrations/:migration_id/repositories"
      },
      listReposForUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "GET",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/:migration_id/repositories"
      },
      mapCommitAuthor: {
        method: "PATCH",
        params: {
          author_id: {
            required: true,
            type: "integer"
          },
          email: {
            type: "string"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import/authors/:author_id"
      },
      setLfsPreference: {
        method: "PATCH",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          use_lfs: {
            enum: ["opt_in", "opt_out"],
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import/lfs"
      },
      startForAuthenticatedUser: {
        method: "POST",
        params: {
          exclude_attachments: {
            type: "boolean"
          },
          lock_repositories: {
            type: "boolean"
          },
          repositories: {
            required: true,
            type: "string[]"
          }
        },
        url: "/user/migrations"
      },
      startForOrg: {
        method: "POST",
        params: {
          exclude_attachments: {
            type: "boolean"
          },
          lock_repositories: {
            type: "boolean"
          },
          org: {
            required: true,
            type: "string"
          },
          repositories: {
            required: true,
            type: "string[]"
          }
        },
        url: "/orgs/:org/migrations"
      },
      startImport: {
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          tfvc_project: {
            type: "string"
          },
          vcs: {
            enum: ["subversion", "git", "mercurial", "tfvc"],
            type: "string"
          },
          vcs_password: {
            type: "string"
          },
          vcs_url: {
            required: true,
            type: "string"
          },
          vcs_username: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import"
      },
      unlockRepoForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "DELETE",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          repo_name: {
            required: true,
            type: "string"
          }
        },
        url: "/user/migrations/:migration_id/repos/:repo_name/lock"
      },
      unlockRepoForOrg: {
        headers: {
          accept: "application/vnd.github.wyandotte-preview+json"
        },
        method: "DELETE",
        params: {
          migration_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          repo_name: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/migrations/:migration_id/repos/:repo_name/lock"
      },
      updateImport: {
        method: "PATCH",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          vcs_password: {
            type: "string"
          },
          vcs_username: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/import"
      }
    },
    oauthAuthorizations: {
      checkAuthorization: {
        deprecated: "octokit.oauthAuthorizations.checkAuthorization() has been renamed to octokit.apps.checkAuthorization() (2019-11-05)",
        method: "GET",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      createAuthorization: {
        deprecated: "octokit.oauthAuthorizations.createAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization",
        method: "POST",
        params: {
          client_id: {
            type: "string"
          },
          client_secret: {
            type: "string"
          },
          fingerprint: {
            type: "string"
          },
          note: {
            required: true,
            type: "string"
          },
          note_url: {
            type: "string"
          },
          scopes: {
            type: "string[]"
          }
        },
        url: "/authorizations"
      },
      deleteAuthorization: {
        deprecated: "octokit.oauthAuthorizations.deleteAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization",
        method: "DELETE",
        params: {
          authorization_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/authorizations/:authorization_id"
      },
      deleteGrant: {
        deprecated: "octokit.oauthAuthorizations.deleteGrant() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#delete-a-grant",
        method: "DELETE",
        params: {
          grant_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/applications/grants/:grant_id"
      },
      getAuthorization: {
        deprecated: "octokit.oauthAuthorizations.getAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization",
        method: "GET",
        params: {
          authorization_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/authorizations/:authorization_id"
      },
      getGrant: {
        deprecated: "octokit.oauthAuthorizations.getGrant() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-a-single-grant",
        method: "GET",
        params: {
          grant_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/applications/grants/:grant_id"
      },
      getOrCreateAuthorizationForApp: {
        deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForApp() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app",
        method: "PUT",
        params: {
          client_id: {
            required: true,
            type: "string"
          },
          client_secret: {
            required: true,
            type: "string"
          },
          fingerprint: {
            type: "string"
          },
          note: {
            type: "string"
          },
          note_url: {
            type: "string"
          },
          scopes: {
            type: "string[]"
          }
        },
        url: "/authorizations/clients/:client_id"
      },
      getOrCreateAuthorizationForAppAndFingerprint: {
        deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForAppAndFingerprint() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app-and-fingerprint",
        method: "PUT",
        params: {
          client_id: {
            required: true,
            type: "string"
          },
          client_secret: {
            required: true,
            type: "string"
          },
          fingerprint: {
            required: true,
            type: "string"
          },
          note: {
            type: "string"
          },
          note_url: {
            type: "string"
          },
          scopes: {
            type: "string[]"
          }
        },
        url: "/authorizations/clients/:client_id/:fingerprint"
      },
      getOrCreateAuthorizationForAppFingerprint: {
        deprecated: "octokit.oauthAuthorizations.getOrCreateAuthorizationForAppFingerprint() has been renamed to octokit.oauthAuthorizations.getOrCreateAuthorizationForAppAndFingerprint() (2018-12-27)",
        method: "PUT",
        params: {
          client_id: {
            required: true,
            type: "string"
          },
          client_secret: {
            required: true,
            type: "string"
          },
          fingerprint: {
            required: true,
            type: "string"
          },
          note: {
            type: "string"
          },
          note_url: {
            type: "string"
          },
          scopes: {
            type: "string[]"
          }
        },
        url: "/authorizations/clients/:client_id/:fingerprint"
      },
      listAuthorizations: {
        deprecated: "octokit.oauthAuthorizations.listAuthorizations() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/authorizations"
      },
      listGrants: {
        deprecated: "octokit.oauthAuthorizations.listGrants() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#list-your-grants",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/applications/grants"
      },
      resetAuthorization: {
        deprecated: "octokit.oauthAuthorizations.resetAuthorization() has been renamed to octokit.apps.resetAuthorization() (2019-11-05)",
        method: "POST",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      revokeAuthorizationForApplication: {
        deprecated: "octokit.oauthAuthorizations.revokeAuthorizationForApplication() has been renamed to octokit.apps.revokeAuthorizationForApplication() (2019-11-05)",
        method: "DELETE",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/tokens/:access_token"
      },
      revokeGrantForApplication: {
        deprecated: "octokit.oauthAuthorizations.revokeGrantForApplication() has been renamed to octokit.apps.revokeGrantForApplication() (2019-11-05)",
        method: "DELETE",
        params: {
          access_token: {
            required: true,
            type: "string"
          },
          client_id: {
            required: true,
            type: "string"
          }
        },
        url: "/applications/:client_id/grants/:access_token"
      },
      updateAuthorization: {
        deprecated: "octokit.oauthAuthorizations.updateAuthorization() is deprecated, see https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization",
        method: "PATCH",
        params: {
          add_scopes: {
            type: "string[]"
          },
          authorization_id: {
            required: true,
            type: "integer"
          },
          fingerprint: {
            type: "string"
          },
          note: {
            type: "string"
          },
          note_url: {
            type: "string"
          },
          remove_scopes: {
            type: "string[]"
          },
          scopes: {
            type: "string[]"
          }
        },
        url: "/authorizations/:authorization_id"
      }
    },
    orgs: {
      addOrUpdateMembership: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          role: {
            enum: ["admin", "member"],
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/memberships/:username"
      },
      blockUser: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/blocks/:username"
      },
      checkBlockedUser: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/blocks/:username"
      },
      checkMembership: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/members/:username"
      },
      checkPublicMembership: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/public_members/:username"
      },
      concealMembership: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/public_members/:username"
      },
      convertMemberToOutsideCollaborator: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/outside_collaborators/:username"
      },
      createHook: {
        method: "POST",
        params: {
          active: {
            type: "boolean"
          },
          config: {
            required: true,
            type: "object"
          },
          "config.content_type": {
            type: "string"
          },
          "config.insecure_ssl": {
            type: "string"
          },
          "config.secret": {
            type: "string"
          },
          "config.url": {
            required: true,
            type: "string"
          },
          events: {
            type: "string[]"
          },
          name: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/hooks"
      },
      createInvitation: {
        method: "POST",
        params: {
          email: {
            type: "string"
          },
          invitee_id: {
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          role: {
            enum: ["admin", "direct_member", "billing_manager"],
            type: "string"
          },
          team_ids: {
            type: "integer[]"
          }
        },
        url: "/orgs/:org/invitations"
      },
      deleteHook: {
        method: "DELETE",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/hooks/:hook_id"
      },
      get: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org"
      },
      getHook: {
        method: "GET",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/hooks/:hook_id"
      },
      getMembership: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/memberships/:username"
      },
      getMembershipForAuthenticatedUser: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/user/memberships/orgs/:org"
      },
      list: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "integer"
          }
        },
        url: "/organizations"
      },
      listBlockedUsers: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/blocks"
      },
      listForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/orgs"
      },
      listForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/orgs"
      },
      listHooks: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/hooks"
      },
      listInstallations: {
        headers: {
          accept: "application/vnd.github.machine-man-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/installations"
      },
      listInvitationTeams: {
        method: "GET",
        params: {
          invitation_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/invitations/:invitation_id/teams"
      },
      listMembers: {
        method: "GET",
        params: {
          filter: {
            enum: ["2fa_disabled", "all"],
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          role: {
            enum: ["all", "admin", "member"],
            type: "string"
          }
        },
        url: "/orgs/:org/members"
      },
      listMemberships: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          state: {
            enum: ["active", "pending"],
            type: "string"
          }
        },
        url: "/user/memberships/orgs"
      },
      listOutsideCollaborators: {
        method: "GET",
        params: {
          filter: {
            enum: ["2fa_disabled", "all"],
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/outside_collaborators"
      },
      listPendingInvitations: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/invitations"
      },
      listPublicMembers: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/public_members"
      },
      pingHook: {
        method: "POST",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/hooks/:hook_id/pings"
      },
      publicizeMembership: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/public_members/:username"
      },
      removeMember: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/members/:username"
      },
      removeMembership: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/memberships/:username"
      },
      removeOutsideCollaborator: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/outside_collaborators/:username"
      },
      unblockUser: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/blocks/:username"
      },
      update: {
        method: "PATCH",
        params: {
          billing_email: {
            type: "string"
          },
          company: {
            type: "string"
          },
          default_repository_permission: {
            enum: ["read", "write", "admin", "none"],
            type: "string"
          },
          description: {
            type: "string"
          },
          email: {
            type: "string"
          },
          has_organization_projects: {
            type: "boolean"
          },
          has_repository_projects: {
            type: "boolean"
          },
          location: {
            type: "string"
          },
          members_allowed_repository_creation_type: {
            enum: ["all", "private", "none"],
            type: "string"
          },
          members_can_create_internal_repositories: {
            type: "boolean"
          },
          members_can_create_private_repositories: {
            type: "boolean"
          },
          members_can_create_public_repositories: {
            type: "boolean"
          },
          members_can_create_repositories: {
            type: "boolean"
          },
          name: {
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org"
      },
      updateHook: {
        method: "PATCH",
        params: {
          active: {
            type: "boolean"
          },
          config: {
            type: "object"
          },
          "config.content_type": {
            type: "string"
          },
          "config.insecure_ssl": {
            type: "string"
          },
          "config.secret": {
            type: "string"
          },
          "config.url": {
            required: true,
            type: "string"
          },
          events: {
            type: "string[]"
          },
          hook_id: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/hooks/:hook_id"
      },
      updateMembership: {
        method: "PATCH",
        params: {
          org: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["active"],
            required: true,
            type: "string"
          }
        },
        url: "/user/memberships/orgs/:org"
      }
    },
    projects: {
      addCollaborator: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PUT",
        params: {
          permission: {
            enum: ["read", "write", "admin"],
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/projects/:project_id/collaborators/:username"
      },
      createCard: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          column_id: {
            required: true,
            type: "integer"
          },
          content_id: {
            type: "integer"
          },
          content_type: {
            type: "string"
          },
          note: {
            type: "string"
          }
        },
        url: "/projects/columns/:column_id/cards"
      },
      createColumn: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          name: {
            required: true,
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/:project_id/columns"
      },
      createForAuthenticatedUser: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          }
        },
        url: "/user/projects"
      },
      createForOrg: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/projects"
      },
      createForRepo: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/projects"
      },
      delete: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "DELETE",
        params: {
          project_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/:project_id"
      },
      deleteCard: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "DELETE",
        params: {
          card_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/columns/cards/:card_id"
      },
      deleteColumn: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "DELETE",
        params: {
          column_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/columns/:column_id"
      },
      get: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          project_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/:project_id"
      },
      getCard: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          card_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/columns/cards/:card_id"
      },
      getColumn: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          column_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/columns/:column_id"
      },
      listCards: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          archived_state: {
            enum: ["all", "archived", "not_archived"],
            type: "string"
          },
          column_id: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/projects/columns/:column_id/cards"
      },
      listCollaborators: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          affiliation: {
            enum: ["outside", "direct", "all"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          project_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/:project_id/collaborators"
      },
      listColumns: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          project_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/projects/:project_id/columns"
      },
      listForOrg: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/orgs/:org/projects"
      },
      listForRepo: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/projects"
      },
      listForUser: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/projects"
      },
      moveCard: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          card_id: {
            required: true,
            type: "integer"
          },
          column_id: {
            type: "integer"
          },
          position: {
            required: true,
            type: "string",
            validation: "^(top|bottom|after:\\d+)$"
          }
        },
        url: "/projects/columns/cards/:card_id/moves"
      },
      moveColumn: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "POST",
        params: {
          column_id: {
            required: true,
            type: "integer"
          },
          position: {
            required: true,
            type: "string",
            validation: "^(first|last|after:\\d+)$"
          }
        },
        url: "/projects/columns/:column_id/moves"
      },
      removeCollaborator: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "DELETE",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/projects/:project_id/collaborators/:username"
      },
      reviewUserPermissionLevel: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/projects/:project_id/collaborators/:username/permission"
      },
      update: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PATCH",
        params: {
          body: {
            type: "string"
          },
          name: {
            type: "string"
          },
          organization_permission: {
            type: "string"
          },
          private: {
            type: "boolean"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          state: {
            enum: ["open", "closed"],
            type: "string"
          }
        },
        url: "/projects/:project_id"
      },
      updateCard: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PATCH",
        params: {
          archived: {
            type: "boolean"
          },
          card_id: {
            required: true,
            type: "integer"
          },
          note: {
            type: "string"
          }
        },
        url: "/projects/columns/cards/:card_id"
      },
      updateColumn: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PATCH",
        params: {
          column_id: {
            required: true,
            type: "integer"
          },
          name: {
            required: true,
            type: "string"
          }
        },
        url: "/projects/columns/:column_id"
      }
    },
    pulls: {
      checkIfMerged: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/merge"
      },
      create: {
        method: "POST",
        params: {
          base: {
            required: true,
            type: "string"
          },
          body: {
            type: "string"
          },
          draft: {
            type: "boolean"
          },
          head: {
            required: true,
            type: "string"
          },
          maintainer_can_modify: {
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls"
      },
      createComment: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          commit_id: {
            required: true,
            type: "string"
          },
          in_reply_to: {
            deprecated: true,
            description: "The comment ID to reply to. **Note**: This must be the ID of a top-level comment, not a reply to that comment. Replies to replies are not supported.",
            type: "integer"
          },
          line: {
            type: "integer"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          position: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          side: {
            enum: ["LEFT", "RIGHT"],
            type: "string"
          },
          start_line: {
            type: "integer"
          },
          start_side: {
            enum: ["LEFT", "RIGHT", "side"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/comments"
      },
      createCommentReply: {
        deprecated: "octokit.pulls.createCommentReply() has been renamed to octokit.pulls.createComment() (2019-09-09)",
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          commit_id: {
            required: true,
            type: "string"
          },
          in_reply_to: {
            deprecated: true,
            description: "The comment ID to reply to. **Note**: This must be the ID of a top-level comment, not a reply to that comment. Replies to replies are not supported.",
            type: "integer"
          },
          line: {
            type: "integer"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          position: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          side: {
            enum: ["LEFT", "RIGHT"],
            type: "string"
          },
          start_line: {
            type: "integer"
          },
          start_side: {
            enum: ["LEFT", "RIGHT", "side"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/comments"
      },
      createFromIssue: {
        deprecated: "octokit.pulls.createFromIssue() is deprecated, see https://developer.github.com/v3/pulls/#create-a-pull-request",
        method: "POST",
        params: {
          base: {
            required: true,
            type: "string"
          },
          draft: {
            type: "boolean"
          },
          head: {
            required: true,
            type: "string"
          },
          issue: {
            required: true,
            type: "integer"
          },
          maintainer_can_modify: {
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls"
      },
      createReview: {
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          comments: {
            type: "object[]"
          },
          "comments[].body": {
            required: true,
            type: "string"
          },
          "comments[].path": {
            required: true,
            type: "string"
          },
          "comments[].position": {
            required: true,
            type: "integer"
          },
          commit_id: {
            type: "string"
          },
          event: {
            enum: ["APPROVE", "REQUEST_CHANGES", "COMMENT"],
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews"
      },
      createReviewCommentReply: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/comments/:comment_id/replies"
      },
      createReviewRequest: {
        method: "POST",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          reviewers: {
            type: "string[]"
          },
          team_reviewers: {
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers"
      },
      deleteComment: {
        method: "DELETE",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments/:comment_id"
      },
      deletePendingReview: {
        method: "DELETE",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id"
      },
      deleteReviewRequest: {
        method: "DELETE",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          reviewers: {
            type: "string[]"
          },
          team_reviewers: {
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers"
      },
      dismissReview: {
        method: "PUT",
        params: {
          message: {
            required: true,
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/dismissals"
      },
      get: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number"
      },
      getComment: {
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments/:comment_id"
      },
      getCommentsForReview: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/comments"
      },
      getReview: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id"
      },
      list: {
        method: "GET",
        params: {
          base: {
            type: "string"
          },
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          head: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["created", "updated", "popularity", "long-running"],
            type: "string"
          },
          state: {
            enum: ["open", "closed", "all"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls"
      },
      listComments: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/comments"
      },
      listCommentsForRepo: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          since: {
            type: "string"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments"
      },
      listCommits: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/commits"
      },
      listFiles: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/files"
      },
      listReviewRequests: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/requested_reviewers"
      },
      listReviews: {
        method: "GET",
        params: {
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews"
      },
      merge: {
        method: "PUT",
        params: {
          commit_message: {
            type: "string"
          },
          commit_title: {
            type: "string"
          },
          merge_method: {
            enum: ["merge", "squash", "rebase"],
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/merge"
      },
      submitReview: {
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          event: {
            enum: ["APPROVE", "REQUEST_CHANGES", "COMMENT"],
            required: true,
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id/events"
      },
      update: {
        method: "PATCH",
        params: {
          base: {
            type: "string"
          },
          body: {
            type: "string"
          },
          maintainer_can_modify: {
            type: "boolean"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["open", "closed"],
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number"
      },
      updateBranch: {
        headers: {
          accept: "application/vnd.github.lydian-preview+json"
        },
        method: "PUT",
        params: {
          expected_head_sha: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/update-branch"
      },
      updateComment: {
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments/:comment_id"
      },
      updateReview: {
        method: "PUT",
        params: {
          body: {
            required: true,
            type: "string"
          },
          number: {
            alias: "pull_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          pull_number: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          review_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/pulls/:pull_number/reviews/:review_id"
      }
    },
    rateLimit: {
      get: {
        method: "GET",
        params: {},
        url: "/rate_limit"
      }
    },
    reactions: {
      createForCommitComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments/:comment_id/reactions"
      },
      createForIssue: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/reactions"
      },
      createForIssueComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments/:comment_id/reactions"
      },
      createForPullRequestReviewComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments/:comment_id/reactions"
      },
      createForTeamDiscussion: {
        deprecated: "octokit.reactions.createForTeamDiscussion() has been renamed to octokit.reactions.createForTeamDiscussionLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/reactions"
      },
      createForTeamDiscussionComment: {
        deprecated: "octokit.reactions.createForTeamDiscussionComment() has been renamed to octokit.reactions.createForTeamDiscussionCommentLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      createForTeamDiscussionCommentInOrg: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      createForTeamDiscussionCommentLegacy: {
        deprecated: "octokit.reactions.createForTeamDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/reactions/#create-reaction-for-a-team-discussion-comment-legacy",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      createForTeamDiscussionInOrg: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/reactions"
      },
      createForTeamDiscussionLegacy: {
        deprecated: "octokit.reactions.createForTeamDiscussionLegacy() is deprecated, see https://developer.github.com/v3/reactions/#create-reaction-for-a-team-discussion-legacy",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "POST",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/reactions"
      },
      delete: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "DELETE",
        params: {
          reaction_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/reactions/:reaction_id"
      },
      listForCommitComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments/:comment_id/reactions"
      },
      listForIssue: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          issue_number: {
            required: true,
            type: "integer"
          },
          number: {
            alias: "issue_number",
            deprecated: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/:issue_number/reactions"
      },
      listForIssueComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/issues/comments/:comment_id/reactions"
      },
      listForPullRequestReviewComment: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pulls/comments/:comment_id/reactions"
      },
      listForTeamDiscussion: {
        deprecated: "octokit.reactions.listForTeamDiscussion() has been renamed to octokit.reactions.listForTeamDiscussionLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/reactions"
      },
      listForTeamDiscussionComment: {
        deprecated: "octokit.reactions.listForTeamDiscussionComment() has been renamed to octokit.reactions.listForTeamDiscussionCommentLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      listForTeamDiscussionCommentInOrg: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      listForTeamDiscussionCommentLegacy: {
        deprecated: "octokit.reactions.listForTeamDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/reactions/#list-reactions-for-a-team-discussion-comment-legacy",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number/reactions"
      },
      listForTeamDiscussionInOrg: {
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/reactions"
      },
      listForTeamDiscussionLegacy: {
        deprecated: "octokit.reactions.listForTeamDiscussionLegacy() is deprecated, see https://developer.github.com/v3/reactions/#list-reactions-for-a-team-discussion-legacy",
        headers: {
          accept: "application/vnd.github.squirrel-girl-preview+json"
        },
        method: "GET",
        params: {
          content: {
            enum: ["+1", "-1", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/reactions"
      }
    },
    repos: {
      acceptInvitation: {
        method: "PATCH",
        params: {
          invitation_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/repository_invitations/:invitation_id"
      },
      addCollaborator: {
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/collaborators/:username"
      },
      addDeployKey: {
        method: "POST",
        params: {
          key: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          read_only: {
            type: "boolean"
          },
          repo: {
            required: true,
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/keys"
      },
      addProtectedBranchAdminEnforcement: {
        method: "POST",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins"
      },
      addProtectedBranchAppRestrictions: {
        method: "POST",
        params: {
          apps: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps"
      },
      addProtectedBranchRequiredSignatures: {
        headers: {
          accept: "application/vnd.github.zzzax-preview+json"
        },
        method: "POST",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures"
      },
      addProtectedBranchRequiredStatusChecksContexts: {
        method: "POST",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          contexts: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts"
      },
      addProtectedBranchTeamRestrictions: {
        method: "POST",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          teams: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      addProtectedBranchUserRestrictions: {
        method: "POST",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          users: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      checkCollaborator: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/collaborators/:username"
      },
      checkVulnerabilityAlerts: {
        headers: {
          accept: "application/vnd.github.dorian-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/vulnerability-alerts"
      },
      compareCommits: {
        method: "GET",
        params: {
          base: {
            required: true,
            type: "string"
          },
          head: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/compare/:base...:head"
      },
      createCommitComment: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          commit_sha: {
            required: true,
            type: "string"
          },
          line: {
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            type: "string"
          },
          position: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            alias: "commit_sha",
            deprecated: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:commit_sha/comments"
      },
      createDeployment: {
        method: "POST",
        params: {
          auto_merge: {
            type: "boolean"
          },
          description: {
            type: "string"
          },
          environment: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          payload: {
            type: "string"
          },
          production_environment: {
            type: "boolean"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          required_contexts: {
            type: "string[]"
          },
          task: {
            type: "string"
          },
          transient_environment: {
            type: "boolean"
          }
        },
        url: "/repos/:owner/:repo/deployments"
      },
      createDeploymentStatus: {
        method: "POST",
        params: {
          auto_inactive: {
            type: "boolean"
          },
          deployment_id: {
            required: true,
            type: "integer"
          },
          description: {
            type: "string"
          },
          environment: {
            enum: ["production", "staging", "qa"],
            type: "string"
          },
          environment_url: {
            type: "string"
          },
          log_url: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["error", "failure", "inactive", "in_progress", "queued", "pending", "success"],
            required: true,
            type: "string"
          },
          target_url: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/deployments/:deployment_id/statuses"
      },
      createDispatchEvent: {
        method: "POST",
        params: {
          client_payload: {
            type: "object"
          },
          event_type: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/dispatches"
      },
      createFile: {
        deprecated: "octokit.repos.createFile() has been renamed to octokit.repos.createOrUpdateFile() (2019-06-07)",
        method: "PUT",
        params: {
          author: {
            type: "object"
          },
          "author.email": {
            required: true,
            type: "string"
          },
          "author.name": {
            required: true,
            type: "string"
          },
          branch: {
            type: "string"
          },
          committer: {
            type: "object"
          },
          "committer.email": {
            required: true,
            type: "string"
          },
          "committer.name": {
            required: true,
            type: "string"
          },
          content: {
            required: true,
            type: "string"
          },
          message: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contents/:path"
      },
      createForAuthenticatedUser: {
        method: "POST",
        params: {
          allow_merge_commit: {
            type: "boolean"
          },
          allow_rebase_merge: {
            type: "boolean"
          },
          allow_squash_merge: {
            type: "boolean"
          },
          auto_init: {
            type: "boolean"
          },
          delete_branch_on_merge: {
            type: "boolean"
          },
          description: {
            type: "string"
          },
          gitignore_template: {
            type: "string"
          },
          has_issues: {
            type: "boolean"
          },
          has_projects: {
            type: "boolean"
          },
          has_wiki: {
            type: "boolean"
          },
          homepage: {
            type: "string"
          },
          is_template: {
            type: "boolean"
          },
          license_template: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          team_id: {
            type: "integer"
          },
          visibility: {
            enum: ["public", "private", "visibility", "internal"],
            type: "string"
          }
        },
        url: "/user/repos"
      },
      createFork: {
        method: "POST",
        params: {
          organization: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/forks"
      },
      createHook: {
        method: "POST",
        params: {
          active: {
            type: "boolean"
          },
          config: {
            required: true,
            type: "object"
          },
          "config.content_type": {
            type: "string"
          },
          "config.insecure_ssl": {
            type: "string"
          },
          "config.secret": {
            type: "string"
          },
          "config.url": {
            required: true,
            type: "string"
          },
          events: {
            type: "string[]"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks"
      },
      createInOrg: {
        method: "POST",
        params: {
          allow_merge_commit: {
            type: "boolean"
          },
          allow_rebase_merge: {
            type: "boolean"
          },
          allow_squash_merge: {
            type: "boolean"
          },
          auto_init: {
            type: "boolean"
          },
          delete_branch_on_merge: {
            type: "boolean"
          },
          description: {
            type: "string"
          },
          gitignore_template: {
            type: "string"
          },
          has_issues: {
            type: "boolean"
          },
          has_projects: {
            type: "boolean"
          },
          has_wiki: {
            type: "boolean"
          },
          homepage: {
            type: "string"
          },
          is_template: {
            type: "boolean"
          },
          license_template: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          team_id: {
            type: "integer"
          },
          visibility: {
            enum: ["public", "private", "visibility", "internal"],
            type: "string"
          }
        },
        url: "/orgs/:org/repos"
      },
      createOrUpdateFile: {
        method: "PUT",
        params: {
          author: {
            type: "object"
          },
          "author.email": {
            required: true,
            type: "string"
          },
          "author.name": {
            required: true,
            type: "string"
          },
          branch: {
            type: "string"
          },
          committer: {
            type: "object"
          },
          "committer.email": {
            required: true,
            type: "string"
          },
          "committer.name": {
            required: true,
            type: "string"
          },
          content: {
            required: true,
            type: "string"
          },
          message: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contents/:path"
      },
      createRelease: {
        method: "POST",
        params: {
          body: {
            type: "string"
          },
          draft: {
            type: "boolean"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          prerelease: {
            type: "boolean"
          },
          repo: {
            required: true,
            type: "string"
          },
          tag_name: {
            required: true,
            type: "string"
          },
          target_commitish: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases"
      },
      createStatus: {
        method: "POST",
        params: {
          context: {
            type: "string"
          },
          description: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            required: true,
            type: "string"
          },
          state: {
            enum: ["error", "failure", "pending", "success"],
            required: true,
            type: "string"
          },
          target_url: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/statuses/:sha"
      },
      createUsingTemplate: {
        headers: {
          accept: "application/vnd.github.baptiste-preview+json"
        },
        method: "POST",
        params: {
          description: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          owner: {
            type: "string"
          },
          private: {
            type: "boolean"
          },
          template_owner: {
            required: true,
            type: "string"
          },
          template_repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:template_owner/:template_repo/generate"
      },
      declineInvitation: {
        method: "DELETE",
        params: {
          invitation_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/repository_invitations/:invitation_id"
      },
      delete: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo"
      },
      deleteCommitComment: {
        method: "DELETE",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments/:comment_id"
      },
      deleteDownload: {
        method: "DELETE",
        params: {
          download_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/downloads/:download_id"
      },
      deleteFile: {
        method: "DELETE",
        params: {
          author: {
            type: "object"
          },
          "author.email": {
            type: "string"
          },
          "author.name": {
            type: "string"
          },
          branch: {
            type: "string"
          },
          committer: {
            type: "object"
          },
          "committer.email": {
            type: "string"
          },
          "committer.name": {
            type: "string"
          },
          message: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contents/:path"
      },
      deleteHook: {
        method: "DELETE",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks/:hook_id"
      },
      deleteInvitation: {
        method: "DELETE",
        params: {
          invitation_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/invitations/:invitation_id"
      },
      deleteRelease: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          release_id: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/:release_id"
      },
      deleteReleaseAsset: {
        method: "DELETE",
        params: {
          asset_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/assets/:asset_id"
      },
      disableAutomatedSecurityFixes: {
        headers: {
          accept: "application/vnd.github.london-preview+json"
        },
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/automated-security-fixes"
      },
      disablePagesSite: {
        headers: {
          accept: "application/vnd.github.switcheroo-preview+json"
        },
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages"
      },
      disableVulnerabilityAlerts: {
        headers: {
          accept: "application/vnd.github.dorian-preview+json"
        },
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/vulnerability-alerts"
      },
      enableAutomatedSecurityFixes: {
        headers: {
          accept: "application/vnd.github.london-preview+json"
        },
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/automated-security-fixes"
      },
      enablePagesSite: {
        headers: {
          accept: "application/vnd.github.switcheroo-preview+json"
        },
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          source: {
            type: "object"
          },
          "source.branch": {
            enum: ["master", "gh-pages"],
            type: "string"
          },
          "source.path": {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages"
      },
      enableVulnerabilityAlerts: {
        headers: {
          accept: "application/vnd.github.dorian-preview+json"
        },
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/vulnerability-alerts"
      },
      get: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo"
      },
      getAppsWithAccessToProtectedBranch: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps"
      },
      getArchiveLink: {
        method: "GET",
        params: {
          archive_format: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/:archive_format/:ref"
      },
      getBranch: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch"
      },
      getBranchProtection: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection"
      },
      getClones: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          per: {
            enum: ["day", "week"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/traffic/clones"
      },
      getCodeFrequencyStats: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stats/code_frequency"
      },
      getCollaboratorPermissionLevel: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/collaborators/:username/permission"
      },
      getCombinedStatusForRef: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref/status"
      },
      getCommit: {
        method: "GET",
        params: {
          commit_sha: {
            alias: "ref",
            deprecated: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            alias: "ref",
            deprecated: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref"
      },
      getCommitActivityStats: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stats/commit_activity"
      },
      getCommitComment: {
        method: "GET",
        params: {
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments/:comment_id"
      },
      getCommitRefSha: {
        deprecated: "octokit.repos.getCommitRefSha() is deprecated, see https://developer.github.com/v3/repos/commits/#get-a-single-commit",
        headers: {
          accept: "application/vnd.github.v3.sha"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref"
      },
      getContents: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          ref: {
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contents/:path"
      },
      getContributorsStats: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stats/contributors"
      },
      getDeployKey: {
        method: "GET",
        params: {
          key_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/keys/:key_id"
      },
      getDeployment: {
        method: "GET",
        params: {
          deployment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/deployments/:deployment_id"
      },
      getDeploymentStatus: {
        method: "GET",
        params: {
          deployment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          status_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/deployments/:deployment_id/statuses/:status_id"
      },
      getDownload: {
        method: "GET",
        params: {
          download_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/downloads/:download_id"
      },
      getHook: {
        method: "GET",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks/:hook_id"
      },
      getLatestPagesBuild: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages/builds/latest"
      },
      getLatestRelease: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/latest"
      },
      getPages: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages"
      },
      getPagesBuild: {
        method: "GET",
        params: {
          build_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages/builds/:build_id"
      },
      getParticipationStats: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stats/participation"
      },
      getProtectedBranchAdminEnforcement: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins"
      },
      getProtectedBranchPullRequestReviewEnforcement: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews"
      },
      getProtectedBranchRequiredSignatures: {
        headers: {
          accept: "application/vnd.github.zzzax-preview+json"
        },
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures"
      },
      getProtectedBranchRequiredStatusChecks: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks"
      },
      getProtectedBranchRestrictions: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions"
      },
      getPunchCardStats: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/stats/punch_card"
      },
      getReadme: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          ref: {
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/readme"
      },
      getRelease: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          release_id: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/:release_id"
      },
      getReleaseAsset: {
        method: "GET",
        params: {
          asset_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/assets/:asset_id"
      },
      getReleaseByTag: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          tag: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/tags/:tag"
      },
      getTeamsWithAccessToProtectedBranch: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      getTopPaths: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/traffic/popular/paths"
      },
      getTopReferrers: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/traffic/popular/referrers"
      },
      getUsersWithAccessToProtectedBranch: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      getViews: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          per: {
            enum: ["day", "week"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/traffic/views"
      },
      list: {
        method: "GET",
        params: {
          affiliation: {
            type: "string"
          },
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          sort: {
            enum: ["created", "updated", "pushed", "full_name"],
            type: "string"
          },
          type: {
            enum: ["all", "owner", "public", "private", "member"],
            type: "string"
          },
          visibility: {
            enum: ["all", "public", "private"],
            type: "string"
          }
        },
        url: "/user/repos"
      },
      listAppsWithAccessToProtectedBranch: {
        deprecated: "octokit.repos.listAppsWithAccessToProtectedBranch() has been renamed to octokit.repos.getAppsWithAccessToProtectedBranch() (2019-09-13)",
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps"
      },
      listAssetsForRelease: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          release_id: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/:release_id/assets"
      },
      listBranches: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          protected: {
            type: "boolean"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches"
      },
      listBranchesForHeadCommit: {
        headers: {
          accept: "application/vnd.github.groot-preview+json"
        },
        method: "GET",
        params: {
          commit_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:commit_sha/branches-where-head"
      },
      listCollaborators: {
        method: "GET",
        params: {
          affiliation: {
            enum: ["outside", "direct", "all"],
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/collaborators"
      },
      listCommentsForCommit: {
        method: "GET",
        params: {
          commit_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            alias: "commit_sha",
            deprecated: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:commit_sha/comments"
      },
      listCommitComments: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments"
      },
      listCommits: {
        method: "GET",
        params: {
          author: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          path: {
            type: "string"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          },
          since: {
            type: "string"
          },
          until: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits"
      },
      listContributors: {
        method: "GET",
        params: {
          anon: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contributors"
      },
      listDeployKeys: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/keys"
      },
      listDeploymentStatuses: {
        method: "GET",
        params: {
          deployment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/deployments/:deployment_id/statuses"
      },
      listDeployments: {
        method: "GET",
        params: {
          environment: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          },
          task: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/deployments"
      },
      listDownloads: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/downloads"
      },
      listForOrg: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          sort: {
            enum: ["created", "updated", "pushed", "full_name"],
            type: "string"
          },
          type: {
            enum: ["all", "public", "private", "forks", "sources", "member", "internal"],
            type: "string"
          }
        },
        url: "/orgs/:org/repos"
      },
      listForUser: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          sort: {
            enum: ["created", "updated", "pushed", "full_name"],
            type: "string"
          },
          type: {
            enum: ["all", "owner", "member"],
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/repos"
      },
      listForks: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["newest", "oldest", "stargazers"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/forks"
      },
      listHooks: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks"
      },
      listInvitations: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/invitations"
      },
      listInvitationsForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/repository_invitations"
      },
      listLanguages: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/languages"
      },
      listPagesBuilds: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages/builds"
      },
      listProtectedBranchRequiredStatusChecksContexts: {
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts"
      },
      listProtectedBranchTeamRestrictions: {
        deprecated: "octokit.repos.listProtectedBranchTeamRestrictions() has been renamed to octokit.repos.getTeamsWithAccessToProtectedBranch() (2019-09-09)",
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      listProtectedBranchUserRestrictions: {
        deprecated: "octokit.repos.listProtectedBranchUserRestrictions() has been renamed to octokit.repos.getUsersWithAccessToProtectedBranch() (2019-09-09)",
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      listPublic: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "integer"
          }
        },
        url: "/repositories"
      },
      listPullRequestsAssociatedWithCommit: {
        headers: {
          accept: "application/vnd.github.groot-preview+json"
        },
        method: "GET",
        params: {
          commit_sha: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:commit_sha/pulls"
      },
      listReleases: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases"
      },
      listStatusesForRef: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          ref: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/commits/:ref/statuses"
      },
      listTags: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/tags"
      },
      listTeams: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/teams"
      },
      listTeamsWithAccessToProtectedBranch: {
        deprecated: "octokit.repos.listTeamsWithAccessToProtectedBranch() has been renamed to octokit.repos.getTeamsWithAccessToProtectedBranch() (2019-09-13)",
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      listTopics: {
        headers: {
          accept: "application/vnd.github.mercy-preview+json"
        },
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/topics"
      },
      listUsersWithAccessToProtectedBranch: {
        deprecated: "octokit.repos.listUsersWithAccessToProtectedBranch() has been renamed to octokit.repos.getUsersWithAccessToProtectedBranch() (2019-09-13)",
        method: "GET",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      merge: {
        method: "POST",
        params: {
          base: {
            required: true,
            type: "string"
          },
          commit_message: {
            type: "string"
          },
          head: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/merges"
      },
      pingHook: {
        method: "POST",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks/:hook_id/pings"
      },
      removeBranchProtection: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection"
      },
      removeCollaborator: {
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/collaborators/:username"
      },
      removeDeployKey: {
        method: "DELETE",
        params: {
          key_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/keys/:key_id"
      },
      removeProtectedBranchAdminEnforcement: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/enforce_admins"
      },
      removeProtectedBranchAppRestrictions: {
        method: "DELETE",
        params: {
          apps: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps"
      },
      removeProtectedBranchPullRequestReviewEnforcement: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews"
      },
      removeProtectedBranchRequiredSignatures: {
        headers: {
          accept: "application/vnd.github.zzzax-preview+json"
        },
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_signatures"
      },
      removeProtectedBranchRequiredStatusChecks: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks"
      },
      removeProtectedBranchRequiredStatusChecksContexts: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          contexts: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts"
      },
      removeProtectedBranchRestrictions: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions"
      },
      removeProtectedBranchTeamRestrictions: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          teams: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      removeProtectedBranchUserRestrictions: {
        method: "DELETE",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          users: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      replaceProtectedBranchAppRestrictions: {
        method: "PUT",
        params: {
          apps: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/apps"
      },
      replaceProtectedBranchRequiredStatusChecksContexts: {
        method: "PUT",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          contexts: {
            mapTo: "data",
            required: true,
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks/contexts"
      },
      replaceProtectedBranchTeamRestrictions: {
        method: "PUT",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          teams: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/teams"
      },
      replaceProtectedBranchUserRestrictions: {
        method: "PUT",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          users: {
            mapTo: "data",
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/restrictions/users"
      },
      replaceTopics: {
        headers: {
          accept: "application/vnd.github.mercy-preview+json"
        },
        method: "PUT",
        params: {
          names: {
            required: true,
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/topics"
      },
      requestPageBuild: {
        method: "POST",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages/builds"
      },
      retrieveCommunityProfileMetrics: {
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/community/profile"
      },
      testPushHook: {
        method: "POST",
        params: {
          hook_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks/:hook_id/tests"
      },
      transfer: {
        method: "POST",
        params: {
          new_owner: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_ids: {
            type: "integer[]"
          }
        },
        url: "/repos/:owner/:repo/transfer"
      },
      update: {
        method: "PATCH",
        params: {
          allow_merge_commit: {
            type: "boolean"
          },
          allow_rebase_merge: {
            type: "boolean"
          },
          allow_squash_merge: {
            type: "boolean"
          },
          archived: {
            type: "boolean"
          },
          default_branch: {
            type: "string"
          },
          delete_branch_on_merge: {
            type: "boolean"
          },
          description: {
            type: "string"
          },
          has_issues: {
            type: "boolean"
          },
          has_projects: {
            type: "boolean"
          },
          has_wiki: {
            type: "boolean"
          },
          homepage: {
            type: "string"
          },
          is_template: {
            type: "boolean"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          repo: {
            required: true,
            type: "string"
          },
          visibility: {
            enum: ["public", "private", "visibility", "internal"],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo"
      },
      updateBranchProtection: {
        method: "PUT",
        params: {
          allow_deletions: {
            type: "boolean"
          },
          allow_force_pushes: {
            allowNull: true,
            type: "boolean"
          },
          branch: {
            required: true,
            type: "string"
          },
          enforce_admins: {
            allowNull: true,
            required: true,
            type: "boolean"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          required_linear_history: {
            type: "boolean"
          },
          required_pull_request_reviews: {
            allowNull: true,
            required: true,
            type: "object"
          },
          "required_pull_request_reviews.dismiss_stale_reviews": {
            type: "boolean"
          },
          "required_pull_request_reviews.dismissal_restrictions": {
            type: "object"
          },
          "required_pull_request_reviews.dismissal_restrictions.teams": {
            type: "string[]"
          },
          "required_pull_request_reviews.dismissal_restrictions.users": {
            type: "string[]"
          },
          "required_pull_request_reviews.require_code_owner_reviews": {
            type: "boolean"
          },
          "required_pull_request_reviews.required_approving_review_count": {
            type: "integer"
          },
          required_status_checks: {
            allowNull: true,
            required: true,
            type: "object"
          },
          "required_status_checks.contexts": {
            required: true,
            type: "string[]"
          },
          "required_status_checks.strict": {
            required: true,
            type: "boolean"
          },
          restrictions: {
            allowNull: true,
            required: true,
            type: "object"
          },
          "restrictions.apps": {
            type: "string[]"
          },
          "restrictions.teams": {
            required: true,
            type: "string[]"
          },
          "restrictions.users": {
            required: true,
            type: "string[]"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection"
      },
      updateCommitComment: {
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/comments/:comment_id"
      },
      updateFile: {
        deprecated: "octokit.repos.updateFile() has been renamed to octokit.repos.createOrUpdateFile() (2019-06-07)",
        method: "PUT",
        params: {
          author: {
            type: "object"
          },
          "author.email": {
            required: true,
            type: "string"
          },
          "author.name": {
            required: true,
            type: "string"
          },
          branch: {
            type: "string"
          },
          committer: {
            type: "object"
          },
          "committer.email": {
            required: true,
            type: "string"
          },
          "committer.name": {
            required: true,
            type: "string"
          },
          content: {
            required: true,
            type: "string"
          },
          message: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          path: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          sha: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/contents/:path"
      },
      updateHook: {
        method: "PATCH",
        params: {
          active: {
            type: "boolean"
          },
          add_events: {
            type: "string[]"
          },
          config: {
            type: "object"
          },
          "config.content_type": {
            type: "string"
          },
          "config.insecure_ssl": {
            type: "string"
          },
          "config.secret": {
            type: "string"
          },
          "config.url": {
            required: true,
            type: "string"
          },
          events: {
            type: "string[]"
          },
          hook_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          remove_events: {
            type: "string[]"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/hooks/:hook_id"
      },
      updateInformationAboutPagesSite: {
        method: "PUT",
        params: {
          cname: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          source: {
            enum: ['"gh-pages"', '"master"', '"master /docs"'],
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/pages"
      },
      updateInvitation: {
        method: "PATCH",
        params: {
          invitation_id: {
            required: true,
            type: "integer"
          },
          owner: {
            required: true,
            type: "string"
          },
          permissions: {
            enum: ["read", "write", "admin"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/invitations/:invitation_id"
      },
      updateProtectedBranchPullRequestReviewEnforcement: {
        method: "PATCH",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          dismiss_stale_reviews: {
            type: "boolean"
          },
          dismissal_restrictions: {
            type: "object"
          },
          "dismissal_restrictions.teams": {
            type: "string[]"
          },
          "dismissal_restrictions.users": {
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          require_code_owner_reviews: {
            type: "boolean"
          },
          required_approving_review_count: {
            type: "integer"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_pull_request_reviews"
      },
      updateProtectedBranchRequiredStatusChecks: {
        method: "PATCH",
        params: {
          branch: {
            required: true,
            type: "string"
          },
          contexts: {
            type: "string[]"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          strict: {
            type: "boolean"
          }
        },
        url: "/repos/:owner/:repo/branches/:branch/protection/required_status_checks"
      },
      updateRelease: {
        method: "PATCH",
        params: {
          body: {
            type: "string"
          },
          draft: {
            type: "boolean"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          prerelease: {
            type: "boolean"
          },
          release_id: {
            required: true,
            type: "integer"
          },
          repo: {
            required: true,
            type: "string"
          },
          tag_name: {
            type: "string"
          },
          target_commitish: {
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/:release_id"
      },
      updateReleaseAsset: {
        method: "PATCH",
        params: {
          asset_id: {
            required: true,
            type: "integer"
          },
          label: {
            type: "string"
          },
          name: {
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          }
        },
        url: "/repos/:owner/:repo/releases/assets/:asset_id"
      },
      uploadReleaseAsset: {
        method: "POST",
        params: {
          data: {
            mapTo: "data",
            required: true,
            type: "string | object"
          },
          file: {
            alias: "data",
            deprecated: true,
            type: "string | object"
          },
          headers: {
            required: true,
            type: "object"
          },
          "headers.content-length": {
            required: true,
            type: "integer"
          },
          "headers.content-type": {
            required: true,
            type: "string"
          },
          label: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          url: {
            required: true,
            type: "string"
          }
        },
        url: ":url"
      }
    },
    search: {
      code: {
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["indexed"],
            type: "string"
          }
        },
        url: "/search/code"
      },
      commits: {
        headers: {
          accept: "application/vnd.github.cloak-preview+json"
        },
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["author-date", "committer-date"],
            type: "string"
          }
        },
        url: "/search/commits"
      },
      issues: {
        deprecated: "octokit.search.issues() has been renamed to octokit.search.issuesAndPullRequests() (2018-12-27)",
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["comments", "reactions", "reactions-+1", "reactions--1", "reactions-smile", "reactions-thinking_face", "reactions-heart", "reactions-tada", "interactions", "created", "updated"],
            type: "string"
          }
        },
        url: "/search/issues"
      },
      issuesAndPullRequests: {
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["comments", "reactions", "reactions-+1", "reactions--1", "reactions-smile", "reactions-thinking_face", "reactions-heart", "reactions-tada", "interactions", "created", "updated"],
            type: "string"
          }
        },
        url: "/search/issues"
      },
      labels: {
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          q: {
            required: true,
            type: "string"
          },
          repository_id: {
            required: true,
            type: "integer"
          },
          sort: {
            enum: ["created", "updated"],
            type: "string"
          }
        },
        url: "/search/labels"
      },
      repos: {
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["stars", "forks", "help-wanted-issues", "updated"],
            type: "string"
          }
        },
        url: "/search/repositories"
      },
      topics: {
        method: "GET",
        params: {
          q: {
            required: true,
            type: "string"
          }
        },
        url: "/search/topics"
      },
      users: {
        method: "GET",
        params: {
          order: {
            enum: ["desc", "asc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          q: {
            required: true,
            type: "string"
          },
          sort: {
            enum: ["followers", "repositories", "joined"],
            type: "string"
          }
        },
        url: "/search/users"
      }
    },
    teams: {
      addMember: {
        deprecated: "octokit.teams.addMember() has been renamed to octokit.teams.addMemberLegacy() (2020-01-16)",
        method: "PUT",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      addMemberLegacy: {
        deprecated: "octokit.teams.addMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#add-team-member-legacy",
        method: "PUT",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      addOrUpdateMembership: {
        deprecated: "octokit.teams.addOrUpdateMembership() has been renamed to octokit.teams.addOrUpdateMembershipLegacy() (2020-01-16)",
        method: "PUT",
        params: {
          role: {
            enum: ["member", "maintainer"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      addOrUpdateMembershipInOrg: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          role: {
            enum: ["member", "maintainer"],
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/memberships/:username"
      },
      addOrUpdateMembershipLegacy: {
        deprecated: "octokit.teams.addOrUpdateMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#add-or-update-team-membership-legacy",
        method: "PUT",
        params: {
          role: {
            enum: ["member", "maintainer"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      addOrUpdateProject: {
        deprecated: "octokit.teams.addOrUpdateProject() has been renamed to octokit.teams.addOrUpdateProjectLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PUT",
        params: {
          permission: {
            enum: ["read", "write", "admin"],
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      addOrUpdateProjectInOrg: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          permission: {
            enum: ["read", "write", "admin"],
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/projects/:project_id"
      },
      addOrUpdateProjectLegacy: {
        deprecated: "octokit.teams.addOrUpdateProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#add-or-update-team-project-legacy",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "PUT",
        params: {
          permission: {
            enum: ["read", "write", "admin"],
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      addOrUpdateRepo: {
        deprecated: "octokit.teams.addOrUpdateRepo() has been renamed to octokit.teams.addOrUpdateRepoLegacy() (2020-01-16)",
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      addOrUpdateRepoInOrg: {
        method: "PUT",
        params: {
          org: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo"
      },
      addOrUpdateRepoLegacy: {
        deprecated: "octokit.teams.addOrUpdateRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#add-or-update-team-repository-legacy",
        method: "PUT",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      checkManagesRepo: {
        deprecated: "octokit.teams.checkManagesRepo() has been renamed to octokit.teams.checkManagesRepoLegacy() (2020-01-16)",
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      checkManagesRepoInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo"
      },
      checkManagesRepoLegacy: {
        deprecated: "octokit.teams.checkManagesRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#check-if-a-team-manages-a-repository-legacy",
        method: "GET",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      create: {
        method: "POST",
        params: {
          description: {
            type: "string"
          },
          maintainers: {
            type: "string[]"
          },
          name: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          parent_team_id: {
            type: "integer"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          privacy: {
            enum: ["secret", "closed"],
            type: "string"
          },
          repo_names: {
            type: "string[]"
          }
        },
        url: "/orgs/:org/teams"
      },
      createDiscussion: {
        deprecated: "octokit.teams.createDiscussion() has been renamed to octokit.teams.createDiscussionLegacy() (2020-01-16)",
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/discussions"
      },
      createDiscussionComment: {
        deprecated: "octokit.teams.createDiscussionComment() has been renamed to octokit.teams.createDiscussionCommentLegacy() (2020-01-16)",
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments"
      },
      createDiscussionCommentInOrg: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments"
      },
      createDiscussionCommentLegacy: {
        deprecated: "octokit.teams.createDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#create-a-comment-legacy",
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments"
      },
      createDiscussionInOrg: {
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          team_slug: {
            required: true,
            type: "string"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions"
      },
      createDiscussionLegacy: {
        deprecated: "octokit.teams.createDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#create-a-discussion-legacy",
        method: "POST",
        params: {
          body: {
            required: true,
            type: "string"
          },
          private: {
            type: "boolean"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          title: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/discussions"
      },
      delete: {
        deprecated: "octokit.teams.delete() has been renamed to octokit.teams.deleteLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      },
      deleteDiscussion: {
        deprecated: "octokit.teams.deleteDiscussion() has been renamed to octokit.teams.deleteDiscussionLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      deleteDiscussionComment: {
        deprecated: "octokit.teams.deleteDiscussionComment() has been renamed to octokit.teams.deleteDiscussionCommentLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      deleteDiscussionCommentInOrg: {
        method: "DELETE",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number"
      },
      deleteDiscussionCommentLegacy: {
        deprecated: "octokit.teams.deleteDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#delete-a-comment-legacy",
        method: "DELETE",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      deleteDiscussionInOrg: {
        method: "DELETE",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number"
      },
      deleteDiscussionLegacy: {
        deprecated: "octokit.teams.deleteDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#delete-a-discussion-legacy",
        method: "DELETE",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      deleteInOrg: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug"
      },
      deleteLegacy: {
        deprecated: "octokit.teams.deleteLegacy() is deprecated, see https://developer.github.com/v3/teams/#delete-team-legacy",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      },
      get: {
        deprecated: "octokit.teams.get() has been renamed to octokit.teams.getLegacy() (2020-01-16)",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      },
      getByName: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug"
      },
      getDiscussion: {
        deprecated: "octokit.teams.getDiscussion() has been renamed to octokit.teams.getDiscussionLegacy() (2020-01-16)",
        method: "GET",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      getDiscussionComment: {
        deprecated: "octokit.teams.getDiscussionComment() has been renamed to octokit.teams.getDiscussionCommentLegacy() (2020-01-16)",
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      getDiscussionCommentInOrg: {
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number"
      },
      getDiscussionCommentLegacy: {
        deprecated: "octokit.teams.getDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#get-a-single-comment-legacy",
        method: "GET",
        params: {
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      getDiscussionInOrg: {
        method: "GET",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number"
      },
      getDiscussionLegacy: {
        deprecated: "octokit.teams.getDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#get-a-single-discussion-legacy",
        method: "GET",
        params: {
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      getLegacy: {
        deprecated: "octokit.teams.getLegacy() is deprecated, see https://developer.github.com/v3/teams/#get-team-legacy",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      },
      getMember: {
        deprecated: "octokit.teams.getMember() has been renamed to octokit.teams.getMemberLegacy() (2020-01-16)",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      getMemberLegacy: {
        deprecated: "octokit.teams.getMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#get-team-member-legacy",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      getMembership: {
        deprecated: "octokit.teams.getMembership() has been renamed to octokit.teams.getMembershipLegacy() (2020-01-16)",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      getMembershipInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/memberships/:username"
      },
      getMembershipLegacy: {
        deprecated: "octokit.teams.getMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#get-team-membership-legacy",
        method: "GET",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      list: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/orgs/:org/teams"
      },
      listChild: {
        deprecated: "octokit.teams.listChild() has been renamed to octokit.teams.listChildLegacy() (2020-01-16)",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/teams"
      },
      listChildInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/teams"
      },
      listChildLegacy: {
        deprecated: "octokit.teams.listChildLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-child-teams-legacy",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/teams"
      },
      listDiscussionComments: {
        deprecated: "octokit.teams.listDiscussionComments() has been renamed to octokit.teams.listDiscussionCommentsLegacy() (2020-01-16)",
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments"
      },
      listDiscussionCommentsInOrg: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments"
      },
      listDiscussionCommentsLegacy: {
        deprecated: "octokit.teams.listDiscussionCommentsLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#list-comments-legacy",
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments"
      },
      listDiscussions: {
        deprecated: "octokit.teams.listDiscussions() has been renamed to octokit.teams.listDiscussionsLegacy() (2020-01-16)",
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions"
      },
      listDiscussionsInOrg: {
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions"
      },
      listDiscussionsLegacy: {
        deprecated: "octokit.teams.listDiscussionsLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#list-discussions-legacy",
        method: "GET",
        params: {
          direction: {
            enum: ["asc", "desc"],
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions"
      },
      listForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/teams"
      },
      listMembers: {
        deprecated: "octokit.teams.listMembers() has been renamed to octokit.teams.listMembersLegacy() (2020-01-16)",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          role: {
            enum: ["member", "maintainer", "all"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/members"
      },
      listMembersInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          role: {
            enum: ["member", "maintainer", "all"],
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/members"
      },
      listMembersLegacy: {
        deprecated: "octokit.teams.listMembersLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#list-team-members-legacy",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          role: {
            enum: ["member", "maintainer", "all"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/members"
      },
      listPendingInvitations: {
        deprecated: "octokit.teams.listPendingInvitations() has been renamed to octokit.teams.listPendingInvitationsLegacy() (2020-01-16)",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/invitations"
      },
      listPendingInvitationsInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/invitations"
      },
      listPendingInvitationsLegacy: {
        deprecated: "octokit.teams.listPendingInvitationsLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#list-pending-team-invitations-legacy",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/invitations"
      },
      listProjects: {
        deprecated: "octokit.teams.listProjects() has been renamed to octokit.teams.listProjectsLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects"
      },
      listProjectsInOrg: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/projects"
      },
      listProjectsLegacy: {
        deprecated: "octokit.teams.listProjectsLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-team-projects-legacy",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects"
      },
      listRepos: {
        deprecated: "octokit.teams.listRepos() has been renamed to octokit.teams.listReposLegacy() (2020-01-16)",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos"
      },
      listReposInOrg: {
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/repos"
      },
      listReposLegacy: {
        deprecated: "octokit.teams.listReposLegacy() is deprecated, see https://developer.github.com/v3/teams/#list-team-repos-legacy",
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos"
      },
      removeMember: {
        deprecated: "octokit.teams.removeMember() has been renamed to octokit.teams.removeMemberLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      removeMemberLegacy: {
        deprecated: "octokit.teams.removeMemberLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#remove-team-member-legacy",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/members/:username"
      },
      removeMembership: {
        deprecated: "octokit.teams.removeMembership() has been renamed to octokit.teams.removeMembershipLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      removeMembershipInOrg: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/memberships/:username"
      },
      removeMembershipLegacy: {
        deprecated: "octokit.teams.removeMembershipLegacy() is deprecated, see https://developer.github.com/v3/teams/members/#remove-team-membership-legacy",
        method: "DELETE",
        params: {
          team_id: {
            required: true,
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/teams/:team_id/memberships/:username"
      },
      removeProject: {
        deprecated: "octokit.teams.removeProject() has been renamed to octokit.teams.removeProjectLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      removeProjectInOrg: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/projects/:project_id"
      },
      removeProjectLegacy: {
        deprecated: "octokit.teams.removeProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#remove-team-project-legacy",
        method: "DELETE",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      removeRepo: {
        deprecated: "octokit.teams.removeRepo() has been renamed to octokit.teams.removeRepoLegacy() (2020-01-16)",
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      removeRepoInOrg: {
        method: "DELETE",
        params: {
          org: {
            required: true,
            type: "string"
          },
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/repos/:owner/:repo"
      },
      removeRepoLegacy: {
        deprecated: "octokit.teams.removeRepoLegacy() is deprecated, see https://developer.github.com/v3/teams/#remove-team-repository-legacy",
        method: "DELETE",
        params: {
          owner: {
            required: true,
            type: "string"
          },
          repo: {
            required: true,
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/repos/:owner/:repo"
      },
      reviewProject: {
        deprecated: "octokit.teams.reviewProject() has been renamed to octokit.teams.reviewProjectLegacy() (2020-01-16)",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      reviewProjectInOrg: {
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          org: {
            required: true,
            type: "string"
          },
          project_id: {
            required: true,
            type: "integer"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/projects/:project_id"
      },
      reviewProjectLegacy: {
        deprecated: "octokit.teams.reviewProjectLegacy() is deprecated, see https://developer.github.com/v3/teams/#review-a-team-project-legacy",
        headers: {
          accept: "application/vnd.github.inertia-preview+json"
        },
        method: "GET",
        params: {
          project_id: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/projects/:project_id"
      },
      update: {
        deprecated: "octokit.teams.update() has been renamed to octokit.teams.updateLegacy() (2020-01-16)",
        method: "PATCH",
        params: {
          description: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          parent_team_id: {
            type: "integer"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          privacy: {
            enum: ["secret", "closed"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      },
      updateDiscussion: {
        deprecated: "octokit.teams.updateDiscussion() has been renamed to octokit.teams.updateDiscussionLegacy() (2020-01-16)",
        method: "PATCH",
        params: {
          body: {
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          title: {
            type: "string"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      updateDiscussionComment: {
        deprecated: "octokit.teams.updateDiscussionComment() has been renamed to octokit.teams.updateDiscussionCommentLegacy() (2020-01-16)",
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      updateDiscussionCommentInOrg: {
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number/comments/:comment_number"
      },
      updateDiscussionCommentLegacy: {
        deprecated: "octokit.teams.updateDiscussionCommentLegacy() is deprecated, see https://developer.github.com/v3/teams/discussion_comments/#edit-a-comment-legacy",
        method: "PATCH",
        params: {
          body: {
            required: true,
            type: "string"
          },
          comment_number: {
            required: true,
            type: "integer"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number/comments/:comment_number"
      },
      updateDiscussionInOrg: {
        method: "PATCH",
        params: {
          body: {
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          org: {
            required: true,
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug/discussions/:discussion_number"
      },
      updateDiscussionLegacy: {
        deprecated: "octokit.teams.updateDiscussionLegacy() is deprecated, see https://developer.github.com/v3/teams/discussions/#edit-a-discussion-legacy",
        method: "PATCH",
        params: {
          body: {
            type: "string"
          },
          discussion_number: {
            required: true,
            type: "integer"
          },
          team_id: {
            required: true,
            type: "integer"
          },
          title: {
            type: "string"
          }
        },
        url: "/teams/:team_id/discussions/:discussion_number"
      },
      updateInOrg: {
        method: "PATCH",
        params: {
          description: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          org: {
            required: true,
            type: "string"
          },
          parent_team_id: {
            type: "integer"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          privacy: {
            enum: ["secret", "closed"],
            type: "string"
          },
          team_slug: {
            required: true,
            type: "string"
          }
        },
        url: "/orgs/:org/teams/:team_slug"
      },
      updateLegacy: {
        deprecated: "octokit.teams.updateLegacy() is deprecated, see https://developer.github.com/v3/teams/#edit-team-legacy",
        method: "PATCH",
        params: {
          description: {
            type: "string"
          },
          name: {
            required: true,
            type: "string"
          },
          parent_team_id: {
            type: "integer"
          },
          permission: {
            enum: ["pull", "push", "admin"],
            type: "string"
          },
          privacy: {
            enum: ["secret", "closed"],
            type: "string"
          },
          team_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/teams/:team_id"
      }
    },
    users: {
      addEmails: {
        method: "POST",
        params: {
          emails: {
            required: true,
            type: "string[]"
          }
        },
        url: "/user/emails"
      },
      block: {
        method: "PUT",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/blocks/:username"
      },
      checkBlocked: {
        method: "GET",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/blocks/:username"
      },
      checkFollowing: {
        method: "GET",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/following/:username"
      },
      checkFollowingForUser: {
        method: "GET",
        params: {
          target_user: {
            required: true,
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/following/:target_user"
      },
      createGpgKey: {
        method: "POST",
        params: {
          armored_public_key: {
            type: "string"
          }
        },
        url: "/user/gpg_keys"
      },
      createPublicKey: {
        method: "POST",
        params: {
          key: {
            type: "string"
          },
          title: {
            type: "string"
          }
        },
        url: "/user/keys"
      },
      deleteEmails: {
        method: "DELETE",
        params: {
          emails: {
            required: true,
            type: "string[]"
          }
        },
        url: "/user/emails"
      },
      deleteGpgKey: {
        method: "DELETE",
        params: {
          gpg_key_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/gpg_keys/:gpg_key_id"
      },
      deletePublicKey: {
        method: "DELETE",
        params: {
          key_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/keys/:key_id"
      },
      follow: {
        method: "PUT",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/following/:username"
      },
      getAuthenticated: {
        method: "GET",
        params: {},
        url: "/user"
      },
      getByUsername: {
        method: "GET",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username"
      },
      getContextForUser: {
        method: "GET",
        params: {
          subject_id: {
            type: "string"
          },
          subject_type: {
            enum: ["organization", "repository", "issue", "pull_request"],
            type: "string"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/hovercard"
      },
      getGpgKey: {
        method: "GET",
        params: {
          gpg_key_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/gpg_keys/:gpg_key_id"
      },
      getPublicKey: {
        method: "GET",
        params: {
          key_id: {
            required: true,
            type: "integer"
          }
        },
        url: "/user/keys/:key_id"
      },
      list: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          since: {
            type: "string"
          }
        },
        url: "/users"
      },
      listBlocked: {
        method: "GET",
        params: {},
        url: "/user/blocks"
      },
      listEmails: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/emails"
      },
      listFollowersForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/followers"
      },
      listFollowersForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/followers"
      },
      listFollowingForAuthenticatedUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/following"
      },
      listFollowingForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/following"
      },
      listGpgKeys: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/gpg_keys"
      },
      listGpgKeysForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/gpg_keys"
      },
      listPublicEmails: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/public_emails"
      },
      listPublicKeys: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          }
        },
        url: "/user/keys"
      },
      listPublicKeysForUser: {
        method: "GET",
        params: {
          page: {
            type: "integer"
          },
          per_page: {
            type: "integer"
          },
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/users/:username/keys"
      },
      togglePrimaryEmailVisibility: {
        method: "PATCH",
        params: {
          email: {
            required: true,
            type: "string"
          },
          visibility: {
            required: true,
            type: "string"
          }
        },
        url: "/user/email/visibility"
      },
      unblock: {
        method: "DELETE",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/blocks/:username"
      },
      unfollow: {
        method: "DELETE",
        params: {
          username: {
            required: true,
            type: "string"
          }
        },
        url: "/user/following/:username"
      },
      updateAuthenticated: {
        method: "PATCH",
        params: {
          bio: {
            type: "string"
          },
          blog: {
            type: "string"
          },
          company: {
            type: "string"
          },
          email: {
            type: "string"
          },
          hireable: {
            type: "boolean"
          },
          location: {
            type: "string"
          },
          name: {
            type: "string"
          }
        },
        url: "/user"
      }
    }
  };
  
  const VERSION = "2.4.0";
  
  function registerEndpoints(octokit, routes) {
    Object.keys(routes).forEach(namespaceName => {
      if (!octokit[namespaceName]) {
        octokit[namespaceName] = {};
      }
  
      Object.keys(routes[namespaceName]).forEach(apiName => {
        const apiOptions = routes[namespaceName][apiName];
        const endpointDefaults = ["method", "url", "headers"].reduce((map, key) => {
          if (typeof apiOptions[key] !== "undefined") {
            map[key] = apiOptions[key];
          }
  
          return map;
        }, {});
        endpointDefaults.request = {
          validate: apiOptions.params
        };
        let request = octokit.request.defaults(endpointDefaults); // patch request & endpoint methods to support deprecated parameters.
        // Not the most elegant solution, but we don’t want to move deprecation
        // logic into octokit/endpoint.js as it’s out of scope
  
        const hasDeprecatedParam = Object.keys(apiOptions.params || {}).find(key => apiOptions.params[key].deprecated);
  
        if (hasDeprecatedParam) {
          const patch = patchForDeprecation.bind(null, octokit, apiOptions);
          request = patch(octokit.request.defaults(endpointDefaults), `.${namespaceName}.${apiName}()`);
          request.endpoint = patch(request.endpoint, `.${namespaceName}.${apiName}.endpoint()`);
          request.endpoint.merge = patch(request.endpoint.merge, `.${namespaceName}.${apiName}.endpoint.merge()`);
        }
  
        if (apiOptions.deprecated) {
          octokit[namespaceName][apiName] = Object.assign(function deprecatedEndpointMethod() {
            octokit.log.warn(new deprecation.Deprecation(`[@octokit/rest] ${apiOptions.deprecated}`));
            octokit[namespaceName][apiName] = request;
            return request.apply(null, arguments);
          }, request);
          return;
        }
  
        octokit[namespaceName][apiName] = request;
      });
    });
  }
  
  function patchForDeprecation(octokit, apiOptions, method, methodName) {
    const patchedMethod = options => {
      options = Object.assign({}, options);
      Object.keys(options).forEach(key => {
        if (apiOptions.params[key] && apiOptions.params[key].deprecated) {
          const aliasKey = apiOptions.params[key].alias;
          octokit.log.warn(new deprecation.Deprecation(`[@octokit/rest] "${key}" parameter is deprecated for "${methodName}". Use "${aliasKey}" instead`));
  
          if (!(aliasKey in options)) {
            options[aliasKey] = options[key];
          }
  
          delete options[key];
        }
      });
      return method(options);
    };
  
    Object.keys(method).forEach(key => {
      patchedMethod[key] = method[key];
    });
    return patchedMethod;
  }
  
  /**
   * 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) {
    // @ts-ignore
    octokit.registerEndpoints = registerEndpoints.bind(null, octokit);
    registerEndpoints(octokit, endpointsByScope); // Aliasing scopes for backward compatibility
    // See https://github.com/octokit/rest.js/pull/1134
  
    [["gitdata", "git"], ["authorization", "oauthAuthorizations"], ["pullRequests", "pulls"]].forEach(([deprecatedScope, scope]) => {
      Object.defineProperty(octokit, deprecatedScope, {
        get() {
          octokit.log.warn( // @ts-ignore
          new deprecation.Deprecation(`[@octokit/plugin-rest-endpoint-methods] "octokit.${deprecatedScope}.*" methods are deprecated, use "octokit.${scope}.*" instead`)); // @ts-ignore
  
          return octokit[scope];
        }
  
      });
    });
    return {};
  }
  restEndpointMethods.VERSION = VERSION;
  
  exports.restEndpointMethods = restEndpointMethods;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 850:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = paginationMethodsPlugin
  
  function paginationMethodsPlugin (octokit) {
    octokit.getFirstPage = __webpack_require__(777).bind(null, octokit)
    octokit.getLastPage = __webpack_require__(649).bind(null, octokit)
    octokit.getNextPage = __webpack_require__(550).bind(null, octokit)
    octokit.getPreviousPage = __webpack_require__(563).bind(null, octokit)
    octokit.hasFirstPage = __webpack_require__(536)
    octokit.hasLastPage = __webpack_require__(336)
    octokit.hasNextPage = __webpack_require__(929)
    octokit.hasPreviousPage = __webpack_require__(558)
  }
  
  
  /***/ }),
  
  /***/ 854:
  /***/ (function(module) {
  
  /**
   * lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="npm" -o ./`
   * Copyright jQuery Foundation and other contributors <https://jquery.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   */
  
  /** Used as the `TypeError` message for "Functions" methods. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0;
  
  /** `Object#toString` result references. */
  var funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      symbolTag = '[object Symbol]';
  
  /** Used to match property names within property paths. */
  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/,
      reLeadingDot = /^\./,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  
  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  
  /** Used to match backslashes in property paths. */
  var reEscapeChar = /\\(\\)?/g;
  
  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();
  
  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }
  
  /**
   * Checks if `value` is a host object in IE < 9.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
   */
  function isHostObject(value) {
    // Many host objects are `Object` objects that can coerce to strings
    // despite having improperly defined `toString` methods.
    var result = false;
    if (value != null && typeof value.toString != 'function') {
      try {
        result = !!(value + '');
      } catch (e) {}
    }
    return result;
  }
  
  /** Used for built-in method references. */
  var arrayProto = Array.prototype,
      funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to detect overreaching core-js shims. */
  var coreJsData = root['__core-js_shared__'];
  
  /** Used to detect methods masquerading as native. */
  var maskSrcKey = (function() {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
    return uid ? ('Symbol(src)_1.' + uid) : '';
  }());
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objectToString = objectProto.toString;
  
  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );
  
  /** Built-in value references. */
  var Symbol = root.Symbol,
      splice = arrayProto.splice;
  
  /* Built-in method references that are verified to be native. */
  var Map = getNative(root, 'Map'),
      nativeCreate = getNative(Object, 'create');
  
  /** Used to convert symbols to primitives and strings. */
  var symbolProto = Symbol ? Symbol.prototype : undefined,
      symbolToString = symbolProto ? symbolProto.toString : undefined;
  
  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
  }
  
  /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function hashDelete(key) {
    return this.has(key) && delete this.__data__[key];
  }
  
  /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function hashGet(key) {
    var data = this.__data__;
    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }
    return hasOwnProperty.call(data, key) ? data[key] : undefined;
  }
  
  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
  }
  
  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
    return this;
  }
  
  // Add methods to `Hash`.
  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;
  
  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
  }
  
  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    return true;
  }
  
  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    return index < 0 ? undefined : data[index][1];
  }
  
  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }
  
  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }
  
  // Add methods to `ListCache`.
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;
  
  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.__data__ = {
      'hash': new Hash,
      'map': new (Map || ListCache),
      'string': new Hash
    };
  }
  
  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    return getMapData(this, key)['delete'](key);
  }
  
  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }
  
  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }
  
  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    getMapData(this, key).set(key, value);
    return this;
  }
  
  // Add methods to `MapCache`.
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;
  
  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }
  
  /**
   * The base implementation of `_.get` without support for default values.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @returns {*} Returns the resolved value.
   */
  function baseGet(object, path) {
    path = isKey(path, object) ? [path] : castPath(path);
  
    var index = 0,
        length = path.length;
  
    while (object != null && index < length) {
      object = object[toKey(path[index++])];
    }
    return (index && index == length) ? object : undefined;
  }
  
  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }
  
  /**
   * The base implementation of `_.toString` which doesn't convert nullish
   * values to empty strings.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
  function baseToString(value) {
    // Exit early for strings to avoid a performance hit in some environments.
    if (typeof value == 'string') {
      return value;
    }
    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : '';
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  /**
   * Casts `value` to a path array if it's not one.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Array} Returns the cast property path array.
   */
  function castPath(value) {
    return isArray(value) ? value : stringToPath(value);
  }
  
  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }
  
  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }
  
  /**
   * Checks if `value` is a property name and not a property path.
   *
   * @private
   * @param {*} value The value to check.
   * @param {Object} [object] The object to query keys on.
   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
   */
  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }
    var type = typeof value;
    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
        value == null || isSymbol(value)) {
      return true;
    }
    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
      (object != null && value in Object(object));
  }
  
  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }
  
  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }
  
  /**
   * Converts `string` to a property path array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the property path array.
   */
  var stringToPath = memoize(function(string) {
    string = toString(string);
  
    var result = [];
    if (reLeadingDot.test(string)) {
      result.push('');
    }
    string.replace(rePropName, function(match, number, quote, string) {
      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    });
    return result;
  });
  
  /**
   * Converts `value` to a string key if it's not a string or symbol.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {string|symbol} Returns the key.
   */
  function toKey(value) {
    if (typeof value == 'string' || isSymbol(value)) {
      return value;
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to process.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }
  
  /**
   * Creates a function that memoizes the result of `func`. If `resolver` is
   * provided, it determines the cache key for storing the result based on the
   * arguments provided to the memoized function. By default, the first argument
   * provided to the memoized function is used as the map cache key. The `func`
   * is invoked with the `this` binding of the memoized function.
   *
   * **Note:** The cache is exposed as the `cache` property on the memoized
   * function. Its creation may be customized by replacing the `_.memoize.Cache`
   * constructor with one whose instances implement the
   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
   * method interface of `delete`, `get`, `has`, and `set`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to have its output memoized.
   * @param {Function} [resolver] The function to resolve the cache key.
   * @returns {Function} Returns the new memoized function.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   * var other = { 'c': 3, 'd': 4 };
   *
   * var values = _.memoize(_.values);
   * values(object);
   * // => [1, 2]
   *
   * values(other);
   * // => [3, 4]
   *
   * object.a = 2;
   * values(object);
   * // => [1, 2]
   *
   * // Modify the result cache.
   * values.cache.set(object, ['a', 'b']);
   * values(object);
   * // => ['a', 'b']
   *
   * // Replace `_.memoize.Cache`.
   * _.memoize.Cache = WeakMap;
   */
  function memoize(func, resolver) {
    if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var memoized = function() {
      var args = arguments,
          key = resolver ? resolver.apply(this, args) : args[0],
          cache = memoized.cache;
  
      if (cache.has(key)) {
        return cache.get(key);
      }
      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result);
      return result;
    };
    memoized.cache = new (memoize.Cache || MapCache);
    return memoized;
  }
  
  // Assign cache to `_.memoize`.
  memoize.Cache = MapCache;
  
  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }
  
  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;
  
  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 8-9 which returns 'object' for typed array and other constructors.
    var tag = isObject(value) ? objectToString.call(value) : '';
    return tag == funcTag || tag == genTag;
  }
  
  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return !!value && (type == 'object' || type == 'function');
  }
  
  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return !!value && typeof value == 'object';
  }
  
  /**
   * Checks if `value` is classified as a `Symbol` primitive or object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
   * @example
   *
   * _.isSymbol(Symbol.iterator);
   * // => true
   *
   * _.isSymbol('abc');
   * // => false
   */
  function isSymbol(value) {
    return typeof value == 'symbol' ||
      (isObjectLike(value) && objectToString.call(value) == symbolTag);
  }
  
  /**
   * Converts `value` to a string. An empty string is returned for `null`
   * and `undefined` values. The sign of `-0` is preserved.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   * @example
   *
   * _.toString(null);
   * // => ''
   *
   * _.toString(-0);
   * // => '-0'
   *
   * _.toString([1, 2, 3]);
   * // => '1,2,3'
   */
  function toString(value) {
    return value == null ? '' : baseToString(value);
  }
  
  /**
   * Gets the value at `path` of `object`. If the resolved value is
   * `undefined`, the `defaultValue` is returned in its place.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.get(object, 'a[0].b.c');
   * // => 3
   *
   * _.get(object, ['a', '0', 'b', 'c']);
   * // => 3
   *
   * _.get(object, 'a.b.c', 'default');
   * // => 'default'
   */
  function get(object, path, defaultValue) {
    var result = object == null ? undefined : baseGet(object, path);
    return result === undefined ? defaultValue : result;
  }
  
  module.exports = get;
  
  
  /***/ }),
  
  /***/ 855:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = registerPlugin;
  
  const factory = __webpack_require__(47);
  
  function registerPlugin(plugins, pluginFunction) {
    return factory(
      plugins.includes(pluginFunction) ? plugins : plugins.concat(pluginFunction)
    );
  }
  
  
  /***/ }),
  
  /***/ 856:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = __webpack_require__(141);
  
  
  /***/ }),
  
  /***/ 860:
  /***/ (function(module, exports) {
  
  
  exports = module.exports = trim;
  
  function trim(str){
    return str.replace(/^\s*|\s*$/g, '');
  }
  
  exports.left = function(str){
    return str.replace(/^\s*/, '');
  };
  
  exports.right = function(str){
    return str.replace(/\s*$/, '');
  };
  
  
  /***/ }),
  
  /***/ 863:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = authenticationBeforeRequest;
  
  const btoa = __webpack_require__(675);
  
  const withAuthorizationPrefix = __webpack_require__(143);
  
  function authenticationBeforeRequest(state, options) {
    if (typeof state.auth === "string") {
      options.headers.authorization = withAuthorizationPrefix(state.auth);
      return;
    }
  
    if (state.auth.username) {
      const hash = btoa(`${state.auth.username}:${state.auth.password}`);
      options.headers.authorization = `Basic ${hash}`;
      if (state.otp) {
        options.headers["x-github-otp"] = state.otp;
      }
      return;
    }
  
    if (state.auth.clientId) {
      // There is a special case for OAuth applications, when `clientId` and `clientSecret` is passed as
      // Basic Authorization instead of query parameters. The only routes where that applies share the same
      // URL though: `/applications/:client_id/tokens/:access_token`.
      //
      //  1. [Check an authorization](https://developer.github.com/v3/oauth_authorizations/#check-an-authorization)
      //  2. [Reset an authorization](https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization)
      //  3. [Revoke an authorization for an application](https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application)
      //
      // We identify by checking the URL. It must merge both "/applications/:client_id/tokens/:access_token"
      // as well as "/applications/123/tokens/token456"
      if (/\/applications\/:?[\w_]+\/tokens\/:?[\w_]+($|\?)/.test(options.url)) {
        const hash = btoa(`${state.auth.clientId}:${state.auth.clientSecret}`);
        options.headers.authorization = `Basic ${hash}`;
        return;
      }
  
      options.url += options.url.indexOf("?") === -1 ? "?" : "&";
      options.url += `client_id=${state.auth.clientId}&client_secret=${state.auth.clientSecret}`;
      return;
    }
  
    return Promise.resolve()
  
      .then(() => {
        return state.auth();
      })
  
      .then(authorization => {
        options.headers.authorization = withAuthorizationPrefix(authorization);
      });
  }
  
  
  /***/ }),
  
  /***/ 866:
  /***/ (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 : '')
  	);
  };
  
  
  /***/ }),
  
  /***/ 881:
  /***/ (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,
  };
  
  
  /***/ }),
  
  /***/ 882:
  /***/ (function(module) {
  
  "use strict";
  
  
  module.exports = trimLines
  
  var ws = /[ \t]*\n+[ \t]*/g
  var newline = '\n'
  
  function trimLines(value) {
    return String(value).replace(ws, newline)
  }
  
  
  /***/ }),
  
  /***/ 883:
  /***/ (function(module) {
  
  /**
   * lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="npm" -o ./`
   * Copyright jQuery Foundation and other contributors <https://jquery.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   */
  
  /** Used as the `TypeError` message for "Functions" methods. */
  var FUNC_ERROR_TEXT = 'Expected a function';
  
  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  
  /** Used as references for various `Number` constants. */
  var INFINITY = 1 / 0,
      MAX_SAFE_INTEGER = 9007199254740991;
  
  /** `Object#toString` result references. */
  var funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      symbolTag = '[object Symbol]';
  
  /** Used to match property names within property paths. */
  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/,
      reLeadingDot = /^\./,
      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  
  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  
  /** Used to match backslashes in property paths. */
  var reEscapeChar = /\\(\\)?/g;
  
  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  
  /** Used to detect unsigned integer values. */
  var reIsUint = /^(?:0|[1-9]\d*)$/;
  
  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();
  
  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }
  
  /**
   * Checks if `value` is a host object in IE < 9.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
   */
  function isHostObject(value) {
    // Many host objects are `Object` objects that can coerce to strings
    // despite having improperly defined `toString` methods.
    var result = false;
    if (value != null && typeof value.toString != 'function') {
      try {
        result = !!(value + '');
      } catch (e) {}
    }
    return result;
  }
  
  /** Used for built-in method references. */
  var arrayProto = Array.prototype,
      funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to detect overreaching core-js shims. */
  var coreJsData = root['__core-js_shared__'];
  
  /** Used to detect methods masquerading as native. */
  var maskSrcKey = (function() {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
    return uid ? ('Symbol(src)_1.' + uid) : '';
  }());
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var objectToString = objectProto.toString;
  
  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );
  
  /** Built-in value references. */
  var Symbol = root.Symbol,
      splice = arrayProto.splice;
  
  /* Built-in method references that are verified to be native. */
  var Map = getNative(root, 'Map'),
      nativeCreate = getNative(Object, 'create');
  
  /** Used to convert symbols to primitives and strings. */
  var symbolProto = Symbol ? Symbol.prototype : undefined,
      symbolToString = symbolProto ? symbolProto.toString : undefined;
  
  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
  }
  
  /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function hashDelete(key) {
    return this.has(key) && delete this.__data__[key];
  }
  
  /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function hashGet(key) {
    var data = this.__data__;
    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }
    return hasOwnProperty.call(data, key) ? data[key] : undefined;
  }
  
  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
  }
  
  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
    return this;
  }
  
  // Add methods to `Hash`.
  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;
  
  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
  }
  
  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    return true;
  }
  
  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    return index < 0 ? undefined : data[index][1];
  }
  
  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }
  
  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
  
    if (index < 0) {
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }
  
  // Add methods to `ListCache`.
  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;
  
  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries ? entries.length : 0;
  
    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }
  
  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.__data__ = {
      'hash': new Hash,
      'map': new (Map || ListCache),
      'string': new Hash
    };
  }
  
  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    return getMapData(this, key)['delete'](key);
  }
  
  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }
  
  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }
  
  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    getMapData(this, key).set(key, value);
    return this;
  }
  
  // Add methods to `MapCache`.
  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;
  
  /**
   * Assigns `value` to `key` of `object` if the existing value is not equivalent
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignValue(object, key, value) {
    var objValue = object[key];
    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
        (value === undefined && !(key in object))) {
      object[key] = value;
    }
  }
  
  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }
  
  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }
    var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }
  
  /**
   * The base implementation of `_.set`.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @param {Function} [customizer] The function to customize path creation.
   * @returns {Object} Returns `object`.
   */
  function baseSet(object, path, value, customizer) {
    if (!isObject(object)) {
      return object;
    }
    path = isKey(path, object) ? [path] : castPath(path);
  
    var index = -1,
        length = path.length,
        lastIndex = length - 1,
        nested = object;
  
    while (nested != null && ++index < length) {
      var key = toKey(path[index]),
          newValue = value;
  
      if (index != lastIndex) {
        var objValue = nested[key];
        newValue = customizer ? customizer(objValue, key, nested) : undefined;
        if (newValue === undefined) {
          newValue = isObject(objValue)
            ? objValue
            : (isIndex(path[index + 1]) ? [] : {});
        }
      }
      assignValue(nested, key, newValue);
      nested = nested[key];
    }
    return object;
  }
  
  /**
   * The base implementation of `_.toString` which doesn't convert nullish
   * values to empty strings.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
  function baseToString(value) {
    // Exit early for strings to avoid a performance hit in some environments.
    if (typeof value == 'string') {
      return value;
    }
    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : '';
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  /**
   * Casts `value` to a path array if it's not one.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Array} Returns the cast property path array.
   */
  function castPath(value) {
    return isArray(value) ? value : stringToPath(value);
  }
  
  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }
  
  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }
  
  /**
   * Checks if `value` is a valid array-like index.
   *
   * @private
   * @param {*} value The value to check.
   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
   */
  function isIndex(value, length) {
    length = length == null ? MAX_SAFE_INTEGER : length;
    return !!length &&
      (typeof value == 'number' || reIsUint.test(value)) &&
      (value > -1 && value % 1 == 0 && value < length);
  }
  
  /**
   * Checks if `value` is a property name and not a property path.
   *
   * @private
   * @param {*} value The value to check.
   * @param {Object} [object] The object to query keys on.
   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
   */
  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }
    var type = typeof value;
    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
        value == null || isSymbol(value)) {
      return true;
    }
    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
      (object != null && value in Object(object));
  }
  
  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }
  
  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }
  
  /**
   * Converts `string` to a property path array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the property path array.
   */
  var stringToPath = memoize(function(string) {
    string = toString(string);
  
    var result = [];
    if (reLeadingDot.test(string)) {
      result.push('');
    }
    string.replace(rePropName, function(match, number, quote, string) {
      result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
    });
    return result;
  });
  
  /**
   * Converts `value` to a string key if it's not a string or symbol.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {string|symbol} Returns the key.
   */
  function toKey(value) {
    if (typeof value == 'string' || isSymbol(value)) {
      return value;
    }
    var result = (value + '');
    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  }
  
  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to process.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }
  
  /**
   * Creates a function that memoizes the result of `func`. If `resolver` is
   * provided, it determines the cache key for storing the result based on the
   * arguments provided to the memoized function. By default, the first argument
   * provided to the memoized function is used as the map cache key. The `func`
   * is invoked with the `this` binding of the memoized function.
   *
   * **Note:** The cache is exposed as the `cache` property on the memoized
   * function. Its creation may be customized by replacing the `_.memoize.Cache`
   * constructor with one whose instances implement the
   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
   * method interface of `delete`, `get`, `has`, and `set`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to have its output memoized.
   * @param {Function} [resolver] The function to resolve the cache key.
   * @returns {Function} Returns the new memoized function.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   * var other = { 'c': 3, 'd': 4 };
   *
   * var values = _.memoize(_.values);
   * values(object);
   * // => [1, 2]
   *
   * values(other);
   * // => [3, 4]
   *
   * object.a = 2;
   * values(object);
   * // => [1, 2]
   *
   * // Modify the result cache.
   * values.cache.set(object, ['a', 'b']);
   * values(object);
   * // => ['a', 'b']
   *
   * // Replace `_.memoize.Cache`.
   * _.memoize.Cache = WeakMap;
   */
  function memoize(func, resolver) {
    if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
      throw new TypeError(FUNC_ERROR_TEXT);
    }
    var memoized = function() {
      var args = arguments,
          key = resolver ? resolver.apply(this, args) : args[0],
          cache = memoized.cache;
  
      if (cache.has(key)) {
        return cache.get(key);
      }
      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result);
      return result;
    };
    memoized.cache = new (memoize.Cache || MapCache);
    return memoized;
  }
  
  // Assign cache to `_.memoize`.
  memoize.Cache = MapCache;
  
  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }
  
  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;
  
  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 8-9 which returns 'object' for typed array and other constructors.
    var tag = isObject(value) ? objectToString.call(value) : '';
    return tag == funcTag || tag == genTag;
  }
  
  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return !!value && (type == 'object' || type == 'function');
  }
  
  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return !!value && typeof value == 'object';
  }
  
  /**
   * Checks if `value` is classified as a `Symbol` primitive or object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
   * @example
   *
   * _.isSymbol(Symbol.iterator);
   * // => true
   *
   * _.isSymbol('abc');
   * // => false
   */
  function isSymbol(value) {
    return typeof value == 'symbol' ||
      (isObjectLike(value) && objectToString.call(value) == symbolTag);
  }
  
  /**
   * Converts `value` to a string. An empty string is returned for `null`
   * and `undefined` values. The sign of `-0` is preserved.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   * @example
   *
   * _.toString(null);
   * // => ''
   *
   * _.toString(-0);
   * // => '-0'
   *
   * _.toString([1, 2, 3]);
   * // => '1,2,3'
   */
  function toString(value) {
    return value == null ? '' : baseToString(value);
  }
  
  /**
   * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
   * it's created. Arrays are created for missing index properties while objects
   * are created for all other missing properties. Use `_.setWith` to customize
   * `path` creation.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to modify.
   * @param {Array|string} path The path of the property to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.set(object, 'a[0].b.c', 4);
   * console.log(object.a[0].b.c);
   * // => 4
   *
   * _.set(object, ['x', '0', 'y', 'z'], 5);
   * console.log(object.x[0].y.z);
   * // => 5
   */
  function set(object, path, value) {
    return object == null ? object : baseSet(object, path, value);
  }
  
  module.exports = set;
  
  
  /***/ }),
  
  /***/ 898:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var request = __webpack_require__(753);
  var universalUserAgent = __webpack_require__(796);
  
  const VERSION = "4.5.1";
  
  class GraphqlError extends Error {
    constructor(request, response) {
      const message = response.data.errors[0].message;
      super(message);
      Object.assign(this, response.data);
      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"];
  function graphql(request, query, options) {
    options = typeof query === "string" ? options = Object.assign({
      query
    }, options) : options = query;
    const requestOptions = Object.keys(options).reduce((result, key) => {
      if (NON_VARIABLE_OPTIONS.includes(key)) {
        result[key] = options[key];
        return result;
      }
  
      if (!result.variables) {
        result.variables = {};
      }
  
      result.variables[key] = options[key];
      return result;
    }, {});
    return request(requestOptions).then(response => {
      if (response.data.errors) {
        throw new GraphqlError(requestOptions, {
          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
  
  
  /***/ }),
  
  /***/ 903:
  /***/ (function(module, exports, __webpack_require__) {
  
  /* module decorator */ module = __webpack_require__.nmd(module);
  /*! http://mths.be/he v0.5.0 by @mathias | MIT license */
  ;(function(root) {
  
  	// Detect free variables `exports`.
  	var freeExports =  true && exports;
  
  	// Detect free variable `module`.
  	var freeModule =  true && module &&
  		module.exports == freeExports && module;
  
  	// Detect free variable `global`, from Node.js or Browserified code,
  	// and use it as `root`.
  	var freeGlobal = typeof global == 'object' && global;
  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
  		root = freeGlobal;
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	// All astral symbols.
  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  	// All ASCII symbols (not just printable ASCII) except those listed in the
  	// first column of the overrides table.
  	// http://whatwg.org/html/tokenization.html#table-charref-overrides
  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
  	// code points listed in the first column of the overrides table on
  	// http://whatwg.org/html/tokenization.html#table-charref-overrides.
  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
  
  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
  	var encodeMap = {'\xC1':'Aacute','\xE1':'aacute','\u0102':'Abreve','\u0103':'abreve','\u223E':'ac','\u223F':'acd','\u223E\u0333':'acE','\xC2':'Acirc','\xE2':'acirc','\xB4':'acute','\u0410':'Acy','\u0430':'acy','\xC6':'AElig','\xE6':'aelig','\u2061':'af','\uD835\uDD04':'Afr','\uD835\uDD1E':'afr','\xC0':'Agrave','\xE0':'agrave','\u2135':'aleph','\u0391':'Alpha','\u03B1':'alpha','\u0100':'Amacr','\u0101':'amacr','\u2A3F':'amalg','&':'amp','\u2A55':'andand','\u2A53':'And','\u2227':'and','\u2A5C':'andd','\u2A58':'andslope','\u2A5A':'andv','\u2220':'ang','\u29A4':'ange','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u2221':'angmsd','\u221F':'angrt','\u22BE':'angrtvb','\u299D':'angrtvbd','\u2222':'angsph','\xC5':'angst','\u237C':'angzarr','\u0104':'Aogon','\u0105':'aogon','\uD835\uDD38':'Aopf','\uD835\uDD52':'aopf','\u2A6F':'apacir','\u2248':'ap','\u2A70':'apE','\u224A':'ape','\u224B':'apid','\'':'apos','\xE5':'aring','\uD835\uDC9C':'Ascr','\uD835\uDCB6':'ascr','\u2254':'colone','*':'ast','\u224D':'CupCap','\xC3':'Atilde','\xE3':'atilde','\xC4':'Auml','\xE4':'auml','\u2233':'awconint','\u2A11':'awint','\u224C':'bcong','\u03F6':'bepsi','\u2035':'bprime','\u223D':'bsim','\u22CD':'bsime','\u2216':'setmn','\u2AE7':'Barv','\u22BD':'barvee','\u2305':'barwed','\u2306':'Barwed','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u0411':'Bcy','\u0431':'bcy','\u201E':'bdquo','\u2235':'becaus','\u29B0':'bemptyv','\u212C':'Bscr','\u0392':'Beta','\u03B2':'beta','\u2136':'beth','\u226C':'twixt','\uD835\uDD05':'Bfr','\uD835\uDD1F':'bfr','\u22C2':'xcap','\u25EF':'xcirc','\u22C3':'xcup','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A06':'xsqcup','\u2605':'starf','\u25BD':'xdtri','\u25B3':'xutri','\u2A04':'xuplus','\u22C1':'Vee','\u22C0':'Wedge','\u290D':'rbarr','\u29EB':'lozf','\u25AA':'squf','\u25B4':'utrif','\u25BE':'dtrif','\u25C2':'ltrif','\u25B8':'rtrif','\u2423':'blank','\u2592':'blk12','\u2591':'blk14','\u2593':'blk34','\u2588':'block','=\u20E5':'bne','\u2261\u20E5':'bnequiv','\u2AED':'bNot','\u2310':'bnot','\uD835\uDD39':'Bopf','\uD835\uDD53':'bopf','\u22A5':'bot','\u22C8':'bowtie','\u29C9':'boxbox','\u2510':'boxdl','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u250C':'boxdr','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2500':'boxh','\u2550':'boxH','\u252C':'boxhd','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2534':'boxhu','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u229F':'minusb','\u229E':'plusb','\u22A0':'timesb','\u2518':'boxul','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u2514':'boxur','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u2502':'boxv','\u2551':'boxV','\u253C':'boxvh','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2524':'boxvl','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u251C':'boxvr','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u02D8':'breve','\xA6':'brvbar','\uD835\uDCB7':'bscr','\u204F':'bsemi','\u29C5':'bsolb','\\':'bsol','\u27C8':'bsolhsub','\u2022':'bull','\u224E':'bump','\u2AAE':'bumpE','\u224F':'bumpe','\u0106':'Cacute','\u0107':'cacute','\u2A44':'capand','\u2A49':'capbrcup','\u2A4B':'capcap','\u2229':'cap','\u22D2':'Cap','\u2A47':'capcup','\u2A40':'capdot','\u2145':'DD','\u2229\uFE00':'caps','\u2041':'caret','\u02C7':'caron','\u212D':'Cfr','\u2A4D':'ccaps','\u010C':'Ccaron','\u010D':'ccaron','\xC7':'Ccedil','\xE7':'ccedil','\u0108':'Ccirc','\u0109':'ccirc','\u2230':'Cconint','\u2A4C':'ccups','\u2A50':'ccupssm','\u010A':'Cdot','\u010B':'cdot','\xB8':'cedil','\u29B2':'cemptyv','\xA2':'cent','\xB7':'middot','\uD835\uDD20':'cfr','\u0427':'CHcy','\u0447':'chcy','\u2713':'check','\u03A7':'Chi','\u03C7':'chi','\u02C6':'circ','\u2257':'cire','\u21BA':'olarr','\u21BB':'orarr','\u229B':'oast','\u229A':'ocir','\u229D':'odash','\u2299':'odot','\xAE':'reg','\u24C8':'oS','\u2296':'ominus','\u2295':'oplus','\u2297':'otimes','\u25CB':'cir','\u29C3':'cirE','\u2A10':'cirfnint','\u2AEF':'cirmid','\u29C2':'cirscir','\u2232':'cwconint','\u201D':'rdquo','\u2019':'rsquo','\u2663':'clubs',':':'colon','\u2237':'Colon','\u2A74':'Colone',',':'comma','@':'commat','\u2201':'comp','\u2218':'compfn','\u2102':'Copf','\u2245':'cong','\u2A6D':'congdot','\u2261':'equiv','\u222E':'oint','\u222F':'Conint','\uD835\uDD54':'copf','\u2210':'coprod','\xA9':'copy','\u2117':'copysr','\u21B5':'crarr','\u2717':'cross','\u2A2F':'Cross','\uD835\uDC9E':'Cscr','\uD835\uDCB8':'cscr','\u2ACF':'csub','\u2AD1':'csube','\u2AD0':'csup','\u2AD2':'csupe','\u22EF':'ctdot','\u2938':'cudarrl','\u2935':'cudarrr','\u22DE':'cuepr','\u22DF':'cuesc','\u21B6':'cularr','\u293D':'cularrp','\u2A48':'cupbrcap','\u2A46':'cupcap','\u222A':'cup','\u22D3':'Cup','\u2A4A':'cupcup','\u228D':'cupdot','\u2A45':'cupor','\u222A\uFE00':'cups','\u21B7':'curarr','\u293C':'curarrm','\u22CE':'cuvee','\u22CF':'cuwed','\xA4':'curren','\u2231':'cwint','\u232D':'cylcty','\u2020':'dagger','\u2021':'Dagger','\u2138':'daleth','\u2193':'darr','\u21A1':'Darr','\u21D3':'dArr','\u2010':'dash','\u2AE4':'Dashv','\u22A3':'dashv','\u290F':'rBarr','\u02DD':'dblac','\u010E':'Dcaron','\u010F':'dcaron','\u0414':'Dcy','\u0434':'dcy','\u21CA':'ddarr','\u2146':'dd','\u2911':'DDotrahd','\u2A77':'eDDot','\xB0':'deg','\u2207':'Del','\u0394':'Delta','\u03B4':'delta','\u29B1':'demptyv','\u297F':'dfisht','\uD835\uDD07':'Dfr','\uD835\uDD21':'dfr','\u2965':'dHar','\u21C3':'dharl','\u21C2':'dharr','\u02D9':'dot','`':'grave','\u02DC':'tilde','\u22C4':'diam','\u2666':'diams','\xA8':'die','\u03DD':'gammad','\u22F2':'disin','\xF7':'div','\u22C7':'divonx','\u0402':'DJcy','\u0452':'djcy','\u231E':'dlcorn','\u230D':'dlcrop','$':'dollar','\uD835\uDD3B':'Dopf','\uD835\uDD55':'dopf','\u20DC':'DotDot','\u2250':'doteq','\u2251':'eDot','\u2238':'minusd','\u2214':'plusdo','\u22A1':'sdotb','\u21D0':'lArr','\u21D4':'iff','\u27F8':'xlArr','\u27FA':'xhArr','\u27F9':'xrArr','\u21D2':'rArr','\u22A8':'vDash','\u21D1':'uArr','\u21D5':'vArr','\u2225':'par','\u2913':'DownArrowBar','\u21F5':'duarr','\u0311':'DownBreve','\u2950':'DownLeftRightVector','\u295E':'DownLeftTeeVector','\u2956':'DownLeftVectorBar','\u21BD':'lhard','\u295F':'DownRightTeeVector','\u2957':'DownRightVectorBar','\u21C1':'rhard','\u21A7':'mapstodown','\u22A4':'top','\u2910':'RBarr','\u231F':'drcorn','\u230C':'drcrop','\uD835\uDC9F':'Dscr','\uD835\uDCB9':'dscr','\u0405':'DScy','\u0455':'dscy','\u29F6':'dsol','\u0110':'Dstrok','\u0111':'dstrok','\u22F1':'dtdot','\u25BF':'dtri','\u296F':'duhar','\u29A6':'dwangle','\u040F':'DZcy','\u045F':'dzcy','\u27FF':'dzigrarr','\xC9':'Eacute','\xE9':'eacute','\u2A6E':'easter','\u011A':'Ecaron','\u011B':'ecaron','\xCA':'Ecirc','\xEA':'ecirc','\u2256':'ecir','\u2255':'ecolon','\u042D':'Ecy','\u044D':'ecy','\u0116':'Edot','\u0117':'edot','\u2147':'ee','\u2252':'efDot','\uD835\uDD08':'Efr','\uD835\uDD22':'efr','\u2A9A':'eg','\xC8':'Egrave','\xE8':'egrave','\u2A96':'egs','\u2A98':'egsdot','\u2A99':'el','\u2208':'in','\u23E7':'elinters','\u2113':'ell','\u2A95':'els','\u2A97':'elsdot','\u0112':'Emacr','\u0113':'emacr','\u2205':'empty','\u25FB':'EmptySmallSquare','\u25AB':'EmptyVerySmallSquare','\u2004':'emsp13','\u2005':'emsp14','\u2003':'emsp','\u014A':'ENG','\u014B':'eng','\u2002':'ensp','\u0118':'Eogon','\u0119':'eogon','\uD835\uDD3C':'Eopf','\uD835\uDD56':'eopf','\u22D5':'epar','\u29E3':'eparsl','\u2A71':'eplus','\u03B5':'epsi','\u0395':'Epsilon','\u03F5':'epsiv','\u2242':'esim','\u2A75':'Equal','=':'equals','\u225F':'equest','\u21CC':'rlhar','\u2A78':'equivDD','\u29E5':'eqvparsl','\u2971':'erarr','\u2253':'erDot','\u212F':'escr','\u2130':'Escr','\u2A73':'Esim','\u0397':'Eta','\u03B7':'eta','\xD0':'ETH','\xF0':'eth','\xCB':'Euml','\xEB':'euml','\u20AC':'euro','!':'excl','\u2203':'exist','\u0424':'Fcy','\u0444':'fcy','\u2640':'female','\uFB03':'ffilig','\uFB00':'fflig','\uFB04':'ffllig','\uD835\uDD09':'Ffr','\uD835\uDD23':'ffr','\uFB01':'filig','\u25FC':'FilledSmallSquare','fj':'fjlig','\u266D':'flat','\uFB02':'fllig','\u25B1':'fltns','\u0192':'fnof','\uD835\uDD3D':'Fopf','\uD835\uDD57':'fopf','\u2200':'forall','\u22D4':'fork','\u2AD9':'forkv','\u2131':'Fscr','\u2A0D':'fpartint','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\u2154':'frac23','\u2156':'frac25','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\u2044':'frasl','\u2322':'frown','\uD835\uDCBB':'fscr','\u01F5':'gacute','\u0393':'Gamma','\u03B3':'gamma','\u03DC':'Gammad','\u2A86':'gap','\u011E':'Gbreve','\u011F':'gbreve','\u0122':'Gcedil','\u011C':'Gcirc','\u011D':'gcirc','\u0413':'Gcy','\u0433':'gcy','\u0120':'Gdot','\u0121':'gdot','\u2265':'ge','\u2267':'gE','\u2A8C':'gEl','\u22DB':'gel','\u2A7E':'ges','\u2AA9':'gescc','\u2A80':'gesdot','\u2A82':'gesdoto','\u2A84':'gesdotol','\u22DB\uFE00':'gesl','\u2A94':'gesles','\uD835\uDD0A':'Gfr','\uD835\uDD24':'gfr','\u226B':'gg','\u22D9':'Gg','\u2137':'gimel','\u0403':'GJcy','\u0453':'gjcy','\u2AA5':'gla','\u2277':'gl','\u2A92':'glE','\u2AA4':'glj','\u2A8A':'gnap','\u2A88':'gne','\u2269':'gnE','\u22E7':'gnsim','\uD835\uDD3E':'Gopf','\uD835\uDD58':'gopf','\u2AA2':'GreaterGreater','\u2273':'gsim','\uD835\uDCA2':'Gscr','\u210A':'gscr','\u2A8E':'gsime','\u2A90':'gsiml','\u2AA7':'gtcc','\u2A7A':'gtcir','>':'gt','\u22D7':'gtdot','\u2995':'gtlPar','\u2A7C':'gtquest','\u2978':'gtrarr','\u2269\uFE00':'gvnE','\u200A':'hairsp','\u210B':'Hscr','\u042A':'HARDcy','\u044A':'hardcy','\u2948':'harrcir','\u2194':'harr','\u21AD':'harrw','^':'Hat','\u210F':'hbar','\u0124':'Hcirc','\u0125':'hcirc','\u2665':'hearts','\u2026':'mldr','\u22B9':'hercon','\uD835\uDD25':'hfr','\u210C':'Hfr','\u2925':'searhk','\u2926':'swarhk','\u21FF':'hoarr','\u223B':'homtht','\u21A9':'larrhk','\u21AA':'rarrhk','\uD835\uDD59':'hopf','\u210D':'Hopf','\u2015':'horbar','\uD835\uDCBD':'hscr','\u0126':'Hstrok','\u0127':'hstrok','\u2043':'hybull','\xCD':'Iacute','\xED':'iacute','\u2063':'ic','\xCE':'Icirc','\xEE':'icirc','\u0418':'Icy','\u0438':'icy','\u0130':'Idot','\u0415':'IEcy','\u0435':'iecy','\xA1':'iexcl','\uD835\uDD26':'ifr','\u2111':'Im','\xCC':'Igrave','\xEC':'igrave','\u2148':'ii','\u2A0C':'qint','\u222D':'tint','\u29DC':'iinfin','\u2129':'iiota','\u0132':'IJlig','\u0133':'ijlig','\u012A':'Imacr','\u012B':'imacr','\u2110':'Iscr','\u0131':'imath','\u22B7':'imof','\u01B5':'imped','\u2105':'incare','\u221E':'infin','\u29DD':'infintie','\u22BA':'intcal','\u222B':'int','\u222C':'Int','\u2124':'Zopf','\u2A17':'intlarhk','\u2A3C':'iprod','\u2062':'it','\u0401':'IOcy','\u0451':'iocy','\u012E':'Iogon','\u012F':'iogon','\uD835\uDD40':'Iopf','\uD835\uDD5A':'iopf','\u0399':'Iota','\u03B9':'iota','\xBF':'iquest','\uD835\uDCBE':'iscr','\u22F5':'isindot','\u22F9':'isinE','\u22F4':'isins','\u22F3':'isinsv','\u0128':'Itilde','\u0129':'itilde','\u0406':'Iukcy','\u0456':'iukcy','\xCF':'Iuml','\xEF':'iuml','\u0134':'Jcirc','\u0135':'jcirc','\u0419':'Jcy','\u0439':'jcy','\uD835\uDD0D':'Jfr','\uD835\uDD27':'jfr','\u0237':'jmath','\uD835\uDD41':'Jopf','\uD835\uDD5B':'jopf','\uD835\uDCA5':'Jscr','\uD835\uDCBF':'jscr','\u0408':'Jsercy','\u0458':'jsercy','\u0404':'Jukcy','\u0454':'jukcy','\u039A':'Kappa','\u03BA':'kappa','\u03F0':'kappav','\u0136':'Kcedil','\u0137':'kcedil','\u041A':'Kcy','\u043A':'kcy','\uD835\uDD0E':'Kfr','\uD835\uDD28':'kfr','\u0138':'kgreen','\u0425':'KHcy','\u0445':'khcy','\u040C':'KJcy','\u045C':'kjcy','\uD835\uDD42':'Kopf','\uD835\uDD5C':'kopf','\uD835\uDCA6':'Kscr','\uD835\uDCC0':'kscr','\u21DA':'lAarr','\u0139':'Lacute','\u013A':'lacute','\u29B4':'laemptyv','\u2112':'Lscr','\u039B':'Lambda','\u03BB':'lambda','\u27E8':'lang','\u27EA':'Lang','\u2991':'langd','\u2A85':'lap','\xAB':'laquo','\u21E4':'larrb','\u291F':'larrbfs','\u2190':'larr','\u219E':'Larr','\u291D':'larrfs','\u21AB':'larrlp','\u2939':'larrpl','\u2973':'larrsim','\u21A2':'larrtl','\u2919':'latail','\u291B':'lAtail','\u2AAB':'lat','\u2AAD':'late','\u2AAD\uFE00':'lates','\u290C':'lbarr','\u290E':'lBarr','\u2772':'lbbrk','{':'lcub','[':'lsqb','\u298B':'lbrke','\u298F':'lbrksld','\u298D':'lbrkslu','\u013D':'Lcaron','\u013E':'lcaron','\u013B':'Lcedil','\u013C':'lcedil','\u2308':'lceil','\u041B':'Lcy','\u043B':'lcy','\u2936':'ldca','\u201C':'ldquo','\u2967':'ldrdhar','\u294B':'ldrushar','\u21B2':'ldsh','\u2264':'le','\u2266':'lE','\u21C6':'lrarr','\u27E6':'lobrk','\u2961':'LeftDownTeeVector','\u2959':'LeftDownVectorBar','\u230A':'lfloor','\u21BC':'lharu','\u21C7':'llarr','\u21CB':'lrhar','\u294E':'LeftRightVector','\u21A4':'mapstoleft','\u295A':'LeftTeeVector','\u22CB':'lthree','\u29CF':'LeftTriangleBar','\u22B2':'vltri','\u22B4':'ltrie','\u2951':'LeftUpDownVector','\u2960':'LeftUpTeeVector','\u2958':'LeftUpVectorBar','\u21BF':'uharl','\u2952':'LeftVectorBar','\u2A8B':'lEg','\u22DA':'leg','\u2A7D':'les','\u2AA8':'lescc','\u2A7F':'lesdot','\u2A81':'lesdoto','\u2A83':'lesdotor','\u22DA\uFE00':'lesg','\u2A93':'lesges','\u22D6':'ltdot','\u2276':'lg','\u2AA1':'LessLess','\u2272':'lsim','\u297C':'lfisht','\uD835\uDD0F':'Lfr','\uD835\uDD29':'lfr','\u2A91':'lgE','\u2962':'lHar','\u296A':'lharul','\u2584':'lhblk','\u0409':'LJcy','\u0459':'ljcy','\u226A':'ll','\u22D8':'Ll','\u296B':'llhard','\u25FA':'lltri','\u013F':'Lmidot','\u0140':'lmidot','\u23B0':'lmoust','\u2A89':'lnap','\u2A87':'lne','\u2268':'lnE','\u22E6':'lnsim','\u27EC':'loang','\u21FD':'loarr','\u27F5':'xlarr','\u27F7':'xharr','\u27FC':'xmap','\u27F6':'xrarr','\u21AC':'rarrlp','\u2985':'lopar','\uD835\uDD43':'Lopf','\uD835\uDD5D':'lopf','\u2A2D':'loplus','\u2A34':'lotimes','\u2217':'lowast','_':'lowbar','\u2199':'swarr','\u2198':'searr','\u25CA':'loz','(':'lpar','\u2993':'lparlt','\u296D':'lrhard','\u200E':'lrm','\u22BF':'lrtri','\u2039':'lsaquo','\uD835\uDCC1':'lscr','\u21B0':'lsh','\u2A8D':'lsime','\u2A8F':'lsimg','\u2018':'lsquo','\u201A':'sbquo','\u0141':'Lstrok','\u0142':'lstrok','\u2AA6':'ltcc','\u2A79':'ltcir','<':'lt','\u22C9':'ltimes','\u2976':'ltlarr','\u2A7B':'ltquest','\u25C3':'ltri','\u2996':'ltrPar','\u294A':'lurdshar','\u2966':'luruhar','\u2268\uFE00':'lvnE','\xAF':'macr','\u2642':'male','\u2720':'malt','\u2905':'Map','\u21A6':'map','\u21A5':'mapstoup','\u25AE':'marker','\u2A29':'mcomma','\u041C':'Mcy','\u043C':'mcy','\u2014':'mdash','\u223A':'mDDot','\u205F':'MediumSpace','\u2133':'Mscr','\uD835\uDD10':'Mfr','\uD835\uDD2A':'mfr','\u2127':'mho','\xB5':'micro','\u2AF0':'midcir','\u2223':'mid','\u2212':'minus','\u2A2A':'minusdu','\u2213':'mp','\u2ADB':'mlcp','\u22A7':'models','\uD835\uDD44':'Mopf','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\u039C':'Mu','\u03BC':'mu','\u22B8':'mumap','\u0143':'Nacute','\u0144':'nacute','\u2220\u20D2':'nang','\u2249':'nap','\u2A70\u0338':'napE','\u224B\u0338':'napid','\u0149':'napos','\u266E':'natur','\u2115':'Nopf','\xA0':'nbsp','\u224E\u0338':'nbump','\u224F\u0338':'nbumpe','\u2A43':'ncap','\u0147':'Ncaron','\u0148':'ncaron','\u0145':'Ncedil','\u0146':'ncedil','\u2247':'ncong','\u2A6D\u0338':'ncongdot','\u2A42':'ncup','\u041D':'Ncy','\u043D':'ncy','\u2013':'ndash','\u2924':'nearhk','\u2197':'nearr','\u21D7':'neArr','\u2260':'ne','\u2250\u0338':'nedot','\u200B':'ZeroWidthSpace','\u2262':'nequiv','\u2928':'toea','\u2242\u0338':'nesim','\n':'NewLine','\u2204':'nexist','\uD835\uDD11':'Nfr','\uD835\uDD2B':'nfr','\u2267\u0338':'ngE','\u2271':'nge','\u2A7E\u0338':'nges','\u22D9\u0338':'nGg','\u2275':'ngsim','\u226B\u20D2':'nGt','\u226F':'ngt','\u226B\u0338':'nGtv','\u21AE':'nharr','\u21CE':'nhArr','\u2AF2':'nhpar','\u220B':'ni','\u22FC':'nis','\u22FA':'nisd','\u040A':'NJcy','\u045A':'njcy','\u219A':'nlarr','\u21CD':'nlArr','\u2025':'nldr','\u2266\u0338':'nlE','\u2270':'nle','\u2A7D\u0338':'nles','\u226E':'nlt','\u22D8\u0338':'nLl','\u2274':'nlsim','\u226A\u20D2':'nLt','\u22EA':'nltri','\u22EC':'nltrie','\u226A\u0338':'nLtv','\u2224':'nmid','\u2060':'NoBreak','\uD835\uDD5F':'nopf','\u2AEC':'Not','\xAC':'not','\u226D':'NotCupCap','\u2226':'npar','\u2209':'notin','\u2279':'ntgl','\u22F5\u0338':'notindot','\u22F9\u0338':'notinE','\u22F7':'notinvb','\u22F6':'notinvc','\u29CF\u0338':'NotLeftTriangleBar','\u2278':'ntlg','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA1\u0338':'NotNestedLessLess','\u220C':'notni','\u22FE':'notnivb','\u22FD':'notnivc','\u2280':'npr','\u2AAF\u0338':'npre','\u22E0':'nprcue','\u29D0\u0338':'NotRightTriangleBar','\u22EB':'nrtri','\u22ED':'nrtrie','\u228F\u0338':'NotSquareSubset','\u22E2':'nsqsube','\u2290\u0338':'NotSquareSuperset','\u22E3':'nsqsupe','\u2282\u20D2':'vnsub','\u2288':'nsube','\u2281':'nsc','\u2AB0\u0338':'nsce','\u22E1':'nsccue','\u227F\u0338':'NotSucceedsTilde','\u2283\u20D2':'vnsup','\u2289':'nsupe','\u2241':'nsim','\u2244':'nsime','\u2AFD\u20E5':'nparsl','\u2202\u0338':'npart','\u2A14':'npolint','\u2933\u0338':'nrarrc','\u219B':'nrarr','\u21CF':'nrArr','\u219D\u0338':'nrarrw','\uD835\uDCA9':'Nscr','\uD835\uDCC3':'nscr','\u2284':'nsub','\u2AC5\u0338':'nsubE','\u2285':'nsup','\u2AC6\u0338':'nsupE','\xD1':'Ntilde','\xF1':'ntilde','\u039D':'Nu','\u03BD':'nu','#':'num','\u2116':'numero','\u2007':'numsp','\u224D\u20D2':'nvap','\u22AC':'nvdash','\u22AD':'nvDash','\u22AE':'nVdash','\u22AF':'nVDash','\u2265\u20D2':'nvge','>\u20D2':'nvgt','\u2904':'nvHarr','\u29DE':'nvinfin','\u2902':'nvlArr','\u2264\u20D2':'nvle','<\u20D2':'nvlt','\u22B4\u20D2':'nvltrie','\u2903':'nvrArr','\u22B5\u20D2':'nvrtrie','\u223C\u20D2':'nvsim','\u2923':'nwarhk','\u2196':'nwarr','\u21D6':'nwArr','\u2927':'nwnear','\xD3':'Oacute','\xF3':'oacute','\xD4':'Ocirc','\xF4':'ocirc','\u041E':'Ocy','\u043E':'ocy','\u0150':'Odblac','\u0151':'odblac','\u2A38':'odiv','\u29BC':'odsold','\u0152':'OElig','\u0153':'oelig','\u29BF':'ofcir','\uD835\uDD12':'Ofr','\uD835\uDD2C':'ofr','\u02DB':'ogon','\xD2':'Ograve','\xF2':'ograve','\u29C1':'ogt','\u29B5':'ohbar','\u03A9':'ohm','\u29BE':'olcir','\u29BB':'olcross','\u203E':'oline','\u29C0':'olt','\u014C':'Omacr','\u014D':'omacr','\u03C9':'omega','\u039F':'Omicron','\u03BF':'omicron','\u29B6':'omid','\uD835\uDD46':'Oopf','\uD835\uDD60':'oopf','\u29B7':'opar','\u29B9':'operp','\u2A54':'Or','\u2228':'or','\u2A5D':'ord','\u2134':'oscr','\xAA':'ordf','\xBA':'ordm','\u22B6':'origof','\u2A56':'oror','\u2A57':'orslope','\u2A5B':'orv','\uD835\uDCAA':'Oscr','\xD8':'Oslash','\xF8':'oslash','\u2298':'osol','\xD5':'Otilde','\xF5':'otilde','\u2A36':'otimesas','\u2A37':'Otimes','\xD6':'Ouml','\xF6':'ouml','\u233D':'ovbar','\u23DE':'OverBrace','\u23B4':'tbrk','\u23DC':'OverParenthesis','\xB6':'para','\u2AF3':'parsim','\u2AFD':'parsl','\u2202':'part','\u041F':'Pcy','\u043F':'pcy','%':'percnt','.':'period','\u2030':'permil','\u2031':'pertenk','\uD835\uDD13':'Pfr','\uD835\uDD2D':'pfr','\u03A6':'Phi','\u03C6':'phi','\u03D5':'phiv','\u260E':'phone','\u03A0':'Pi','\u03C0':'pi','\u03D6':'piv','\u210E':'planckh','\u2A23':'plusacir','\u2A22':'pluscir','+':'plus','\u2A25':'plusdu','\u2A72':'pluse','\xB1':'pm','\u2A26':'plussim','\u2A27':'plustwo','\u2A15':'pointint','\uD835\uDD61':'popf','\u2119':'Popf','\xA3':'pound','\u2AB7':'prap','\u2ABB':'Pr','\u227A':'pr','\u227C':'prcue','\u2AAF':'pre','\u227E':'prsim','\u2AB9':'prnap','\u2AB5':'prnE','\u22E8':'prnsim','\u2AB3':'prE','\u2032':'prime','\u2033':'Prime','\u220F':'prod','\u232E':'profalar','\u2312':'profline','\u2313':'profsurf','\u221D':'prop','\u22B0':'prurel','\uD835\uDCAB':'Pscr','\uD835\uDCC5':'pscr','\u03A8':'Psi','\u03C8':'psi','\u2008':'puncsp','\uD835\uDD14':'Qfr','\uD835\uDD2E':'qfr','\uD835\uDD62':'qopf','\u211A':'Qopf','\u2057':'qprime','\uD835\uDCAC':'Qscr','\uD835\uDCC6':'qscr','\u2A16':'quatint','?':'quest','"':'quot','\u21DB':'rAarr','\u223D\u0331':'race','\u0154':'Racute','\u0155':'racute','\u221A':'Sqrt','\u29B3':'raemptyv','\u27E9':'rang','\u27EB':'Rang','\u2992':'rangd','\u29A5':'range','\xBB':'raquo','\u2975':'rarrap','\u21E5':'rarrb','\u2920':'rarrbfs','\u2933':'rarrc','\u2192':'rarr','\u21A0':'Rarr','\u291E':'rarrfs','\u2945':'rarrpl','\u2974':'rarrsim','\u2916':'Rarrtl','\u21A3':'rarrtl','\u219D':'rarrw','\u291A':'ratail','\u291C':'rAtail','\u2236':'ratio','\u2773':'rbbrk','}':'rcub',']':'rsqb','\u298C':'rbrke','\u298E':'rbrksld','\u2990':'rbrkslu','\u0158':'Rcaron','\u0159':'rcaron','\u0156':'Rcedil','\u0157':'rcedil','\u2309':'rceil','\u0420':'Rcy','\u0440':'rcy','\u2937':'rdca','\u2969':'rdldhar','\u21B3':'rdsh','\u211C':'Re','\u211B':'Rscr','\u211D':'Ropf','\u25AD':'rect','\u297D':'rfisht','\u230B':'rfloor','\uD835\uDD2F':'rfr','\u2964':'rHar','\u21C0':'rharu','\u296C':'rharul','\u03A1':'Rho','\u03C1':'rho','\u03F1':'rhov','\u21C4':'rlarr','\u27E7':'robrk','\u295D':'RightDownTeeVector','\u2955':'RightDownVectorBar','\u21C9':'rrarr','\u22A2':'vdash','\u295B':'RightTeeVector','\u22CC':'rthree','\u29D0':'RightTriangleBar','\u22B3':'vrtri','\u22B5':'rtrie','\u294F':'RightUpDownVector','\u295C':'RightUpTeeVector','\u2954':'RightUpVectorBar','\u21BE':'uharr','\u2953':'RightVectorBar','\u02DA':'ring','\u200F':'rlm','\u23B1':'rmoust','\u2AEE':'rnmid','\u27ED':'roang','\u21FE':'roarr','\u2986':'ropar','\uD835\uDD63':'ropf','\u2A2E':'roplus','\u2A35':'rotimes','\u2970':'RoundImplies',')':'rpar','\u2994':'rpargt','\u2A12':'rppolint','\u203A':'rsaquo','\uD835\uDCC7':'rscr','\u21B1':'rsh','\u22CA':'rtimes','\u25B9':'rtri','\u29CE':'rtriltri','\u29F4':'RuleDelayed','\u2968':'ruluhar','\u211E':'rx','\u015A':'Sacute','\u015B':'sacute','\u2AB8':'scap','\u0160':'Scaron','\u0161':'scaron','\u2ABC':'Sc','\u227B':'sc','\u227D':'sccue','\u2AB0':'sce','\u2AB4':'scE','\u015E':'Scedil','\u015F':'scedil','\u015C':'Scirc','\u015D':'scirc','\u2ABA':'scnap','\u2AB6':'scnE','\u22E9':'scnsim','\u2A13':'scpolint','\u227F':'scsim','\u0421':'Scy','\u0441':'scy','\u22C5':'sdot','\u2A66':'sdote','\u21D8':'seArr','\xA7':'sect',';':'semi','\u2929':'tosa','\u2736':'sext','\uD835\uDD16':'Sfr','\uD835\uDD30':'sfr','\u266F':'sharp','\u0429':'SHCHcy','\u0449':'shchcy','\u0428':'SHcy','\u0448':'shcy','\u2191':'uarr','\xAD':'shy','\u03A3':'Sigma','\u03C3':'sigma','\u03C2':'sigmaf','\u223C':'sim','\u2A6A':'simdot','\u2243':'sime','\u2A9E':'simg','\u2AA0':'simgE','\u2A9D':'siml','\u2A9F':'simlE','\u2246':'simne','\u2A24':'simplus','\u2972':'simrarr','\u2A33':'smashp','\u29E4':'smeparsl','\u2323':'smile','\u2AAA':'smt','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u042C':'SOFTcy','\u044C':'softcy','\u233F':'solbar','\u29C4':'solb','/':'sol','\uD835\uDD4A':'Sopf','\uD835\uDD64':'sopf','\u2660':'spades','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u228F':'sqsub','\u2291':'sqsube','\u2290':'sqsup','\u2292':'sqsupe','\u25A1':'squ','\uD835\uDCAE':'Sscr','\uD835\uDCC8':'sscr','\u22C6':'Star','\u2606':'star','\u2282':'sub','\u22D0':'Sub','\u2ABD':'subdot','\u2AC5':'subE','\u2286':'sube','\u2AC3':'subedot','\u2AC1':'submult','\u2ACB':'subnE','\u228A':'subne','\u2ABF':'subplus','\u2979':'subrarr','\u2AC7':'subsim','\u2AD5':'subsub','\u2AD3':'subsup','\u2211':'sum','\u266A':'sung','\xB9':'sup1','\xB2':'sup2','\xB3':'sup3','\u2283':'sup','\u22D1':'Sup','\u2ABE':'supdot','\u2AD8':'supdsub','\u2AC6':'supE','\u2287':'supe','\u2AC4':'supedot','\u27C9':'suphsol','\u2AD7':'suphsub','\u297B':'suplarr','\u2AC2':'supmult','\u2ACC':'supnE','\u228B':'supne','\u2AC0':'supplus','\u2AC8':'supsim','\u2AD4':'supsub','\u2AD6':'supsup','\u21D9':'swArr','\u292A':'swnwar','\xDF':'szlig','\t':'Tab','\u2316':'target','\u03A4':'Tau','\u03C4':'tau','\u0164':'Tcaron','\u0165':'tcaron','\u0162':'Tcedil','\u0163':'tcedil','\u0422':'Tcy','\u0442':'tcy','\u20DB':'tdot','\u2315':'telrec','\uD835\uDD17':'Tfr','\uD835\uDD31':'tfr','\u2234':'there4','\u0398':'Theta','\u03B8':'theta','\u03D1':'thetav','\u205F\u200A':'ThickSpace','\u2009':'thinsp','\xDE':'THORN','\xFE':'thorn','\u2A31':'timesbar','\xD7':'times','\u2A30':'timesd','\u2336':'topbot','\u2AF1':'topcir','\uD835\uDD4B':'Topf','\uD835\uDD65':'topf','\u2ADA':'topfork','\u2034':'tprime','\u2122':'trade','\u25B5':'utri','\u225C':'trie','\u25EC':'tridot','\u2A3A':'triminus','\u2A39':'triplus','\u29CD':'trisb','\u2A3B':'tritime','\u23E2':'trpezium','\uD835\uDCAF':'Tscr','\uD835\uDCC9':'tscr','\u0426':'TScy','\u0446':'tscy','\u040B':'TSHcy','\u045B':'tshcy','\u0166':'Tstrok','\u0167':'tstrok','\xDA':'Uacute','\xFA':'uacute','\u219F':'Uarr','\u2949':'Uarrocir','\u040E':'Ubrcy','\u045E':'ubrcy','\u016C':'Ubreve','\u016D':'ubreve','\xDB':'Ucirc','\xFB':'ucirc','\u0423':'Ucy','\u0443':'ucy','\u21C5':'udarr','\u0170':'Udblac','\u0171':'udblac','\u296E':'udhar','\u297E':'ufisht','\uD835\uDD18':'Ufr','\uD835\uDD32':'ufr','\xD9':'Ugrave','\xF9':'ugrave','\u2963':'uHar','\u2580':'uhblk','\u231C':'ulcorn','\u230F':'ulcrop','\u25F8':'ultri','\u016A':'Umacr','\u016B':'umacr','\u23DF':'UnderBrace','\u23DD':'UnderParenthesis','\u228E':'uplus','\u0172':'Uogon','\u0173':'uogon','\uD835\uDD4C':'Uopf','\uD835\uDD66':'uopf','\u2912':'UpArrowBar','\u2195':'varr','\u03C5':'upsi','\u03D2':'Upsi','\u03A5':'Upsilon','\u21C8':'uuarr','\u231D':'urcorn','\u230E':'urcrop','\u016E':'Uring','\u016F':'uring','\u25F9':'urtri','\uD835\uDCB0':'Uscr','\uD835\uDCCA':'uscr','\u22F0':'utdot','\u0168':'Utilde','\u0169':'utilde','\xDC':'Uuml','\xFC':'uuml','\u29A7':'uwangle','\u299C':'vangrt','\u228A\uFE00':'vsubne','\u2ACB\uFE00':'vsubnE','\u228B\uFE00':'vsupne','\u2ACC\uFE00':'vsupnE','\u2AE8':'vBar','\u2AEB':'Vbar','\u2AE9':'vBarv','\u0412':'Vcy','\u0432':'vcy','\u22A9':'Vdash','\u22AB':'VDash','\u2AE6':'Vdashl','\u22BB':'veebar','\u225A':'veeeq','\u22EE':'vellip','|':'vert','\u2016':'Vert','\u2758':'VerticalSeparator','\u2240':'wr','\uD835\uDD19':'Vfr','\uD835\uDD33':'vfr','\uD835\uDD4D':'Vopf','\uD835\uDD67':'vopf','\uD835\uDCB1':'Vscr','\uD835\uDCCB':'vscr','\u22AA':'Vvdash','\u299A':'vzigzag','\u0174':'Wcirc','\u0175':'wcirc','\u2A5F':'wedbar','\u2259':'wedgeq','\u2118':'wp','\uD835\uDD1A':'Wfr','\uD835\uDD34':'wfr','\uD835\uDD4E':'Wopf','\uD835\uDD68':'wopf','\uD835\uDCB2':'Wscr','\uD835\uDCCC':'wscr','\uD835\uDD1B':'Xfr','\uD835\uDD35':'xfr','\u039E':'Xi','\u03BE':'xi','\u22FB':'xnis','\uD835\uDD4F':'Xopf','\uD835\uDD69':'xopf','\uD835\uDCB3':'Xscr','\uD835\uDCCD':'xscr','\xDD':'Yacute','\xFD':'yacute','\u042F':'YAcy','\u044F':'yacy','\u0176':'Ycirc','\u0177':'ycirc','\u042B':'Ycy','\u044B':'ycy','\xA5':'yen','\uD835\uDD1C':'Yfr','\uD835\uDD36':'yfr','\u0407':'YIcy','\u0457':'yicy','\uD835\uDD50':'Yopf','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDCCE':'yscr','\u042E':'YUcy','\u044E':'yucy','\xFF':'yuml','\u0178':'Yuml','\u0179':'Zacute','\u017A':'zacute','\u017D':'Zcaron','\u017E':'zcaron','\u0417':'Zcy','\u0437':'zcy','\u017B':'Zdot','\u017C':'zdot','\u2128':'Zfr','\u0396':'Zeta','\u03B6':'zeta','\uD835\uDD37':'zfr','\u0416':'ZHcy','\u0436':'zhcy','\u21DD':'zigrarr','\uD835\uDD6B':'zopf','\uD835\uDCB5':'Zscr','\uD835\uDCCF':'zscr','\u200D':'zwj','\u200C':'zwnj'};
  
  	var regexEscape = /["&'<>`]/g;
  	var escapeMap = {
  		'"': '&quot;',
  		'&': '&amp;',
  		'\'': '&#x27;',
  		'<': '&lt;',
  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
  		// following is not strictly necessary unless it’s part of a tag or an
  		// unquoted attribute value. We’re only escaping it to support those
  		// situations, and for XML support.
  		'>': '&gt;',
  		// In Internet Explorer ≤ 8, the backtick character can be used
  		// to break out of (un)quoted attribute values or HTML comments.
  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
  		// http://html5sec.org/#133.
  		'`': '&#x60;'
  	};
  
  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  	var regexDecode = /&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+);|&(Aacute|iacute|Uacute|plusmn|otilde|Otilde|Agrave|agrave|yacute|Yacute|oslash|Oslash|Atilde|atilde|brvbar|Ccedil|ccedil|ograve|curren|divide|Eacute|eacute|Ograve|oacute|Egrave|egrave|ugrave|frac12|frac14|frac34|Ugrave|Oacute|Iacute|ntilde|Ntilde|uacute|middot|Igrave|igrave|iquest|aacute|laquo|THORN|micro|iexcl|icirc|Icirc|Acirc|ucirc|ecirc|Ocirc|ocirc|Ecirc|Ucirc|aring|Aring|aelig|AElig|acute|pound|raquo|acirc|times|thorn|szlig|cedil|COPY|Auml|ordf|ordm|uuml|macr|Uuml|auml|Ouml|ouml|para|nbsp|Euml|quot|QUOT|euml|yuml|cent|sect|copy|sup1|sup2|sup3|Iuml|iuml|shy|eth|reg|not|yen|amp|AMP|REG|uml|ETH|deg|gt|GT|LT|lt)([=a-zA-Z0-9])?/g;
  	var decodeMap = {'Aacute':'\xC1','aacute':'\xE1','Abreve':'\u0102','abreve':'\u0103','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','Acirc':'\xC2','acirc':'\xE2','acute':'\xB4','Acy':'\u0410','acy':'\u0430','AElig':'\xC6','aelig':'\xE6','af':'\u2061','Afr':'\uD835\uDD04','afr':'\uD835\uDD1E','Agrave':'\xC0','agrave':'\xE0','alefsym':'\u2135','aleph':'\u2135','Alpha':'\u0391','alpha':'\u03B1','Amacr':'\u0100','amacr':'\u0101','amalg':'\u2A3F','amp':'&','AMP':'&','andand':'\u2A55','And':'\u2A53','and':'\u2227','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angmsd':'\u2221','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','Aogon':'\u0104','aogon':'\u0105','Aopf':'\uD835\uDD38','aopf':'\uD835\uDD52','apacir':'\u2A6F','ap':'\u2248','apE':'\u2A70','ape':'\u224A','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','Aring':'\xC5','aring':'\xE5','Ascr':'\uD835\uDC9C','ascr':'\uD835\uDCB6','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','Atilde':'\xC3','atilde':'\xE3','Auml':'\xC4','auml':'\xE4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','Bcy':'\u0411','bcy':'\u0431','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','Beta':'\u0392','beta':'\u03B2','beth':'\u2136','between':'\u226C','Bfr':'\uD835\uDD05','bfr':'\uD835\uDD1F','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bNot':'\u2AED','bnot':'\u2310','Bopf':'\uD835\uDD39','bopf':'\uD835\uDD53','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxHd':'\u2564','boxhD':'\u2565','boxHD':'\u2566','boxhu':'\u2534','boxHu':'\u2567','boxhU':'\u2568','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsolb':'\u29C5','bsol':'\\','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpE':'\u2AAE','bumpe':'\u224F','Bumpeq':'\u224E','bumpeq':'\u224F','Cacute':'\u0106','cacute':'\u0107','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','cap':'\u2229','Cap':'\u22D2','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','Ccaron':'\u010C','ccaron':'\u010D','Ccedil':'\xC7','ccedil':'\xE7','Ccirc':'\u0108','ccirc':'\u0109','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','Cdot':'\u010A','cdot':'\u010B','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','CHcy':'\u0427','chcy':'\u0447','check':'\u2713','checkmark':'\u2713','Chi':'\u03A7','chi':'\u03C7','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cir':'\u25CB','cirE':'\u29C3','cire':'\u2257','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','Colone':'\u2A74','colone':'\u2254','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','Cscr':'\uD835\uDC9E','cscr':'\uD835\uDCB8','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cup':'\u222A','Cup':'\u22D3','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','Darr':'\u21A1','dArr':'\u21D3','dash':'\u2010','Dashv':'\u2AE4','dashv':'\u22A3','dbkarow':'\u290F','dblac':'\u02DD','Dcaron':'\u010E','dcaron':'\u010F','Dcy':'\u0414','dcy':'\u0434','ddagger':'\u2021','ddarr':'\u21CA','DD':'\u2145','dd':'\u2146','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','Delta':'\u0394','delta':'\u03B4','demptyv':'\u29B1','dfisht':'\u297F','Dfr':'\uD835\uDD07','dfr':'\uD835\uDD21','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','DJcy':'\u0402','djcy':'\u0452','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','Dopf':'\uD835\uDD3B','dopf':'\uD835\uDD55','Dot':'\xA8','dot':'\u02D9','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','DownArrowBar':'\u2913','downarrow':'\u2193','DownArrow':'\u2193','Downarrow':'\u21D3','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVectorBar':'\u2956','DownLeftVector':'\u21BD','DownRightTeeVector':'\u295F','DownRightVectorBar':'\u2957','DownRightVector':'\u21C1','DownTeeArrow':'\u21A7','DownTee':'\u22A4','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','Dscr':'\uD835\uDC9F','dscr':'\uD835\uDCB9','DScy':'\u0405','dscy':'\u0455','dsol':'\u29F6','Dstrok':'\u0110','dstrok':'\u0111','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','DZcy':'\u040F','dzcy':'\u045F','dzigrarr':'\u27FF','Eacute':'\xC9','eacute':'\xE9','easter':'\u2A6E','Ecaron':'\u011A','ecaron':'\u011B','Ecirc':'\xCA','ecirc':'\xEA','ecir':'\u2256','ecolon':'\u2255','Ecy':'\u042D','ecy':'\u044D','eDDot':'\u2A77','Edot':'\u0116','edot':'\u0117','eDot':'\u2251','ee':'\u2147','efDot':'\u2252','Efr':'\uD835\uDD08','efr':'\uD835\uDD22','eg':'\u2A9A','Egrave':'\xC8','egrave':'\xE8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','Emacr':'\u0112','emacr':'\u0113','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp13':'\u2004','emsp14':'\u2005','emsp':'\u2003','ENG':'\u014A','eng':'\u014B','ensp':'\u2002','Eogon':'\u0118','eogon':'\u0119','Eopf':'\uD835\uDD3C','eopf':'\uD835\uDD56','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','Epsilon':'\u0395','epsilon':'\u03B5','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','Esim':'\u2A73','esim':'\u2242','Eta':'\u0397','eta':'\u03B7','ETH':'\xD0','eth':'\xF0','Euml':'\xCB','euml':'\xEB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','Fcy':'\u0424','fcy':'\u0444','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','Ffr':'\uD835\uDD09','ffr':'\uD835\uDD23','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','Fopf':'\uD835\uDD3D','fopf':'\uD835\uDD57','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','Gamma':'\u0393','gamma':'\u03B3','Gammad':'\u03DC','gammad':'\u03DD','gap':'\u2A86','Gbreve':'\u011E','gbreve':'\u011F','Gcedil':'\u0122','Gcirc':'\u011C','gcirc':'\u011D','Gcy':'\u0413','gcy':'\u0433','Gdot':'\u0120','gdot':'\u0121','ge':'\u2265','gE':'\u2267','gEl':'\u2A8C','gel':'\u22DB','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','gescc':'\u2AA9','ges':'\u2A7E','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','Gfr':'\uD835\uDD0A','gfr':'\uD835\uDD24','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','GJcy':'\u0403','gjcy':'\u0453','gla':'\u2AA5','gl':'\u2277','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','Gopf':'\uD835\uDD3E','gopf':'\uD835\uDD58','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','Gscr':'\uD835\uDCA2','gscr':'\u210A','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gtcc':'\u2AA7','gtcir':'\u2A7A','gt':'>','GT':'>','Gt':'\u226B','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','HARDcy':'\u042A','hardcy':'\u044A','harrcir':'\u2948','harr':'\u2194','hArr':'\u21D4','harrw':'\u21AD','Hat':'^','hbar':'\u210F','Hcirc':'\u0124','hcirc':'\u0125','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','Hstrok':'\u0126','hstrok':'\u0127','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','Iacute':'\xCD','iacute':'\xED','ic':'\u2063','Icirc':'\xCE','icirc':'\xEE','Icy':'\u0418','icy':'\u0438','Idot':'\u0130','IEcy':'\u0415','iecy':'\u0435','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','Igrave':'\xCC','igrave':'\xEC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','IJlig':'\u0132','ijlig':'\u0133','Imacr':'\u012A','imacr':'\u012B','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','Im':'\u2111','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','incare':'\u2105','in':'\u2208','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','intcal':'\u22BA','int':'\u222B','Int':'\u222C','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','IOcy':'\u0401','iocy':'\u0451','Iogon':'\u012E','iogon':'\u012F','Iopf':'\uD835\uDD40','iopf':'\uD835\uDD5A','Iota':'\u0399','iota':'\u03B9','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','Itilde':'\u0128','itilde':'\u0129','Iukcy':'\u0406','iukcy':'\u0456','Iuml':'\xCF','iuml':'\xEF','Jcirc':'\u0134','jcirc':'\u0135','Jcy':'\u0419','jcy':'\u0439','Jfr':'\uD835\uDD0D','jfr':'\uD835\uDD27','jmath':'\u0237','Jopf':'\uD835\uDD41','jopf':'\uD835\uDD5B','Jscr':'\uD835\uDCA5','jscr':'\uD835\uDCBF','Jsercy':'\u0408','jsercy':'\u0458','Jukcy':'\u0404','jukcy':'\u0454','Kappa':'\u039A','kappa':'\u03BA','kappav':'\u03F0','Kcedil':'\u0136','kcedil':'\u0137','Kcy':'\u041A','kcy':'\u043A','Kfr':'\uD835\uDD0E','kfr':'\uD835\uDD28','kgreen':'\u0138','KHcy':'\u0425','khcy':'\u0445','KJcy':'\u040C','kjcy':'\u045C','Kopf':'\uD835\uDD42','kopf':'\uD835\uDD5C','Kscr':'\uD835\uDCA6','kscr':'\uD835\uDCC0','lAarr':'\u21DA','Lacute':'\u0139','lacute':'\u013A','laemptyv':'\u29B4','lagran':'\u2112','Lambda':'\u039B','lambda':'\u03BB','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larrb':'\u21E4','larrbfs':'\u291F','larr':'\u2190','Larr':'\u219E','lArr':'\u21D0','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','latail':'\u2919','lAtail':'\u291B','lat':'\u2AAB','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','Lcaron':'\u013D','lcaron':'\u013E','Lcedil':'\u013B','lcedil':'\u013C','lceil':'\u2308','lcub':'{','Lcy':'\u041B','lcy':'\u043B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','LeftArrowBar':'\u21E4','leftarrow':'\u2190','LeftArrow':'\u2190','Leftarrow':'\u21D0','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVectorBar':'\u2959','LeftDownVector':'\u21C3','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','LeftRightArrow':'\u2194','Leftrightarrow':'\u21D4','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTeeArrow':'\u21A4','LeftTee':'\u22A3','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangleBar':'\u29CF','LeftTriangle':'\u22B2','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVectorBar':'\u2958','LeftUpVector':'\u21BF','LeftVectorBar':'\u2952','LeftVector':'\u21BC','lEg':'\u2A8B','leg':'\u22DA','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','lescc':'\u2AA8','les':'\u2A7D','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','Lfr':'\uD835\uDD0F','lfr':'\uD835\uDD29','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','LJcy':'\u0409','ljcy':'\u0459','llarr':'\u21C7','ll':'\u226A','Ll':'\u22D8','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','Lmidot':'\u013F','lmidot':'\u0140','lmoustache':'\u23B0','lmoust':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','LongLeftArrow':'\u27F5','Longleftarrow':'\u27F8','longleftrightarrow':'\u27F7','LongLeftRightArrow':'\u27F7','Longleftrightarrow':'\u27FA','longmapsto':'\u27FC','longrightarrow':'\u27F6','LongRightArrow':'\u27F6','Longrightarrow':'\u27F9','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','Lopf':'\uD835\uDD43','lopf':'\uD835\uDD5D','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','Lstrok':'\u0141','lstrok':'\u0142','ltcc':'\u2AA6','ltcir':'\u2A79','lt':'<','LT':'<','Lt':'\u226A','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','Map':'\u2905','map':'\u21A6','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','Mcy':'\u041C','mcy':'\u043C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','Mfr':'\uD835\uDD10','mfr':'\uD835\uDD2A','mho':'\u2127','micro':'\xB5','midast':'*','midcir':'\u2AF0','mid':'\u2223','middot':'\xB7','minusb':'\u229F','minus':'\u2212','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','Mopf':'\uD835\uDD44','mopf':'\uD835\uDD5E','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','Mu':'\u039C','mu':'\u03BC','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','Nacute':'\u0143','nacute':'\u0144','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natural':'\u266E','naturals':'\u2115','natur':'\u266E','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','Ncaron':'\u0147','ncaron':'\u0148','Ncedil':'\u0145','ncedil':'\u0146','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','Ncy':'\u041D','ncy':'\u043D','ndash':'\u2013','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','ne':'\u2260','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','Nfr':'\uD835\uDD11','nfr':'\uD835\uDD2B','ngE':'\u2267\u0338','nge':'\u2271','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','nGt':'\u226B\u20D2','ngt':'\u226F','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','NJcy':'\u040A','njcy':'\u045A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nlE':'\u2266\u0338','nle':'\u2270','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nLt':'\u226A\u20D2','nlt':'\u226E','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','Not':'\u2AEC','not':'\xAC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangle':'\u22EA','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangle':'\u22EB','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','nparallel':'\u2226','npar':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','nprec':'\u2280','npreceq':'\u2AAF\u0338','npre':'\u2AAF\u0338','nrarrc':'\u2933\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','Nscr':'\uD835\uDCA9','nscr':'\uD835\uDCC3','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsubE':'\u2AC5\u0338','nsube':'\u2288','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupE':'\u2AC6\u0338','nsupe':'\u2289','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','Ntilde':'\xD1','ntilde':'\xF1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','Nu':'\u039D','nu':'\u03BD','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','Oacute':'\xD3','oacute':'\xF3','oast':'\u229B','Ocirc':'\xD4','ocirc':'\xF4','ocir':'\u229A','Ocy':'\u041E','ocy':'\u043E','odash':'\u229D','Odblac':'\u0150','odblac':'\u0151','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','OElig':'\u0152','oelig':'\u0153','ofcir':'\u29BF','Ofr':'\uD835\uDD12','ofr':'\uD835\uDD2C','ogon':'\u02DB','Ograve':'\xD2','ograve':'\xF2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','Omacr':'\u014C','omacr':'\u014D','Omega':'\u03A9','omega':'\u03C9','Omicron':'\u039F','omicron':'\u03BF','omid':'\u29B6','ominus':'\u2296','Oopf':'\uD835\uDD46','oopf':'\uD835\uDD60','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','orarr':'\u21BB','Or':'\u2A54','or':'\u2228','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','Oscr':'\uD835\uDCAA','oscr':'\u2134','Oslash':'\xD8','oslash':'\xF8','osol':'\u2298','Otilde':'\xD5','otilde':'\xF5','otimesas':'\u2A36','Otimes':'\u2A37','otimes':'\u2297','Ouml':'\xD6','ouml':'\xF6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','para':'\xB6','parallel':'\u2225','par':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','Pcy':'\u041F','pcy':'\u043F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','Pfr':'\uD835\uDD13','pfr':'\uD835\uDD2D','Phi':'\u03A6','phi':'\u03C6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','Pi':'\u03A0','pi':'\u03C0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plus':'+','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','prap':'\u2AB7','Pr':'\u2ABB','pr':'\u227A','prcue':'\u227C','precapprox':'\u2AB7','prec':'\u227A','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','pre':'\u2AAF','prE':'\u2AB3','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportional':'\u221D','Proportion':'\u2237','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','Pscr':'\uD835\uDCAB','pscr':'\uD835\uDCC5','Psi':'\u03A8','psi':'\u03C8','puncsp':'\u2008','Qfr':'\uD835\uDD14','qfr':'\uD835\uDD2E','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','Qscr':'\uD835\uDCAC','qscr':'\uD835\uDCC6','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','Racute':'\u0154','racute':'\u0155','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarr':'\u2192','Rarr':'\u21A0','rArr':'\u21D2','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','Rarrtl':'\u2916','rarrtl':'\u21A3','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','Rcaron':'\u0158','rcaron':'\u0159','Rcedil':'\u0156','rcedil':'\u0157','rceil':'\u2309','rcub':'}','Rcy':'\u0420','rcy':'\u0440','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','Re':'\u211C','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','Rho':'\u03A1','rho':'\u03C1','rhov':'\u03F1','RightAngleBracket':'\u27E9','RightArrowBar':'\u21E5','rightarrow':'\u2192','RightArrow':'\u2192','Rightarrow':'\u21D2','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVectorBar':'\u2955','RightDownVector':'\u21C2','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTeeArrow':'\u21A6','RightTee':'\u22A2','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangleBar':'\u29D0','RightTriangle':'\u22B3','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVectorBar':'\u2954','RightUpVector':'\u21BE','RightVectorBar':'\u2953','RightVector':'\u21C0','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoustache':'\u23B1','rmoust':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','Sacute':'\u015A','sacute':'\u015B','sbquo':'\u201A','scap':'\u2AB8','Scaron':'\u0160','scaron':'\u0161','Sc':'\u2ABC','sc':'\u227B','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','Scedil':'\u015E','scedil':'\u015F','Scirc':'\u015C','scirc':'\u015D','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','Scy':'\u0421','scy':'\u0441','sdotb':'\u22A1','sdot':'\u22C5','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','Sfr':'\uD835\uDD16','sfr':'\uD835\uDD30','sfrown':'\u2322','sharp':'\u266F','SHCHcy':'\u0429','shchcy':'\u0449','SHcy':'\u0428','shcy':'\u0448','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','Sigma':'\u03A3','sigma':'\u03C3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','SOFTcy':'\u042C','softcy':'\u044C','solbar':'\u233F','solb':'\u29C4','sol':'/','Sopf':'\uD835\uDD4A','sopf':'\uD835\uDD64','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squ':'\u25A1','squf':'\u25AA','srarr':'\u2192','Sscr':'\uD835\uDCAE','sscr':'\uD835\uDCC8','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','Star':'\u22C6','star':'\u2606','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','subE':'\u2AC5','sube':'\u2286','subedot':'\u2AC3','submult':'\u2AC1','subnE':'\u2ACB','subne':'\u228A','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succapprox':'\u2AB8','succ':'\u227B','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','sup':'\u2283','Sup':'\u22D1','supdot':'\u2ABE','supdsub':'\u2AD8','supE':'\u2AC6','supe':'\u2287','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supnE':'\u2ACC','supne':'\u228B','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','Tau':'\u03A4','tau':'\u03C4','tbrk':'\u23B4','Tcaron':'\u0164','tcaron':'\u0165','Tcedil':'\u0162','tcedil':'\u0163','Tcy':'\u0422','tcy':'\u0442','tdot':'\u20DB','telrec':'\u2315','Tfr':'\uD835\uDD17','tfr':'\uD835\uDD31','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','Theta':'\u0398','theta':'\u03B8','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','ThinSpace':'\u2009','thinsp':'\u2009','thkap':'\u2248','thksim':'\u223C','THORN':'\xDE','thorn':'\xFE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','timesbar':'\u2A31','timesb':'\u22A0','times':'\xD7','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','topbot':'\u2336','topcir':'\u2AF1','top':'\u22A4','Topf':'\uD835\uDD4B','topf':'\uD835\uDD65','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','Tscr':'\uD835\uDCAF','tscr':'\uD835\uDCC9','TScy':'\u0426','tscy':'\u0446','TSHcy':'\u040B','tshcy':'\u045B','Tstrok':'\u0166','tstrok':'\u0167','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','Uacute':'\xDA','uacute':'\xFA','uarr':'\u2191','Uarr':'\u219F','uArr':'\u21D1','Uarrocir':'\u2949','Ubrcy':'\u040E','ubrcy':'\u045E','Ubreve':'\u016C','ubreve':'\u016D','Ucirc':'\xDB','ucirc':'\xFB','Ucy':'\u0423','ucy':'\u0443','udarr':'\u21C5','Udblac':'\u0170','udblac':'\u0171','udhar':'\u296E','ufisht':'\u297E','Ufr':'\uD835\uDD18','ufr':'\uD835\uDD32','Ugrave':'\xD9','ugrave':'\xF9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','Umacr':'\u016A','umacr':'\u016B','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','Uogon':'\u0172','uogon':'\u0173','Uopf':'\uD835\uDD4C','uopf':'\uD835\uDD66','UpArrowBar':'\u2912','uparrow':'\u2191','UpArrow':'\u2191','Uparrow':'\u21D1','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','UpDownArrow':'\u2195','Updownarrow':'\u21D5','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','Upsilon':'\u03A5','upsilon':'\u03C5','UpTeeArrow':'\u21A5','UpTee':'\u22A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','Uring':'\u016E','uring':'\u016F','urtri':'\u25F9','Uscr':'\uD835\uDCB0','uscr':'\uD835\uDCCA','utdot':'\u22F0','Utilde':'\u0168','utilde':'\u0169','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','Uuml':'\xDC','uuml':'\xFC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','Vcy':'\u0412','vcy':'\u0432','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','veebar':'\u22BB','vee':'\u2228','Vee':'\u22C1','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','Vfr':'\uD835\uDD19','vfr':'\uD835\uDD33','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','Vopf':'\uD835\uDD4D','vopf':'\uD835\uDD67','vprop':'\u221D','vrtri':'\u22B3','Vscr':'\uD835\uDCB1','vscr':'\uD835\uDCCB','vsubnE':'\u2ACB\uFE00','vsubne':'\u228A\uFE00','vsupnE':'\u2ACC\uFE00','vsupne':'\u228B\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','Wcirc':'\u0174','wcirc':'\u0175','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','Wfr':'\uD835\uDD1A','wfr':'\uD835\uDD34','Wopf':'\uD835\uDD4E','wopf':'\uD835\uDD68','wp':'\u2118','wr':'\u2240','wreath':'\u2240','Wscr':'\uD835\uDCB2','wscr':'\uD835\uDCCC','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','Xfr':'\uD835\uDD1B','xfr':'\uD835\uDD35','xharr':'\u27F7','xhArr':'\u27FA','Xi':'\u039E','xi':'\u03BE','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','Xopf':'\uD835\uDD4F','xopf':'\uD835\uDD69','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','Xscr':'\uD835\uDCB3','xscr':'\uD835\uDCCD','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','Yacute':'\xDD','yacute':'\xFD','YAcy':'\u042F','yacy':'\u044F','Ycirc':'\u0176','ycirc':'\u0177','Ycy':'\u042B','ycy':'\u044B','yen':'\xA5','Yfr':'\uD835\uDD1C','yfr':'\uD835\uDD36','YIcy':'\u0407','yicy':'\u0457','Yopf':'\uD835\uDD50','yopf':'\uD835\uDD6A','Yscr':'\uD835\uDCB4','yscr':'\uD835\uDCCE','YUcy':'\u042E','yucy':'\u044E','yuml':'\xFF','Yuml':'\u0178','Zacute':'\u0179','zacute':'\u017A','Zcaron':'\u017D','zcaron':'\u017E','Zcy':'\u0417','zcy':'\u0437','Zdot':'\u017B','zdot':'\u017C','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','Zeta':'\u0396','zeta':'\u03B6','zfr':'\uD835\uDD37','Zfr':'\u2128','ZHcy':'\u0416','zhcy':'\u0436','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','Zscr':'\uD835\uDCB5','zscr':'\uD835\uDCCF','zwj':'\u200D','zwnj':'\u200C'};
  	var decodeMapLegacy = {'Aacute':'\xC1','aacute':'\xE1','Acirc':'\xC2','acirc':'\xE2','acute':'\xB4','AElig':'\xC6','aelig':'\xE6','Agrave':'\xC0','agrave':'\xE0','amp':'&','AMP':'&','Aring':'\xC5','aring':'\xE5','Atilde':'\xC3','atilde':'\xE3','Auml':'\xC4','auml':'\xE4','brvbar':'\xA6','Ccedil':'\xC7','ccedil':'\xE7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','Eacute':'\xC9','eacute':'\xE9','Ecirc':'\xCA','ecirc':'\xEA','Egrave':'\xC8','egrave':'\xE8','ETH':'\xD0','eth':'\xF0','Euml':'\xCB','euml':'\xEB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','Iacute':'\xCD','iacute':'\xED','Icirc':'\xCE','icirc':'\xEE','iexcl':'\xA1','Igrave':'\xCC','igrave':'\xEC','iquest':'\xBF','Iuml':'\xCF','iuml':'\xEF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','Ntilde':'\xD1','ntilde':'\xF1','Oacute':'\xD3','oacute':'\xF3','Ocirc':'\xD4','ocirc':'\xF4','Ograve':'\xD2','ograve':'\xF2','ordf':'\xAA','ordm':'\xBA','Oslash':'\xD8','oslash':'\xF8','Otilde':'\xD5','otilde':'\xF5','Ouml':'\xD6','ouml':'\xF6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','THORN':'\xDE','thorn':'\xFE','times':'\xD7','Uacute':'\xDA','uacute':'\xFA','Ucirc':'\xDB','ucirc':'\xFB','Ugrave':'\xD9','ugrave':'\xF9','uml':'\xA8','Uuml':'\xDC','uuml':'\xFC','Yacute':'\xDD','yacute':'\xFD','yen':'\xA5','yuml':'\xFF'};
  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
  
  	/*--------------------------------------------------------------------------*/
  
  	var stringFromCharCode = String.fromCharCode;
  
  	var object = {};
  	var hasOwnProperty = object.hasOwnProperty;
  	var has = function(object, propertyName) {
  		return hasOwnProperty.call(object, propertyName);
  	};
  
  	var contains = function(array, value) {
  		var index = -1;
  		var length = array.length;
  		while (++index < length) {
  			if (array[index] == value) {
  				return true;
  			}
  		}
  		return false;
  	};
  
  	var merge = function(options, defaults) {
  		if (!options) {
  			return defaults;
  		}
  		var result = {};
  		var key;
  		for (key in defaults) {
  			// A `hasOwnProperty` check is not needed here, since only recognized
  			// option names are used anyway. Any others are ignored.
  			result[key] = has(options, key) ? options[key] : defaults[key];
  		}
  		return result;
  	};
  
  	// Modified version of `ucs2encode`; see http://mths.be/punycode.
  	var codePointToSymbol = function(codePoint, strict) {
  		var output = '';
  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
  			// See issue #4:
  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
  			// REPLACEMENT CHARACTER.”
  			if (strict) {
  				parseError('character reference outside the permissible Unicode range');
  			}
  			return '\uFFFD';
  		}
  		if (has(decodeMapNumeric, codePoint)) {
  			if (strict) {
  				parseError('disallowed character reference');
  			}
  			return decodeMapNumeric[codePoint];
  		}
  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
  			parseError('disallowed character reference');
  		}
  		if (codePoint > 0xFFFF) {
  			codePoint -= 0x10000;
  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
  			codePoint = 0xDC00 | codePoint & 0x3FF;
  		}
  		output += stringFromCharCode(codePoint);
  		return output;
  	};
  
  	var hexEscape = function(symbol) {
  		return '&#x' + symbol.charCodeAt(0).toString(16).toUpperCase() + ';';
  	};
  
  	var parseError = function(message) {
  		throw Error('Parse error: ' + message);
  	};
  
  	/*--------------------------------------------------------------------------*/
  
  	var encode = function(string, options) {
  		options = merge(options, encode.options);
  		var strict = options.strict;
  		if (strict && regexInvalidRawCodePoint.test(string)) {
  			parseError('forbidden code point');
  		}
  		var encodeEverything = options.encodeEverything;
  		var useNamedReferences = options.useNamedReferences;
  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
  		if (encodeEverything) {
  			// Encode ASCII symbols.
  			string = string.replace(regexAsciiWhitelist, function(symbol) {
  				// Use named references if requested & possible.
  				if (useNamedReferences && has(encodeMap, symbol)) {
  					return '&' + encodeMap[symbol] + ';';
  				}
  				return hexEscape(symbol);
  			});
  			// Shorten a few escapes that represent two symbols, of which at least one
  			// is within the ASCII range.
  			if (useNamedReferences) {
  				string = string
  					.replace(/&gt;\u20D2/g, '&nvgt;')
  					.replace(/&lt;\u20D2/g, '&nvlt;')
  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
  			}
  			// Encode non-ASCII symbols.
  			if (useNamedReferences) {
  				// Encode non-ASCII symbols that can be replaced with a named reference.
  				string = string.replace(regexEncodeNonAscii, function(string) {
  					// Note: there is no need to check `has(encodeMap, string)` here.
  					return '&' + encodeMap[string] + ';';
  				});
  			}
  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
  		} else if (useNamedReferences) {
  			// Apply named character references.
  			// Encode `<>"'&` using named character references.
  			if (!allowUnsafeSymbols) {
  				string = string.replace(regexEscape, function(string) {
  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
  				});
  			}
  			// Shorten escapes that represent two symbols, of which at least one is
  			// `<>"'&`.
  			string = string
  				.replace(/&gt;\u20D2/g, '&nvgt;')
  				.replace(/&lt;\u20D2/g, '&nvlt;');
  			// Encode non-ASCII symbols that can be replaced with a named reference.
  			string = string.replace(regexEncodeNonAscii, function(string) {
  				// Note: there is no need to check `has(encodeMap, string)` here.
  				return '&' + encodeMap[string] + ';';
  			});
  		} else if (!allowUnsafeSymbols) {
  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
  			// using named character references.
  			string = string.replace(regexEscape, hexEscape);
  		}
  		return string
  			// Encode astral symbols.
  			.replace(regexAstralSymbols, function($0) {
  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
  				var high = $0.charCodeAt(0);
  				var low = $0.charCodeAt(1);
  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
  				return '&#x' + codePoint.toString(16).toUpperCase() + ';';
  			})
  			// Encode any remaining BMP symbols that are not printable ASCII symbols
  			// using a hexadecimal escape.
  			.replace(regexBmpWhitelist, hexEscape);
  	};
  	// Expose default options (so they can be overridden globally).
  	encode.options = {
  		'allowUnsafeSymbols': false,
  		'encodeEverything': false,
  		'strict': false,
  		'useNamedReferences': false
  	};
  
  	var decode = function(html, options) {
  		options = merge(options, decode.options);
  		var strict = options.strict;
  		if (strict && regexInvalidEntity.test(html)) {
  			parseError('malformed character reference');
  		}
  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7) {
  			var codePoint;
  			var semicolon;
  			var hexDigits;
  			var reference;
  			var next;
  			if ($1) {
  				// Decode decimal escapes, e.g. `&#119558;`.
  				codePoint = $1;
  				semicolon = $2;
  				if (strict && !semicolon) {
  					parseError('character reference was not terminated by a semicolon');
  				}
  				return codePointToSymbol(codePoint, strict);
  			}
  			if ($3) {
  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
  				hexDigits = $3;
  				semicolon = $4;
  				if (strict && !semicolon) {
  					parseError('character reference was not terminated by a semicolon');
  				}
  				codePoint = parseInt(hexDigits, 16);
  				return codePointToSymbol(codePoint, strict);
  			}
  			if ($5) {
  				// Decode named character references with trailing `;`, e.g. `&copy;`.
  				reference = $5;
  				if (has(decodeMap, reference)) {
  					return decodeMap[reference];
  				} else {
  					// Ambiguous ampersand; see http://mths.be/notes/ambiguous-ampersands.
  					if (strict) {
  						parseError(
  							'named character reference was not terminated by a semicolon'
  						);
  					}
  					return $0;
  				}
  			}
  			// If we’re still here, it’s a legacy reference for sure. No need for an
  			// extra `if` check.
  			// Decode named character references without trailing `;`, e.g. `&amp`
  			// This is only a parse error if it gets converted to `&`, or if it is
  			// followed by `=` in an attribute context.
  			reference = $6;
  			next = $7;
  			if (next && options.isAttributeValue) {
  				if (strict && next == '=') {
  					parseError('`&` did not start a character reference');
  				}
  				return $0;
  			} else {
  				if (strict) {
  					parseError(
  						'named character reference was not terminated by a semicolon'
  					);
  				}
  				// Note: there is no need to check `has(decodeMapLegacy, reference)`.
  				return decodeMapLegacy[reference] + (next || '');
  			}
  		});
  	};
  	// Expose default options (so they can be overridden globally).
  	decode.options = {
  		'isAttributeValue': false,
  		'strict': false
  	};
  
  	var escape = function(string) {
  		return string.replace(regexEscape, function($0) {
  			// Note: there is no need to check `has(escapeMap, $0)` here.
  			return escapeMap[$0];
  		});
  	};
  
  	/*--------------------------------------------------------------------------*/
  
  	var he = {
  		'version': '0.5.0',
  		'encode': encode,
  		'decode': decode,
  		'escape': escape,
  		'unescape': decode
  	};
  
  	// Some AMD build optimizers, like r.js, check for specific condition patterns
  	// like the following:
  	if (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define(function() {
  			return he;
  		});
  	}	else if (freeExports && !freeExports.nodeType) {
  		if (freeModule) { // in Node.js or RingoJS v0.8.0+
  			freeModule.exports = he;
  		} else { // in Narwhal or RingoJS v0.7.0-
  			for (var key in he) {
  				has(he, key) && (freeExports[key] = he[key]);
  			}
  		}
  	} else { // in Rhino or a web browser
  		root.he = he;
  	}
  
  }(this));
  
  
  /***/ }),
  
  /***/ 916:
  /***/ (function(__unusedmodule, exports) {
  
  "use strict";
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  const VERSION = "1.0.0";
  
  /**
   * @param octokit Octokit instance
   * @param options Options passed to Octokit constructor
   */
  
  function requestLog(octokit) {
    octokit.hook.wrap("request", (request, options) => {
      octokit.log.debug("request", options);
      const start = Date.now();
      const requestOptions = octokit.request.endpoint.parse(options);
      const path = requestOptions.url.replace(options.baseUrl, "");
      return request(options).then(response => {
        octokit.log.info(`${requestOptions.method} ${path} - ${response.status} in ${Date.now() - start}ms`);
        return response;
      }).catch(error => {
        octokit.log.info(`${requestOptions.method} ${path} - ${error.status} in ${Date.now() - start}ms`);
        throw error;
      });
    });
  }
  requestLog.VERSION = VERSION;
  
  exports.requestLog = requestLog;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 929:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  module.exports = hasNextPage
  
  const deprecate = __webpack_require__(370)
  const getPageLinks = __webpack_require__(577)
  
  function hasNextPage (link) {
    deprecate(`octokit.hasNextPage() – You can use octokit.paginate or async iterators instead: https://github.com/octokit/rest.js#pagination.`)
    return getPageLinks(link).next
  }
  
  
  /***/ }),
  
  /***/ 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) {}
  
  }
  
  /***/ }),
  
  /***/ 950:
  /***/ (function(__unusedmodule, exports, __webpack_require__) {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", { value: true });
  const url = __webpack_require__(835);
  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 = url.parse(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;
  
  
  /***/ }),
  
  /***/ 953:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  /**
   * @author Titus Wormer
   * @copyright 2015 Titus Wormer. All rights reserved.
   * @module Parse
   * @fileoverview Parse a markdown document into an
   *   abstract syntax tree.
   */
  
  
  
  /*
   * Dependencies.
   */
  
  var he = __webpack_require__(903);
  var repeat = __webpack_require__(8);
  var utilities = __webpack_require__(65);
  var defaultExpressions = __webpack_require__(302);
  var defaultOptions = __webpack_require__(575).parse;
  
  /*
   * Methods.
   */
  
  var clone = utilities.clone;
  var copy = utilities.copy;
  var raise = utilities.raise;
  var trim = utilities.trim;
  var trimRightLines = utilities.trimRightLines;
  var clean = utilities.clean;
  var validate = utilities.validate;
  var normalize = utilities.normalizeIdentifier;
  var objectCreate = utilities.create;
  var arrayPush = [].push;
  
  /*
   * Characters.
   */
  
  var AT_SIGN = '@';
  var CARET = '^';
  var EQUALS = '=';
  var EXCLAMATION_MARK = '!';
  var MAILTO_PROTOCOL = 'mailto:';
  var NEW_LINE = '\n';
  var SPACE = ' ';
  var TAB = '\t';
  var EMPTY = '';
  var LT = '<';
  var GT = '>';
  var BRACKET_OPEN = '[';
  
  /*
   * Types.
   */
  
  var BLOCK = 'block';
  var INLINE = 'inline';
  var HORIZONTAL_RULE = 'horizontalRule';
  var HTML = 'html';
  var YAML = 'yaml';
  var TABLE = 'table';
  var TABLE_CELL = 'tableCell';
  var TABLE_HEADER = 'tableHeader';
  var TABLE_ROW = 'tableRow';
  var PARAGRAPH = 'paragraph';
  var TEXT = 'text';
  var CODE = 'code';
  var LIST = 'list';
  var LIST_ITEM = 'listItem';
  var FOOTNOTE_DEFINITION = 'footnoteDefinition';
  var HEADING = 'heading';
  var BLOCKQUOTE = 'blockquote';
  var LINK = 'link';
  var IMAGE = 'image';
  var FOOTNOTE = 'footnote';
  var ESCAPE = 'escape';
  var STRONG = 'strong';
  var EMPHASIS = 'emphasis';
  var DELETE = 'delete';
  var INLINE_CODE = 'inlineCode';
  var BREAK = 'break';
  var ROOT = 'root';
  
  /**
   * Wrapper around he's `decode` function.
   *
   * @example
   *   decode('&amp;'); // '&'
   *   decode('&amp'); // '&'
   *
   * @param {string} value
   * @param {function(string)} eat
   * @return {string}
   * @throws {Error} - When `eat.file.quiet` is not `true`.
   *   However, by default `he` does not throw on incorrect
   *   encoded entities, but when
   *   `he.decode.options.strict: true`, they occur on
   *   entities with a missing closing semi-colon.
   */
  function decode(value, eat) {
      try {
          return he.decode(value);
      } catch (exception) {
          eat.file.fail(exception, eat.now());
      }
  }
  
  /**
   * Factory to de-escape a value, based on an expression
   * at `key` in `scope`.
   *
   * @example
   *   var expressions = {escape: /\\(a)/}
   *   var descape = descapeFactory(expressions, 'escape');
   *
   * @param {Object} scope - Map of expressions.
   * @param {string} key - Key in `map` at which the
   *   non-global expression exists.
   * @return {function(string): string} - Function which
   *   takes a value and returns its unescaped version.
   */
  function descapeFactory(scope, key) {
      var globalExpression;
      var expression;
  
      /**
       * Private method to get a global expression
       * from the expression at `key` in `scope`.
       * This method is smart about not recreating
       * the expressions every time.
       *
       * @private
       * @return {RegExp}
       */
      function generate() {
          if (scope[key] !== globalExpression) {
              globalExpression = scope[key];
              expression = new RegExp(
                  scope[key].source.replace(CARET, EMPTY), 'g'
              );
          }
  
          return expression;
      }
  
      /**
       * De-escape a string using the expression at `key`
       * in `scope`.
       *
       * @example
       *   var expressions = {escape: /\\(a)/}
       *   var descape = descapeFactory(expressions, 'escape');
       *   descape('\a'); // 'a'
       *
       * @param {string} value - Escaped string.
       * @return {string} - Unescaped string.
       */
      function descape(value) {
          return value.replace(generate(), '$1');
      }
  
      return descape;
  }
  
  /*
   * Tab size.
   */
  
  var TAB_SIZE = 4;
  
  /*
   * Expressions.
   */
  
  var EXPRESSION_RIGHT_ALIGNMENT = /^[ \t]*-+:[ \t]*$/;
  var EXPRESSION_CENTER_ALIGNMENT = /^[ \t]*:-+:[ \t]*$/;
  var EXPRESSION_LEFT_ALIGNMENT = /^[ \t]*:-+[ \t]*$/;
  var EXPRESSION_TABLE_FENCE = /^[ \t]*|\|[ \t]*$/g;
  var EXPRESSION_TABLE_INITIAL = /^[ \t]*\|/g;
  var EXPRESSION_TABLE_CONTENT =
      /[ \t]*?((?:\\[\s\S]|[^\|])+?)([ \t]?\|[ \t]?\n?|\n?$)/g;
  var EXPRESSION_TABLE_BORDER = /[ \t]*\|[ \t]*/;
  var EXPRESSION_BLOCK_QUOTE = /^[ \t]*>[ \t]?/gm;
  var EXPRESSION_BULLET = /^([ \t]*)([*+-]|\d+[.)])( {1,4}(?! )| |\t)([^\n]*)/;
  var EXPRESSION_PEDANTIC_BULLET = /^([ \t]*)([*+-]|\d+[.)])([ \t]+)/;
  var EXPRESSION_INITIAL_INDENT = /^( {1,4}|\t)?/gm;
  var EXPRESSION_INITIAL_TAB = /^( {4}|\t)?/gm;
  var EXPRESSION_HTML_LINK_OPEN = /^<a /i;
  var EXPRESSION_HTML_LINK_CLOSE = /^<\/a>/i;
  var EXPRESSION_LOOSE_LIST_ITEM = /\n\n(?!\s*$)/;
  var EXPRESSION_TASK_ITEM = /^\[([\ \t]|x|X)\][\ \t]/;
  
  /*
   * A map of characters, and their column length,
   * which can be used as indentation.
   */
  
  var INDENTATION_CHARACTERS = objectCreate();
  
  INDENTATION_CHARACTERS[SPACE] = SPACE.length;
  INDENTATION_CHARACTERS[TAB] = TAB_SIZE;
  
  /**
   * Gets indentation information for a line.
   *
   * @example
   *   getIndent('  foo');
   *   // {indent: 2, stops: {1: 0, 2: 1}}
   *
   *   getIndent('\tfoo');
   *   // {indent: 4, stops: {4: 0}}
   *
   *   getIndent('  \tfoo');
   *   // {indent: 4, stops: {1: 0, 2: 1, 4: 2}}
   *
   *   getIndent('\t  foo')
   *   // {indent: 6, stops: {4: 0, 5: 1, 6: 2}}
   *
   * @param {string} value - Indented line.
   * @return {Object}
   */
  function getIndent(value) {
      var index = 0;
      var indent = 0;
      var character = value.charAt(index);
      var stops = {};
      var size;
  
      while (character in INDENTATION_CHARACTERS) {
          size = INDENTATION_CHARACTERS[character];
  
          indent += size;
  
          if (size > 1) {
              indent = Math.floor(indent / size) * size;
          }
  
          stops[indent] = index;
  
          character = value.charAt(++index);
      }
  
      return {
          'indent': indent,
          'stops': stops
      };
  }
  
  /**
   * Remove the minimum indent from every line in `value`.
   * Supports both tab, spaced, and mixed indentation (as
   * well as possible).
   *
   * @example
   *   removeIndentation('  foo'); // 'foo'
   *   removeIndentation('    foo', 2); // '  foo'
   *   removeIndentation('\tfoo', 2); // '  foo'
   *   removeIndentation('  foo\n bar'); // ' foo\n bar'
   *
   * @param {string} value
   * @param {number?} [maximum] - Maximum indentation
   *   to remove.
   * @return {string} - Unindented `value`.
   */
  function removeIndentation(value, maximum) {
      var values = value.split(NEW_LINE);
      var position = values.length + 1;
      var minIndent = Infinity;
      var matrix = [];
      var index;
      var indentation;
      var stops;
      var padding;
  
      values.unshift(repeat(SPACE, maximum) + EXCLAMATION_MARK);
  
      while (position--) {
          indentation = getIndent(values[position]);
  
          matrix[position] = indentation.stops;
  
          if (trim(values[position]).length === 0) {
              continue;
          }
  
          if (indentation.indent) {
              if (indentation.indent > 0 && indentation.indent < minIndent) {
                  minIndent = indentation.indent;
              }
          } else {
              minIndent = Infinity;
  
              break;
          }
      }
  
      if (minIndent !== Infinity) {
          position = values.length;
  
          while (position--) {
              stops = matrix[position];
              index = minIndent;
  
              while (index && !(index in stops)) {
                  index--;
              }
  
              if (
                  trim(values[position]).length !== 0 &&
                  minIndent &&
                  index !== minIndent
              ) {
                  padding = TAB;
              } else {
                  padding = EMPTY;
              }
  
              values[position] = padding + values[position].slice(
                  index in stops ? stops[index] + 1 : 0
              );
          }
      }
  
      values.shift();
  
      return values.join(NEW_LINE);
  }
  
  /**
   * Ensure that `value` is at least indented with
   * `indent` spaces.  Does not support tabs. Does support
   * multiple lines.
   *
   * @example
   *   ensureIndentation('foo', 2); // '  foo'
   *   ensureIndentation('  foo', 4); // '    foo'
   *
   * @param {string} value
   * @param {number} indent - The maximum amount of
   *   spacing to insert.
   * @return {string} - indented `value`.
   */
  function ensureIndentation(value, indent) {
      var values = value.split(NEW_LINE);
      var length = values.length;
      var index = -1;
      var line;
      var position;
  
      while (++index < length) {
          line = values[index];
  
          position = -1;
  
          while (++position < indent) {
              if (line.charAt(position) !== SPACE) {
                  values[index] = repeat(SPACE, indent - position) + line;
                  break;
              }
          }
      }
  
      return values.join(NEW_LINE);
  }
  
  /**
   * Get the alignment from a table rule.
   *
   * @example
   *   getAlignment([':-', ':-:', '-:', '--']);
   *   // ['left', 'center', 'right', null];
   *
   * @param {Array.<string>} cells
   * @return {Array.<string?>}
   */
  function getAlignment(cells) {
      var results = [];
      var index = -1;
      var length = cells.length;
      var alignment;
  
      while (++index < length) {
          alignment = cells[index];
  
          if (EXPRESSION_RIGHT_ALIGNMENT.test(alignment)) {
              results[index] = 'right';
          } else if (EXPRESSION_CENTER_ALIGNMENT.test(alignment)) {
              results[index] = 'center';
          } else if (EXPRESSION_LEFT_ALIGNMENT.test(alignment)) {
              results[index] = 'left';
          } else {
              results[index] = null;
          }
      }
  
      return results;
  }
  
  /**
   * Construct a state `toggler`: a function which inverses
   * `property` in context based on its current value.
   * The by `toggler` returned function restores that value.
   *
   * @example
   *   var context = {};
   *   var key = 'foo';
   *   var val = true;
   *   context[key] = val;
   *   context.enter = stateToggler(key, val);
   *   context[key]; // true
   *   var exit = context.enter();
   *   context[key]; // false
   *   var nested = context.enter();
   *   context[key]; // false
   *   nested();
   *   context[key]; // false
   *   exit();
   *   context[key]; // true
   *
   * @param {string} key - Property to toggle.
   * @param {boolean} state - It's default state.
   * @return {function(): function()} - Enter.
   */
  function stateToggler(key, state) {
      /**
       * Construct a toggler for the bound `key`.
       *
       * @return {Function} - Exit state.
       */
      function enter() {
          var self = this;
          var current = self[key];
  
          self[key] = !state;
  
          /**
           * State canceler, cancels the state, if allowed.
           */
          function exit() {
              self[key] = current;
          }
  
          return exit;
      }
  
      return enter;
  }
  
  /**
   * Construct a state toggler which doesn't toggle.
   *
   * @example
   *   var context = {};
   *   var key = 'foo';
   *   var val = true;
   *   context[key] = val;
   *   context.enter = noopToggler();
   *   context[key]; // true
   *   var exit = context.enter();
   *   context[key]; // true
   *   exit();
   *   context[key]; // true
   *
   * @return {function(): function()} - Enter.
   */
  function noopToggler() {
      /**
       * No-operation.
       */
      function exit() {}
  
      /**
       * @return {Function}
       */
      function enter() {
          return exit;
      }
  
      return enter;
  }
  
  /*
   * Define nodes of a type which can be merged.
   */
  
  var MERGEABLE_NODES = objectCreate();
  
  /**
   * Merge two text nodes: `token` into `prev`.
   *
   * @param {Object} prev - Preceding sibling.
   * @param {Object} token - Following sibling.
   * @return {Object} - `prev`.
   */
  MERGEABLE_NODES.text = function (prev, token) {
      prev.value += token.value;
  
      return prev;
  };
  
  /**
   * Merge two blockquotes: `token` into `prev`, unless in
   * CommonMark mode.
   *
   * @param {Object} prev - Preceding sibling.
   * @param {Object} token - Following sibling.
   * @return {Object} - `prev`, or `token` in CommonMark mode.
   */
  MERGEABLE_NODES.blockquote = function (prev, token) {
      if (this.options.commonmark) {
          return token;
      }
  
      prev.children = prev.children.concat(token.children);
  
      return prev;
  };
  
  /**
   * Merge two lists: `token` into `prev`. Knows, about
   * which bullets were used.
   *
   * @param {Object} prev - Preceding sibling.
   * @param {Object} token - Following sibling.
   * @return {Object} - `prev`, or `token` when the lists are
   *   of different types (a different bullet is used).
   */
  MERGEABLE_NODES.list = function (prev, token) {
      if (
          !this.currentBullet ||
          this.currentBullet !== this.previousBullet ||
          this.currentBullet.length !== 1
      ) {
          return token;
      }
  
      prev.children = prev.children.concat(token.children);
  
      return prev;
  };
  
  /**
   * Tokenise a line.  Unsets `currentBullet` and
   * `previousBullet` if more than one lines are found, thus
   * preventing lists from merging when they use different
   * bullets.
   *
   * @example
   *   tokenizeNewline(eat, '\n\n');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Lines.
   */
  function tokenizeNewline(eat, $0) {
      if ($0.length > 1) {
          this.currentBullet = null;
          this.previousBullet = null;
      }
  
      eat($0);
  }
  
  /**
   * Tokenise an indented code block.
   *
   * @example
   *   tokenizeCode(eat, '\tfoo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole code.
   * @return {Node} - `code` node.
   */
  function tokenizeCode(eat, $0) {
      $0 = trimRightLines($0);
  
      return eat($0)(this.renderCodeBlock(
          removeIndentation($0, TAB_SIZE), null, eat)
      );
  }
  
  /**
   * Tokenise a fenced code block.
   *
   * @example
   *   var $0 = '```js\nfoo()\n```';
   *   tokenizeFences(eat, $0, '', '```', '`', 'js', 'foo()\n');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole code.
   * @param {string} $1 - Initial spacing.
   * @param {string} $2 - Initial fence.
   * @param {string} $3 - Fence marker.
   * @param {string} $4 - Programming language flag.
   * @param {string} $5 - Content.
   * @return {Node} - `code` node.
   */
  function tokenizeFences(eat, $0, $1, $2, $3, $4, $5) {
      $0 = trimRightLines($0);
  
      /*
       * If the initial fence was preceded by spaces,
       * exdent that amount of white space from the code
       * block.  Because it's possible that the code block
       * is exdented, we first have to ensure at least
       * those spaces are available.
       */
  
      if ($1) {
          $5 = removeIndentation(ensureIndentation($5, $1.length), $1.length);
      }
  
      return eat($0)(this.renderCodeBlock($5, $4, eat));
  }
  
  /**
   * Tokenise an ATX-style heading.
   *
   * @example
   *   tokenizeHeading(eat, ' # foo', ' ', '#', ' ', 'foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole heading.
   * @param {string} $1 - Initial spacing.
   * @param {string} $2 - Hashes.
   * @param {string} $3 - Internal spacing.
   * @param {string} $4 - Content.
   * @return {Node} - `heading` node.
   */
  function tokenizeHeading(eat, $0, $1, $2, $3, $4) {
      var now = eat.now();
  
      now.column += ($1 + $2 + ($3 || '')).length;
  
      return eat($0)(this.renderHeading($4, $2.length, now));
  }
  
  /**
   * Tokenise a Setext-style heading.
   *
   * @example
   *   tokenizeLineHeading(eat, 'foo\n===', '', 'foo', '=');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole heading.
   * @param {string} $1 - Initial spacing.
   * @param {string} $2 - Content.
   * @param {string} $3 - Underline marker.
   * @return {Node} - `heading` node.
   */
  function tokenizeLineHeading(eat, $0, $1, $2, $3) {
      var now = eat.now();
  
      now.column += $1.length;
  
      return eat($0)(this.renderHeading($2, $3 === EQUALS ? 1 : 2, now));
  }
  
  /**
   * Tokenise a horizontal rule.
   *
   * @example
   *   tokenizeHorizontalRule(eat, '***');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole rule.
   * @return {Node} - `horizontalRule` node.
   */
  function tokenizeHorizontalRule(eat, $0) {
      return eat($0)(this.renderVoid(HORIZONTAL_RULE));
  }
  
  /**
   * Tokenise a blockquote.
   *
   * @example
   *   tokenizeBlockquote(eat, '> Foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole blockquote.
   * @return {Node} - `blockquote` node.
   */
  function tokenizeBlockquote(eat, $0) {
      var now = eat.now();
      var indent = this.indent(now.line);
      var value = trimRightLines($0);
      var add = eat(value);
  
      value = value.replace(EXPRESSION_BLOCK_QUOTE, function (prefix) {
          indent(prefix.length);
  
          return '';
      });
  
      return add(this.renderBlockquote(value, now));
  }
  
  /**
   * Tokenise a list.
   *
   * @example
   *   tokenizeList(eat, '- Foo', '', '-');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole list.
   * @param {string} $1 - Indent.
   * @param {string} $2 - Bullet.
   * @return {Node} - `list` node.
   */
  function tokenizeList(eat, $0, $1, $2) {
      var self = this;
      var firstBullet = $2;
      var value = trimRightLines($0);
      var matches = value.match(self.rules.item);
      var length = matches.length;
      var index = 0;
      var isLoose = false;
      var now;
      var bullet;
      var item;
      var enterTop;
      var exitBlockquote;
      var node;
      var indent;
      var size;
      var position;
      var end;
  
      /*
       * Determine if all list-items belong to the
       * same list.
       */
  
      if (!self.options.pedantic) {
          while (++index < length) {
              bullet = self.rules.bullet.exec(matches[index])[0];
  
              if (
                  firstBullet !== bullet &&
                  (
                      firstBullet.length === 1 && bullet.length === 1 ||
                      bullet.charAt(bullet.length - 1) !==
                      firstBullet.charAt(firstBullet.length - 1)
                  )
              ) {
                  matches = matches.slice(0, index);
                  matches[index - 1] = trimRightLines(matches[index - 1]);
  
                  length = matches.length;
  
                  break;
              }
          }
      }
  
      if (self.options.commonmark) {
          index = -1;
  
          while (++index < length) {
              item = matches[index];
              indent = self.rules.indent.exec(item);
              indent = indent[1] + repeat(SPACE, indent[2].length) + indent[3];
              size = getIndent(indent).indent;
              position = indent.length;
              end = item.length;
  
              while (++position < end) {
                  if (
                      item.charAt(position) === NEW_LINE &&
                      item.charAt(position - 1) === NEW_LINE &&
                      getIndent(item.slice(position + 1)).indent < size
                  ) {
                      matches[index] = item.slice(0, position - 1);
  
                      matches = matches.slice(0, index + 1);
                      length = matches.length;
  
                      break;
                  }
              }
          }
      }
  
      self.previousBullet = self.currentBullet;
      self.currentBullet = firstBullet;
  
      index = -1;
  
      node = eat(matches.join(NEW_LINE)).reset(
          self.renderList([], firstBullet)
      );
  
      enterTop = self.exitTop();
      exitBlockquote = self.enterBlockquote();
  
      while (++index < length) {
          item = matches[index];
          now = eat.now();
  
          item = eat(item)(self.renderListItem(item, now), node);
  
          if (item.loose) {
              isLoose = true;
          }
  
          if (index !== length - 1) {
              eat(NEW_LINE);
          }
      }
  
      node.loose = isLoose;
  
      enterTop();
      exitBlockquote();
  
      return node;
  }
  
  /**
   * Tokenise HTML.
   *
   * @example
   *   tokenizeHtml(eat, '<span>foo</span>');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole HTML.
   * @return {Node} - `html` node.
   */
  function tokenizeHtml(eat, $0) {
      $0 = trimRightLines($0);
  
      return eat($0)(this.renderRaw(HTML, $0));
  }
  
  /**
   * Tokenise a definition.
   *
   * @example
   *   var $0 = '[foo]: http://example.com "Example Domain"';
   *   var $1 = 'foo';
   *   var $2 = 'http://example.com';
   *   var $3 = 'Example Domain';
   *   tokenizeDefinition(eat, $0, $1, $2, $3);
   *
   * @property {boolean} onlyAtTop
   * @property {boolean} notInBlockquote
   * @param {function(string)} eat
   * @param {string} $0 - Whole definition.
   * @param {string} $1 - Key.
   * @param {string} $2 - URL.
   * @param {string} $3 - Title.
   * @return {Node} - `definition` node.
   */
  function tokenizeDefinition(eat, $0, $1, $2, $3) {
      var link = $2;
  
      /*
       * Remove angle-brackets from `link`.
       */
  
      if (link.charAt(0) === LT && link.charAt(link.length - 1) === GT) {
          link = link.slice(1, -1);
      }
  
      return eat($0)({
          'type': 'definition',
          'identifier': normalize($1),
          'title': $3 ? decode(this.descape($3), eat) : null,
          'link': decode(this.descape(link), eat)
      });
  }
  
  tokenizeDefinition.onlyAtTop = true;
  tokenizeDefinition.notInBlockquote = true;
  
  /**
   * Tokenise YAML front matter.
   *
   * @example
   *   var $0 = '---\nfoo: bar\n---';
   *   var $1 = 'foo: bar';
   *   tokenizeYAMLFrontMatter(eat, $0, $1);
   *
   * @property {boolean} onlyAtStart
   * @param {function(string)} eat
   * @param {string} $0 - Whole front matter.
   * @param {string} $1 - Content.
   * @return {Node} - `yaml` node.
   */
  function tokenizeYAMLFrontMatter(eat, $0, $1) {
      return eat($0)(this.renderRaw(YAML, $1 ? trimRightLines($1) : EMPTY));
  }
  
  tokenizeYAMLFrontMatter.onlyAtStart = true;
  
  /**
   * Tokenise a footnote definition.
   *
   * @example
   *   var $0 = '[foo]: Bar.';
   *   var $1 = '[foo]';
   *   var $2 = 'foo';
   *   var $3 = 'Bar.';
   *   tokenizeFootnoteDefinition(eat, $0, $1, $2, $3);
   *
   * @property {boolean} onlyAtTop
   * @property {boolean} notInBlockquote
   * @param {function(string)} eat
   * @param {string} $0 - Whole definition.
   * @param {string} $1 - Whole key.
   * @param {string} $2 - Key.
   * @param {string} $3 - Whole value.
   * @return {Node} - `footnoteDefinition` node.
   */
  function tokenizeFootnoteDefinition(eat, $0, $1, $2, $3) {
      var self = this;
      var now = eat.now();
      var indent = self.indent(now.line);
  
      $3 = $3.replace(EXPRESSION_INITIAL_TAB, function (value) {
          indent(value.length);
  
          return EMPTY;
      });
  
      now.column += $1.length;
  
      return eat($0)(self.renderFootnoteDefinition(normalize($2), $3, now));
  }
  
  tokenizeFootnoteDefinition.onlyAtTop = true;
  tokenizeFootnoteDefinition.notInBlockquote = true;
  
  /**
   * Tokenise a table.
   *
   * @example
   *   var $0 = ' | foo |\n | --- |\n | bar |';
   *   var $1 = ' | foo |';
   *   var $2 = '| foo |';
   *   var $3 = ' | --- |';
   *   var $4 = '| --- |';
   *   var $5 = ' | bar |';
   *   tokenizeTable(eat, $0, $1, $2, $3, $4, $5);
   *
   * @property {boolean} onlyAtTop
   * @param {function(string)} eat
   * @param {string} $0 - Whole table.
   * @param {string} $1 - Whole heading.
   * @param {string} $2 - Trimmed heading.
   * @param {string} $3 - Whole alignment.
   * @param {string} $4 - Trimmed alignment.
   * @param {string} $5 - Rows.
   * @return {Node} - `table` node.
   */
  function tokenizeTable(eat, $0, $1, $2, $3, $4, $5) {
      var self = this;
      var node;
      var index;
      var length;
  
      $0 = trimRightLines($0);
  
      node = eat($0).reset({
          'type': TABLE,
          'align': [],
          'children': []
      });
  
      /**
       * Eat a fence.  Returns an empty string so it can be
       * passed to `String#replace()`.
       *
       * @param {string} value - Fence.
       * @return {string} - Empty string.
       */
      function eatFence(value) {
          eat(value);
  
          return EMPTY;
      }
  
      /**
       * Factory to eat a cell to a bound `row`.
       *
       * @param {Object} row - Parent to add cells to.
       * @return {Function} - `eatCell` bound to `row`.
       */
      function eatCellFactory(row) {
          /**
           * Eat a cell.  Returns an empty string so it can be
           * passed to `String#replace()`.
           *
           * @param {string} value - Complete match.
           * @param {string} content - Cell content.
           * @param {string} pipe - Fence.
           * @return {string} - Empty string.
           */
          function eatCell(value, content, pipe) {
              var cell = utilities.trimLeft(content);
              var diff = content.length - cell.length;
              var now;
  
              eat(content.slice(0, diff));
  
              now = eat.now();
  
              eat(cell)(self.renderInline(
                  TABLE_CELL, utilities.trimRight(cell), now
              ), row);
  
              eat(pipe);
  
              return EMPTY;
          }
  
          return eatCell;
      }
  
      /**
       * Eat a row of type `type`.
       *
       * @param {string} type - Type of the returned node,
       *   such as `tableHeader` or `tableRow`.
       * @param {string} value - Row, including initial and
       *   final fences.
       */
      function renderRow(type, value) {
          var row = eat(value).reset(self.renderParent(type, []), node);
  
          value
              .replace(EXPRESSION_TABLE_INITIAL, eatFence)
              .replace(EXPRESSION_TABLE_CONTENT, eatCellFactory(row));
      }
  
      /*
       * Add the table's header.
       */
  
      renderRow(TABLE_HEADER, $1);
  
      eat(NEW_LINE);
  
      /*
       * Add the table's alignment.
       */
  
      eat($3);
  
      $4 = $4
          .replace(EXPRESSION_TABLE_FENCE, EMPTY)
          .split(EXPRESSION_TABLE_BORDER);
  
      node.align = getAlignment($4);
  
      /*
       * Add the table rows to table's children.
       */
  
      $5 = trimRightLines($5).split(NEW_LINE);
  
      index = -1;
      length = $5.length;
  
      while (++index < length) {
          renderRow(TABLE_ROW, $5[index]);
  
          if (index !== length - 1) {
              eat(NEW_LINE);
          }
      }
  
      return node;
  }
  
  tokenizeTable.onlyAtTop = true;
  
  /**
   * Tokenise a paragraph token.
   *
   * @example
   *   tokenizeParagraph(eat, 'Foo.');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole paragraph.
   * @return {Node?} - `paragraph` node, when the node does
   *   not just contain white space.
   */
  function tokenizeParagraph(eat, $0) {
      var now = eat.now();
  
      if (trim($0) === EMPTY) {
          eat($0);
  
          return null;
      }
  
      $0 = trimRightLines($0);
  
      return eat($0)(this.renderInline(PARAGRAPH, $0, now));
  }
  
  /**
   * Tokenise a text token.
   *
   * @example
   *   tokenizeText(eat, 'foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole text.
   * @return {Node} - `text` node.
   */
  function tokenizeText(eat, $0) {
      return eat($0)(this.renderRaw(TEXT, $0));
  }
  
  /**
   * Create a code-block token.
   *
   * @example
   *   renderCodeBlock('foo()', 'js', now());
   *
   * @param {string?} [value] - Code.
   * @param {string?} [language] - Optional language flag.
   * @param {Function} eat
   * @return {Object} - `code` node.
   */
  function renderCodeBlock(value, language, eat) {
      return {
          'type': CODE,
          'lang': language ? decode(this.descape(language), eat) : null,
          'value': trimRightLines(value || EMPTY)
      };
  }
  
  /**
   * Create a list token.
   *
   * @example
   *   var children = [renderListItem('- foo')];
   *   renderList(children, '-');
   *
   * @param {string} children - Children.
   * @param {string} bullet - First bullet.
   * @return {Object} - `list` node.
   */
  function renderList(children, bullet) {
      var start = parseInt(bullet, 10);
  
      if (start !== start) {
          start = null;
      }
  
      /*
       * `loose` should be added later.
       */
  
      return {
          'type': LIST,
          'ordered': bullet.length > 1,
          'start': start,
          'loose': null,
          'children': children
      };
  }
  
  /**
   * Create a list-item using overly simple mechanics.
   *
   * @example
   *   renderPedanticListItem('- _foo_', now());
   *
   * @param {string} value - List-item.
   * @param {Object} position - List-item location.
   * @return {string} - Cleaned `value`.
   */
  function renderPedanticListItem(value, position) {
      var self = this;
      var indent = self.indent(position.line);
  
      /**
       * A simple replacer which removed all matches,
       * and adds their length to `offset`.
       *
       * @param {string} $0
       * @return {string}
       */
      function replacer($0) {
          indent($0.length);
  
          return EMPTY;
      }
  
      /*
       * Remove the list-item's bullet.
       */
  
      value = value.replace(EXPRESSION_PEDANTIC_BULLET, replacer);
  
      /*
       * The initial line was also matched by the below, so
       * we reset the `line`.
       */
  
      indent = self.indent(position.line);
  
      return value.replace(EXPRESSION_INITIAL_INDENT, replacer);
  }
  
  /**
   * Create a list-item using sane mechanics.
   *
   * @example
   *   renderNormalListItem('- _foo_', now());
   *
   * @param {string} value - List-item.
   * @param {Object} position - List-item location.
   * @return {string} - Cleaned `value`.
   */
  function renderNormalListItem(value, position) {
      var self = this;
      var indent = self.indent(position.line);
      var bullet;
      var rest;
      var lines;
      var trimmedLines;
      var index;
      var length;
      var max;
  
      /*
       * Remove the list-item's bullet.
       */
  
      value = value.replace(EXPRESSION_BULLET, function ($0, $1, $2, $3, $4) {
          bullet = $1 + $2 + $3;
          rest = $4;
  
         /*
          * Make sure that the first nine numbered list items
          * can indent with an extra space.  That is, when
          * the bullet did not receive an extra final space.
          */
  
          if (Number($2) < 10 && bullet.length % 2 === 1) {
              $2 = SPACE + $2;
          }
  
          max = $1 + repeat(SPACE, $2.length) + $3;
  
          return max + rest;
      });
  
      lines = value.split(NEW_LINE);
  
      trimmedLines = removeIndentation(
          value, getIndent(max).indent
      ).split(NEW_LINE);
  
      /*
       * We replaced the initial bullet with something
       * else above, which was used to trick
       * `removeIndentation` into removing some more
       * characters when possible. However, that could
       * result in the initial line to be stripped more
       * than it should be.
       */
  
      trimmedLines[0] = rest;
  
      indent(bullet.length);
  
      index = 0;
      length = lines.length;
  
      while (++index < length) {
          indent(lines[index].length - trimmedLines[index].length);
      }
  
      return trimmedLines.join(NEW_LINE);
  }
  
  /*
   * A map of two functions which can create list items.
   */
  
  var LIST_ITEM_MAP = objectCreate();
  
  LIST_ITEM_MAP.true = renderPedanticListItem;
  LIST_ITEM_MAP.false = renderNormalListItem;
  
  /**
   * Create a list-item token.
   *
   * @example
   *   renderListItem('- _foo_', now());
   *
   * @param {Object} value - List-item.
   * @param {Object} position - List-item location.
   * @return {Object} - `listItem` node.
   */
  function renderListItem(value, position) {
      var self = this;
      var checked = null;
      var node;
      var task;
      var indent;
  
      value = LIST_ITEM_MAP[self.options.pedantic].apply(self, arguments);
  
      if (self.options.gfm) {
          task = value.match(EXPRESSION_TASK_ITEM);
  
          if (task) {
              indent = task[0].length;
              checked = task[1].toLowerCase() === 'x';
  
              self.indent(position.line)(indent);
              value = value.slice(indent);
          }
      }
  
      node = {
          'type': LIST_ITEM,
          'loose': EXPRESSION_LOOSE_LIST_ITEM.test(value) ||
              value.charAt(value.length - 1) === NEW_LINE
      };
  
      if (self.options.gfm) {
          node.checked = checked;
      }
  
      node.children = self.tokenizeBlock(value, position);
  
      return node;
  }
  
  /**
   * Create a footnote-definition token.
   *
   * @example
   *   renderFootnoteDefinition('1', '_foo_', now());
   *
   * @param {string} identifier - Unique reference.
   * @param {string} value - Contents
   * @param {Object} position - Definition location.
   * @return {Object} - `footnoteDefinition` node.
   */
  function renderFootnoteDefinition(identifier, value, position) {
      var self = this;
      var exitBlockquote = self.enterBlockquote();
      var token;
  
      token = {
          'type': FOOTNOTE_DEFINITION,
          'identifier': identifier,
          'children': self.tokenizeBlock(value, position)
      };
  
      exitBlockquote();
  
      return token;
  }
  
  /**
   * Create a heading token.
   *
   * @example
   *   renderHeading('_foo_', 1, now());
   *
   * @param {string} value - Content.
   * @param {number} depth - Heading depth.
   * @param {Object} position - Heading content location.
   * @return {Object} - `heading` node
   */
  function renderHeading(value, depth, position) {
      return {
          'type': HEADING,
          'depth': depth,
          'children': this.tokenizeInline(value, position)
      };
  }
  
  /**
   * Create a blockquote token.
   *
   * @example
   *   renderBlockquote('_foo_', eat);
   *
   * @param {string} value - Content.
   * @param {Object} now - Position.
   * @return {Object} - `blockquote` node.
   */
  function renderBlockquote(value, now) {
      var self = this;
      var exitBlockquote = self.enterBlockquote();
      var token = {
          'type': BLOCKQUOTE,
          'children': this.tokenizeBlock(value, now)
      };
  
      exitBlockquote();
  
      return token;
  }
  
  /**
   * Create a void token.
   *
   * @example
   *   renderVoid('horizontalRule');
   *
   * @param {string} type - Node type.
   * @return {Object} - Node of type `type`.
   */
  function renderVoid(type) {
      return {
          'type': type
      };
  }
  
  /**
   * Create a parent.
   *
   * @example
   *   renderParent('paragraph', '_foo_');
   *
   * @param {string} type - Node type.
   * @param {Array.<Object>} children - Child nodes.
   * @return {Object} - Node of type `type`.
   */
  function renderParent(type, children) {
      return {
          'type': type,
          'children': children
      };
  }
  
  /**
   * Create a raw token.
   *
   * @example
   *   renderRaw('inlineCode', 'foo()');
   *
   * @param {string} type - Node type.
   * @param {string} value - Contents.
   * @return {Object} - Node of type `type`.
   */
  function renderRaw(type, value) {
      return {
          'type': type,
          'value': value
      };
  }
  
  /**
   * Create a link token.
   *
   * @example
   *   renderLink(true, 'example.com', 'example', 'Example Domain', now(), eat);
   *   renderLink(false, 'fav.ico', 'example', 'Example Domain', now(), eat);
   *
   * @param {boolean} isLink - Whether linking to a document
   *   or an image.
   * @param {string} href - URI reference.
   * @param {string} text - Content.
   * @param {string?} title - Title.
   * @param {Object} position - Location of link.
   * @param {function(string)} eat
   * @return {Object} - `link` or `image` node.
   */
  function renderLink(isLink, href, text, title, position, eat) {
      var self = this;
      var exitLink = self.enterLink();
      var token;
  
      token = {
          'type': isLink ? LINK : IMAGE,
          'title': title ? decode(self.descape(title), eat) : null
      };
  
      href = decode(href, eat);
  
      if (isLink) {
          token.href = href;
          token.children = self.tokenizeInline(text, position);
      } else {
          token.src = href;
          token.alt = text ? decode(self.descape(text), eat) : null;
      }
  
      exitLink();
  
      return token;
  }
  
  /**
   * Create a footnote token.
   *
   * @example
   *   renderFootnote('_foo_', now());
   *
   * @param {string} value - Contents.
   * @param {Object} position - Location of footnote.
   * @return {Object} - `footnote` node.
   */
  function renderFootnote(value, position) {
      return this.renderInline(FOOTNOTE, value, position);
  }
  
  /**
   * Add a token with inline content.
   *
   * @example
   *   renderInline('strong', '_foo_', now());
   *
   * @param {string} type - Node type.
   * @param {string} value - Contents.
   * @param {Object} position - Location of node.
   * @return {Object} - Node of type `type`.
   */
  function renderInline(type, value, position) {
      return this.renderParent(type, this.tokenizeInline(value, position));
  }
  
  /**
   * Add a token with block content.
   *
   * @example
   *   renderBlock('blockquote', 'Foo.', now());
   *
   * @param {string} type - Node type.
   * @param {string} value - Contents.
   * @param {Object} position - Location of node.
   * @return {Object} - Node of type `type`.
   */
  function renderBlock(type, value, position) {
      return this.renderParent(type, this.tokenizeBlock(value, position));
  }
  
  /**
   * Tokenise an escape sequence.
   *
   * @example
   *   tokenizeEscape(eat, '\\a', 'a');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole escape.
   * @param {string} $1 - Escaped character.
   * @return {Node} - `escape` node.
   */
  function tokenizeEscape(eat, $0, $1) {
      return eat($0)(this.renderRaw(ESCAPE, $1));
  }
  
  /**
   * Tokenise a URL in carets.
   *
   * @example
   *   tokenizeAutoLink(eat, '<http://foo.bar>', 'http://foo.bar', '');
   *
   * @property {boolean} notInLink
   * @param {function(string)} eat
   * @param {string} $0 - Whole link.
   * @param {string} $1 - URL.
   * @param {string?} [$2] - Protocol or at.
   * @return {Node} - `link` node.
   */
  function tokenizeAutoLink(eat, $0, $1, $2) {
      var self = this;
      var href = $1;
      var text = $1;
      var now = eat.now();
      var offset = 1;
      var tokenize;
      var node;
  
      if ($2 === AT_SIGN) {
          if (
              text.substr(0, MAILTO_PROTOCOL.length).toLowerCase() !==
              MAILTO_PROTOCOL
          ) {
              href = MAILTO_PROTOCOL + text;
          } else {
              text = text.substr(MAILTO_PROTOCOL.length);
              offset += MAILTO_PROTOCOL.length;
          }
      }
  
      now.column += offset;
  
      /*
       * Temporarily remove support for escapes in autolinks.
       */
  
      tokenize = self.inlineTokenizers.escape;
      self.inlineTokenizers.escape = null;
  
      node = eat($0)(self.renderLink(true, href, text, null, now, eat));
  
      self.inlineTokenizers.escape = tokenize;
  
      return node;
  }
  
  tokenizeAutoLink.notInLink = true;
  
  /**
   * Tokenise a URL in text.
   *
   * @example
   *   tokenizeURL(eat, 'http://foo.bar');
   *
   * @property {boolean} notInLink
   * @param {function(string)} eat
   * @param {string} $0 - Whole link.
   * @return {Node} - `link` node.
   */
  function tokenizeURL(eat, $0) {
      var now = eat.now();
  
      return eat($0)(this.renderLink(true, $0, $0, null, now, eat));
  }
  
  tokenizeURL.notInLink = true;
  
  /**
   * Tokenise an HTML tag.
   *
   * @example
   *   tokenizeTag(eat, '<span foo="bar">');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Content.
   * @return {Node} - `html` node.
   */
  function tokenizeTag(eat, $0) {
      var self = this;
  
      if (!self.inLink && EXPRESSION_HTML_LINK_OPEN.test($0)) {
          self.inLink = true;
      } else if (self.inLink && EXPRESSION_HTML_LINK_CLOSE.test($0)) {
          self.inLink = false;
      }
  
      return eat($0)(self.renderRaw(HTML, $0));
  }
  
  /**
   * Tokenise a link.
   *
   * @example
   *   tokenizeLink(
   *     eat, '![foo](fav.ico "Favicon")', '![', 'foo', null,
   *     'fav.ico', 'Foo Domain'
   *   );
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole link.
   * @param {string} $1 - Prefix.
   * @param {string} $2 - Text.
   * @param {string?} $3 - URL wrapped in angle braces.
   * @param {string?} $4 - Literal URL.
   * @param {string?} $5 - Title wrapped in single or double
   *   quotes.
   * @param {string?} [$6] - Title wrapped in double quotes.
   * @param {string?} [$7] - Title wrapped in parentheses.
   * @return {Node?} - `link` node, `image` node, or `null`.
   */
  function tokenizeLink(eat, $0, $1, $2, $3, $4, $5, $6, $7) {
      var isLink = $1 === BRACKET_OPEN;
      var href = $4 || $3 || '';
      var title = $7 || $6 || $5;
      var now;
  
      if (!isLink || !this.inLink) {
          now = eat.now();
  
          now.column += $1.length;
  
          return eat($0)(this.renderLink(
              isLink, this.descape(href), $2, title, now, eat
          ));
      }
  
      return null;
  }
  
  /**
   * Tokenise a reference link, image, or footnote;
   * shortcut reference link, or footnote.
   *
   * @example
   *   tokenizeReference(eat, '[foo]', '[', 'foo');
   *   tokenizeReference(eat, '[foo][]', '[', 'foo', '');
   *   tokenizeReference(eat, '[foo][bar]', '[', 'foo', 'bar');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole link.
   * @param {string} $1 - Prefix.
   * @param {string} $2 - identifier.
   * @param {string} $3 - Content.
   * @return {Node?} - `linkReference`, `imageReference`, or
   *   `footnoteReference`.  Returns null when this is a link
   *   reference, but we're already in a link.
   */
  function tokenizeReference(eat, $0, $1, $2, $3) {
      var self = this;
      var text = $2;
      var identifier = $3 || $2;
      var type = $1 === BRACKET_OPEN ? 'link' : 'image';
      var isFootnote = self.options.footnotes && identifier.charAt(0) === CARET;
      var now = eat.now();
      var referenceType;
      var node;
      var exitLink;
  
      if ($3 === undefined) {
          referenceType = 'shortcut';
      } else if ($3 === '') {
          referenceType = 'collapsed';
      } else {
          referenceType = 'full';
      }
  
      if (referenceType !== 'shortcut') {
          isFootnote = false;
      }
  
      if (isFootnote) {
          identifier = identifier.substr(1);
      }
  
      if (isFootnote) {
          if (identifier.indexOf(SPACE) !== -1) {
              return eat($0)(self.renderFootnote(identifier, eat.now()));
          } else {
              type = 'footnote';
          }
      }
  
      if (self.inLink && type === 'link') {
          return null;
      }
  
      now.column += $1.length;
  
      node = {
          'type': type + 'Reference',
          'identifier': normalize(identifier)
      };
  
      if (type === 'link' || type === 'image') {
          node.referenceType = referenceType;
      }
  
      if (type === 'link') {
          exitLink = self.enterLink();
          node.children = self.tokenizeInline(text, now);
          exitLink();
      } else if (type === 'image') {
          node.alt = decode(self.descape(text), eat);
      }
  
      return eat($0)(node);
  }
  
  /**
   * Tokenise strong emphasis.
   *
   * @example
   *   tokenizeStrong(eat, '**foo**', '**', 'foo');
   *   tokenizeStrong(eat, '__foo__', null, null, '__', 'foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole emphasis.
   * @param {string?} $1 - Marker.
   * @param {string?} $2 - Content.
   * @param {string?} [$3] - Marker.
   * @param {string?} [$4] - Content.
   * @return {Node?} - `strong` node, when not empty.
   */
  function tokenizeStrong(eat, $0, $1, $2, $3, $4) {
      var now = eat.now();
      var value = $2 || $4;
  
      if (trim(value) === EMPTY) {
          return null;
      }
  
      now.column += 2;
  
      return eat($0)(this.renderInline(STRONG, value, now));
  }
  
  /**
   * Tokenise slight emphasis.
   *
   * @example
   *   tokenizeEmphasis(eat, '*foo*', '*', 'foo');
   *   tokenizeEmphasis(eat, '_foo_', null, null, '_', 'foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole emphasis.
   * @param {string?} $1 - Marker.
   * @param {string?} $2 - Content.
   * @param {string?} [$3] - Marker.
   * @param {string?} [$4] - Content.
   * @return {Node?} - `emphasis` node, when not empty.
   */
  function tokenizeEmphasis(eat, $0, $1, $2, $3, $4) {
      var now = eat.now();
      var marker = $1 || $3;
      var value = $2 || $4;
  
      if (
          trim(value) === EMPTY ||
          value.charAt(0) === marker ||
          value.charAt(value.length - 1) === marker
      ) {
          return null;
      }
  
      now.column += 1;
  
      return eat($0)(this.renderInline(EMPHASIS, value, now));
  }
  
  /**
   * Tokenise a deletion.
   *
   * @example
   *   tokenizeDeletion(eat, '~~foo~~', '~~', 'foo');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole deletion.
   * @param {string} $1 - Content.
   * @return {Node} - `delete` node.
   */
  function tokenizeDeletion(eat, $0, $1) {
      var now = eat.now();
  
      now.column += 2;
  
      return eat($0)(this.renderInline(DELETE, $1, now));
  }
  
  /**
   * Tokenise inline code.
   *
   * @example
   *   tokenizeInlineCode(eat, '`foo()`', '`', 'foo()');
   *
   * @param {function(string)} eat
   * @param {string} $0 - Whole code.
   * @param {string} $1 - Initial markers.
   * @param {string} $2 - Content.
   * @return {Node} - `inlineCode` node.
   */
  function tokenizeInlineCode(eat, $0, $1, $2) {
      return eat($0)(this.renderRaw(INLINE_CODE, trim($2 || '')));
  }
  
  /**
   * Tokenise a break.
   *
   * @example
   *   tokenizeBreak(eat, '  \n');
   *
   * @param {function(string)} eat
   * @param {string} $0
   * @return {Node} - `break` node.
   */
  function tokenizeBreak(eat, $0) {
      return eat($0)(this.renderVoid(BREAK));
  }
  
  /**
   * Construct a new parser.
   *
   * @example
   *   var parser = new Parser();
   *
   * @constructor
   * @class {Parser}
   * @param {Object?} [options] - Passed to
   *   `Parser#setOptions()`.
   */
  function Parser(options) {
      var self = this;
      var rules = copy({}, self.expressions.rules);
  
      self.inLink = false;
      self.atTop = true;
      self.atStart = true;
      self.inBlockquote = false;
  
      self.rules = rules;
      self.descape = descapeFactory(rules, 'escape');
  
      self.options = clone(self.options);
  
      self.setOptions(options);
  }
  
  /**
   * Set options.  Does not overwrite previously set
   * options.
   *
   * @example
   *   var parser = new Parser();
   *   parser.setOptions({gfm: true});
   *
   * @this {Parser}
   * @throws {Error} - When an option is invalid.
   * @param {Object?} [options] - Parse settings.
   * @return {Parser} - `self`.
   */
  Parser.prototype.setOptions = function (options) {
      var self = this;
      var expressions = self.expressions;
      var rules = self.rules;
      var current = self.options;
      var key;
  
      if (options === null || options === undefined) {
          options = {};
      } else if (typeof options === 'object') {
          options = clone(options);
      } else {
          raise(options, 'options');
      }
  
      self.options = options;
  
      for (key in defaultOptions) {
          validate.boolean(options, key, current[key]);
  
          if (options[key]) {
              copy(rules, expressions[key]);
          }
      }
  
      if (options.gfm && options.breaks) {
          copy(rules, expressions.breaksGFM);
      }
  
      if (options.gfm && options.commonmark) {
          copy(rules, expressions.commonmarkGFM);
      }
  
      if (options.commonmark) {
          self.enterBlockquote = noopToggler();
      }
  
      return self;
  };
  
  /*
   * Expose `defaults`.
   */
  
  Parser.prototype.options = defaultOptions;
  
  /*
   * Expose `expressions`.
   */
  
  Parser.prototype.expressions = defaultExpressions;
  
  /**
   * Factory to track indentation for each line corresponding
   * to the given `start` and the number of invocations.
   *
   * @param {number} start - Starting line.
   * @return {function(offset)} - Indenter.
   */
  Parser.prototype.indent = function (start) {
      var self = this;
      var line = start;
  
      /**
       * Intender which increments the global offset,
       * starting at the bound line, and further incrementing
       * each line for each invocation.
       *
       * @example
       *   indenter(2)
       *
       * @param {number} offset - Number to increment the
       *   offset.
       */
      function indenter(offset) {
          self.offset[line] = (self.offset[line] || 0) + offset;
  
          line++;
      }
  
      return indenter;
  };
  
  /**
   * Parse `value` into an AST.
   *
   * @example
   *   var parser = new Parser();
   *   parser.parse(new File('_Foo_.'));
   *
   * @this {Parser}
   * @param {Object} file
   * @return {Object} - `root` node.
   */
  Parser.prototype.parse = function (file) {
      var self = this;
      var value = clean(String(file));
      var token;
  
      self.file = file;
  
      /*
       * Add an `offset` matrix, used to keep track of
       * syntax and white space indentation per line.
       */
  
      self.offset = {};
  
      token = self.renderBlock(ROOT, value);
  
      if (self.options.position) {
          token.position = {
              'start': {
                  'line': 1,
                  'column': 1
              }
          };
  
          token.position.end = self.eof || token.position.start;
      }
  
      return token;
  };
  
  /*
   * Enter and exit helpers.
   */
  
  Parser.prototype.enterLink = stateToggler('inLink', false);
  Parser.prototype.exitTop = stateToggler('atTop', true);
  Parser.prototype.exitStart = stateToggler('atStart', true);
  Parser.prototype.enterBlockquote = stateToggler('inBlockquote', false);
  
  /*
   * Expose helpers
   */
  
  Parser.prototype.renderRaw = renderRaw;
  Parser.prototype.renderVoid = renderVoid;
  Parser.prototype.renderParent = renderParent;
  Parser.prototype.renderInline = renderInline;
  Parser.prototype.renderBlock = renderBlock;
  
  Parser.prototype.renderLink = renderLink;
  Parser.prototype.renderCodeBlock = renderCodeBlock;
  Parser.prototype.renderBlockquote = renderBlockquote;
  Parser.prototype.renderList = renderList;
  Parser.prototype.renderListItem = renderListItem;
  Parser.prototype.renderFootnoteDefinition = renderFootnoteDefinition;
  Parser.prototype.renderHeading = renderHeading;
  Parser.prototype.renderFootnote = renderFootnote;
  
  /**
   * Construct a tokenizer.  This creates both
   * `tokenizeInline` and `tokenizeBlock`.
   *
   * @example
   *   Parser.prototype.tokenizeInline = tokenizeFactory('inline');
   *
   * @param {string} type - Name of parser, used to find
   *   its expressions (`%sMethods`) and tokenizers
   *   (`%Tokenizers`).
   * @return {function(string, Object?): Array.<Object>}
   */
  function tokenizeFactory(type) {
      /**
       * Tokenizer for a bound `type`
       *
       * @example
       *   parser = new Parser();
       *   parser.tokenizeInline('_foo_');
       *
       * @param {string} value - Content.
       * @param {Object?} [location] - Offset at which `value`
       *   starts.
       * @return {Array.<Object>} - Nodes.
       */
      function tokenize(value, location) {
          var self = this;
          var offset = self.offset;
          var tokens = [];
          var rules = self.rules;
          var methods = self[type + 'Methods'];
          var tokenizers = self[type + 'Tokenizers'];
          var line = location ? location.line : 1;
          var column = location ? location.column : 1;
          var patchPosition = self.options.position;
          var add;
          var index;
          var length;
          var method;
          var name;
          var match;
          var matched;
          var valueLength;
          var eater;
  
          /*
           * Trim white space only lines.
           */
  
          if (!value) {
              return tokens;
          }
  
          /**
           * Update line and column based on `value`.
           *
           * @example
           *   updatePosition('foo');
           *
           * @param {string} subvalue
           */
          function updatePosition(subvalue) {
              var character = -1;
              var subvalueLength = subvalue.length;
              var lastIndex = -1;
  
              while (++character < subvalueLength) {
                  if (subvalue.charAt(character) === NEW_LINE) {
                      lastIndex = character;
                      line++;
                  }
              }
  
              if (lastIndex === -1) {
                  column = column + subvalue.length;
              } else {
                  column = subvalue.length - lastIndex;
              }
  
              if (line in offset) {
                  if (lastIndex !== -1) {
                      column += offset[line];
                  } else if (column <= offset[line]) {
                      column = offset[line] + 1;
                  }
              }
          }
  
          /**
           * Get offset. Called before the fisrt character is
           * eaten to retrieve the range's offsets.
           *
           * @return {Function} - `done`, to be called when
           *   the last character is eaten.
           */
          function getOffset() {
              var indentation = [];
              var pos = line + 1;
  
              /**
               * Done. Called when the last character is
               * eaten to retrieve the range's offsets.
               *
               * @return {Array.<number>} - Offset.
               */
              function done() {
                  var last = line + 1;
  
                  while (pos < last) {
                      indentation.push((offset[pos] || 0) + 1);
  
                      pos++;
                  }
  
                  return indentation;
              }
  
              return done;
          }
  
          /**
           * Get the current position.
           *
           * @example
           *   position = now(); // {line: 1, column: 1}
           *
           * @return {Object}
           */
          function now() {
              return {
                  'line': line,
                  'column': column
              };
          }
  
          /**
           * Store position information for a node.
           *
           * @example
           *   start = now();
           *   updatePosition('foo');
           *   location = new Position(start);
           *   // {start: {line: 1, column: 1}, end: {line: 1, column: 3}}
           *
           * @param {Object} start
           */
          function Position(start) {
              this.start = start;
              this.end = now();
          }
  
          /**
           * Throw when a value is incorrectly eaten.
           * This shouldn’t happen but will throw on new,
           * incorrect rules.
           *
           * @example
           *   // When the current value is set to `foo bar`.
           *   validateEat('foo');
           *   eat('foo');
           *
           *   validateEat('bar');
           *   // throws, because the space is not eaten.
           *
           * @param {string} subvalue - Value to be eaten.
           * @throws {Error} - When `subvalue` cannot be eaten.
           */
          function validateEat(subvalue) {
              /* istanbul ignore if */
              if (value.substring(0, subvalue.length) !== subvalue) {
                  self.file.fail(
                      'Incorrectly eaten value: please report this ' +
                      'warning on http://git.io/vUYWz', now()
                  );
              }
          }
  
          /**
           * Mark position and patch `node.position`.
           *
           * @example
           *   var update = position();
           *   updatePosition('foo');
           *   update({});
           *   // {
           *   //   position: {
           *   //     start: {line: 1, column: 1}
           *   //     end: {line: 1, column: 3}
           *   //   }
           *   // }
           *
           * @returns {function(Node): Node}
           */
          function position() {
              var before = now();
  
              /**
               * Add the position to a node.
               *
               * @example
               *   update({type: 'text', value: 'foo'});
               *
               * @param {Node} node - Node to attach position
               *   on.
               * @return {Node} - `node`.
               */
              function update(node, indent) {
                  var prev = node.position;
                  var start = prev ? prev.start : before;
                  var combined = [];
                  var n = prev && prev.end.line;
                  var l = before.line;
  
                  node.position = new Position(start);
  
                  /*
                   * If there was already a `position`, this
                   * node was merged.  Fixing `start` wasn't
                   * hard, but the indent is different.
                   * Especially because some information, the
                   * indent between `n` and `l` wasn't
                   * tracked.  Luckily, that space is
                   * (should be?) empty, so we can safely
                   * check for it now.
                   */
  
                  if (prev) {
                      combined = prev.indent;
  
                      if (n < l) {
                          while (++n < l) {
                              combined.push((offset[n] || 0) + 1);
                          }
  
                          combined.push(before.column);
                      }
  
                      indent = combined.concat(indent);
                  }
  
                  node.position.indent = indent;
  
  
                  return node;
              }
  
              return update;
          }
  
          /**
           * Add `token` to `parent`s children or to `tokens`.
           * Performs merges where possible.
           *
           * @example
           *   add({});
           *
           *   add({}, {children: []});
           *
           * @param {Object} token - Node to add.
           * @param {Object} [parent] - Parent to insert into.
           * @return {Object} - Added or merged into token.
           */
          add = function (token, parent) {
              var isMultiple = 'length' in token;
              var prev;
              var children;
  
              if (!parent) {
                  children = tokens;
              } else {
                  children = parent.children;
              }
  
              if (isMultiple) {
                  arrayPush.apply(children, token);
              } else {
                  if (type === INLINE && token.type === TEXT) {
                      token.value = decode(token.value, eater);
                  }
  
                  prev = children[children.length - 1];
  
                  if (
                      prev &&
                      token.type === prev.type &&
                      token.type in MERGEABLE_NODES
                  ) {
                      token = MERGEABLE_NODES[token.type].call(
                          self, prev, token
                      );
                  }
  
                  if (token !== prev) {
                      children.push(token);
                  }
  
                  if (self.atStart && tokens.length) {
                      self.exitStart();
                  }
              }
  
              return token;
          };
  
          /**
           * Remove `subvalue` from `value`.
           * Expects `subvalue` to be at the start from
           * `value`, and applies no validation.
           *
           * @example
           *   eat('foo')({type: 'text', value: 'foo'});
           *
           * @param {string} subvalue - Removed from `value`,
           *   and passed to `updatePosition`.
           * @return {Function} - Wrapper around `add`, which
           *   also adds `position` to node.
           */
          function eat(subvalue) {
              var indent = getOffset();
              var pos = position();
              var current = now();
  
              validateEat(subvalue);
  
              /**
               * Add the given arguments, add `position` to
               * the returned node, and return the node.
               *
               * @return {Node}
               */
              function apply() {
                  return pos(add.apply(null, arguments), indent);
              }
  
              /**
               * Functions just like apply, but resets the
               * content:  the line and column are reversed,
               * and the eaten value is re-added.
               *
               * This is useful for nodes with a single
               * type of content, such as lists and tables.
               *
               * See `apply` above for what parameters are
               * expected.
               *
               * @return {Node}
               */
              function reset() {
                  var node = apply.apply(null, arguments);
  
                  line = current.line;
                  column = current.column;
                  value = subvalue + value;
  
                  return node;
              }
  
              apply.reset = reset;
  
              value = value.substring(subvalue.length);
  
              updatePosition(subvalue);
  
              indent = indent();
  
              return apply;
          }
  
          /**
           * Same as `eat` above, but will not add positional
           * information to nodes.
           *
           * @example
           *   noEat('foo')({type: 'text', value: 'foo'});
           *
           * @param {string} subvalue - Removed from `value`.
           * @return {Function} - Wrapper around `add`.
           */
          function noEat(subvalue) {
              validateEat(subvalue);
  
              /**
               * Add the given arguments, and return the
               * node.
               *
               * @return {Node}
               */
              function apply() {
                  return add.apply(null, arguments);
              }
  
              /**
               * Functions just like apply, but resets the
               * content: the eaten value is re-added.
               *
               * @return {Node}
               */
              function reset() {
                  var node = apply.apply(null, arguments);
  
                  value = subvalue + value;
  
                  return node;
              }
  
              apply.reset = reset;
  
              value = value.substring(subvalue.length);
  
              return apply;
          }
  
          /*
           * Expose the eater, depending on if `position`s
           * should be patched on nodes.
           */
  
          eater = patchPosition ? eat : noEat;
  
          /*
           * Expose `now` on `eater`.
           */
  
          eater.now = now;
  
          /*
           * Expose `file` on `eater`.
           */
  
          eater.file = self.file;
  
          /*
           * Sync initial offset.
           */
  
          updatePosition(EMPTY);
  
          /*
           * Iterate over `value`, and iterate over all
           * block-expressions.  When one matches, invoke
           * its companion function.  If no expression
           * matches, something failed (should not happen)
           * and an exception is thrown.
           */
  
          while (value) {
              index = -1;
              length = methods.length;
              matched = false;
  
              while (++index < length) {
                  name = methods[index];
  
                  method = tokenizers[name];
  
                  match = rules[name] &&
                      method &&
                      (!method.onlyAtStart || self.atStart) &&
                      (!method.onlyAtTop || self.atTop) &&
                      (!method.notInBlockquote || !self.inBlockquote) &&
                      (!method.notInLink || !self.inLink) &&
                      rules[name].exec(value);
  
                  if (match) {
                      valueLength = value.length;
  
                      method.apply(self, [eater].concat(match));
  
                      matched = valueLength !== value.length;
  
                      if (matched) {
                          break;
                      }
                  }
              }
  
              /* istanbul ignore if */
              if (!matched) {
                  self.file.fail('Infinite loop', eater.now());
  
                  /*
                   * Errors are not thrown on `File#fail`
                   * when `quiet: true`.
                   */
  
                  break;
              }
          }
  
          self.eof = now();
  
          return tokens;
      }
  
      return tokenize;
  }
  
  /*
   * Expose tokenizers for block-level nodes.
   */
  
  Parser.prototype.blockTokenizers = {
      'yamlFrontMatter': tokenizeYAMLFrontMatter,
      'newline': tokenizeNewline,
      'code': tokenizeCode,
      'fences': tokenizeFences,
      'heading': tokenizeHeading,
      'lineHeading': tokenizeLineHeading,
      'horizontalRule': tokenizeHorizontalRule,
      'blockquote': tokenizeBlockquote,
      'list': tokenizeList,
      'html': tokenizeHtml,
      'definition': tokenizeDefinition,
      'footnoteDefinition': tokenizeFootnoteDefinition,
      'looseTable': tokenizeTable,
      'table': tokenizeTable,
      'paragraph': tokenizeParagraph
  };
  
  /*
   * Expose order in which to parse block-level nodes.
   */
  
  Parser.prototype.blockMethods = [
      'yamlFrontMatter',
      'newline',
      'code',
      'fences',
      'blockquote',
      'heading',
      'horizontalRule',
      'list',
      'lineHeading',
      'html',
      'definition',
      'footnoteDefinition',
      'looseTable',
      'table',
      'paragraph',
      'blockText'
  ];
  
  /**
   * Block tokenizer.
   *
   * @example
   *   var parser = new Parser();
   *   parser.tokenizeBlock('> foo.');
   *
   * @param {string} value - Content.
   * @return {Array.<Object>} - Nodes.
   */
  
  Parser.prototype.tokenizeBlock = tokenizeFactory(BLOCK);
  
  /*
   * Expose tokenizers for inline-level nodes.
   */
  
  Parser.prototype.inlineTokenizers = {
      'escape': tokenizeEscape,
      'autoLink': tokenizeAutoLink,
      'url': tokenizeURL,
      'tag': tokenizeTag,
      'link': tokenizeLink,
      'reference': tokenizeReference,
      'shortcutReference': tokenizeReference,
      'strong': tokenizeStrong,
      'emphasis': tokenizeEmphasis,
      'deletion': tokenizeDeletion,
      'inlineCode': tokenizeInlineCode,
      'break': tokenizeBreak,
      'inlineText': tokenizeText
  };
  
  /*
   * Expose order in which to parse inline-level nodes.
   */
  
  Parser.prototype.inlineMethods = [
      'escape',
      'autoLink',
      'url',
      'tag',
      'link',
      'reference',
      'shortcutReference',
      'strong',
      'emphasis',
      'deletion',
      'inlineCode',
      'break',
      'inlineText'
  ];
  
  /**
   * Inline tokenizer.
   *
   * @example
   *   var parser = new Parser();
   *   parser.tokenizeInline('_foo_');
   *
   * @param {string} value - Content.
   * @return {Array.<Object>} - Nodes.
   */
  
  Parser.prototype.tokenizeInline = tokenizeFactory(INLINE);
  
  /**
   * Transform a markdown document into an AST.
   *
   * @example
   *   parse(new File('> foo.'), {gfm: true});
   *
   * @this {Object?} - When this function is places on an
   *   object which also houses a `Parser` property, that
   *   class is used.
   * @param {File} file - Virtual file.
   * @param {Object?} [options] - Settings for the parser.
   * @return {Object} - Abstract syntax tree.
   */
  function parse(file, options) {
      var CustomParser = this.Parser || Parser;
  
      return new CustomParser(options).parse(file);
  }
  
  /*
   * Expose `Parser` on `parse`.
   */
  
  parse.Parser = Parser;
  
  /*
   * Expose `tokenizeFactory` so dependencies could create
   * their own tokenizers.
   */
  
  Parser.prototype.tokenizeFactory = tokenizeFactory;
  
  /*
   * Expose `parse` on `module.exports`.
   */
  
  module.exports = parse;
  
  
  /***/ }),
  
  /***/ 954:
  /***/ (function(module) {
  
  module.exports = validateAuth;
  
  function validateAuth(auth) {
    if (typeof auth === "string") {
      return;
    }
  
    if (typeof auth === "function") {
      return;
    }
  
    if (auth.username && auth.password) {
      return;
    }
  
    if (auth.clientId && auth.clientSecret) {
      return;
    }
  
    throw new Error(`Invalid "auth" option: ${JSON.stringify(auth)}`);
  }
  
  
  /***/ }),
  
  /***/ 955:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const path = __webpack_require__(622);
  const childProcess = __webpack_require__(129);
  const crossSpawn = __webpack_require__(20);
  const stripEof = __webpack_require__(768);
  const npmRunPath = __webpack_require__(621);
  const isStream = __webpack_require__(323);
  const _getStream = __webpack_require__(145);
  const pFinally = __webpack_require__(697);
  const onExit = __webpack_require__(260);
  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);
  
  
  /***/ }),
  
  /***/ 966:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  "use strict";
  
  const {PassThrough} = __webpack_require__(413);
  
  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;
  };
  
  
  /***/ }),
  
  /***/ 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
  }
  
  
  /***/ }),
  
  /***/ 986:
  /***/ (function(module, __unusedexports, __webpack_require__) {
  
  /**
   * Module Dependencies
   */
  
  var noop = function(){};
  var co = __webpack_require__(987);
  
  /**
   * Export `wrap-fn`
   */
  
  module.exports = wrap;
  
  /**
   * Wrap a function to support
   * sync, async, and gen functions.
   *
   * @param {Function} fn
   * @param {Function} done
   * @return {Function}
   * @api public
   */
  
  function wrap(fn, done) {
    done = once(done || noop);
  
    return function() {
      // prevents arguments leakage
      // see https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments
      var i = arguments.length;
      var args = new Array(i);
      while (i--) args[i] = arguments[i];
  
      var ctx = this;
  
      // done
      if (!fn) {
        return done.apply(ctx, [null].concat(args));
      }
  
      // async
      if (fn.length > args.length) {
        // NOTE: this only handles uncaught synchronous errors
        try {
          return fn.apply(ctx, args.concat(done));
        } catch (e) {
          return done(e);
        }
      }
  
      // generator
      if (generator(fn)) {
        return co(fn).apply(ctx, args.concat(done));
      }
  
      // sync
      return sync(fn, done).apply(ctx, args);
    }
  }
  
  /**
   * Wrap a synchronous function execution.
   *
   * @param {Function} fn
   * @param {Function} done
   * @return {Function}
   * @api private
   */
  
  function sync(fn, done) {
    return function () {
      var ret;
  
      try {
        ret = fn.apply(this, arguments);
      } catch (err) {
        return done(err);
      }
  
      if (promise(ret)) {
        ret.then(function (value) { done(null, value); }, done);
      } else {
        ret instanceof Error ? done(ret) : done(null, ret);
      }
    }
  }
  
  /**
   * Is `value` a generator?
   *
   * @param {Mixed} value
   * @return {Boolean}
   * @api private
   */
  
  function generator(value) {
    return value
      && value.constructor
      && 'GeneratorFunction' == value.constructor.name;
  }
  
  
  /**
   * Is `value` a promise?
   *
   * @param {Mixed} value
   * @return {Boolean}
   * @api private
   */
  
  function promise(value) {
    return value && 'function' == typeof value.then;
  }
  
  /**
   * Once
   */
  
  function once(fn) {
    return function() {
      var ret = fn.apply(this, arguments);
      fn = noop;
      return ret;
    };
  }
  
  
  /***/ }),
  
  /***/ 987:
  /***/ (function(module) {
  
  
  /**
   * slice() reference.
   */
  
  var slice = Array.prototype.slice;
  
  /**
   * Expose `co`.
   */
  
  module.exports = co;
  
  /**
   * Wrap the given generator `fn` and
   * return a thunk.
   *
   * @param {Function} fn
   * @return {Function}
   * @api public
   */
  
  function co(fn) {
    var isGenFun = isGeneratorFunction(fn);
  
    return function (done) {
      var ctx = this;
  
      // in toThunk() below we invoke co()
      // with a generator, so optimize for
      // this case
      var gen = fn;
  
      // we only need to parse the arguments
      // if gen is a generator function.
      if (isGenFun) {
        var args = slice.call(arguments), len = args.length;
        var hasCallback = len && 'function' == typeof args[len - 1];
        done = hasCallback ? args.pop() : error;
        gen = fn.apply(this, args);
      } else {
        done = done || error;
      }
  
      next();
  
      // #92
      // wrap the callback in a setImmediate
      // so that any of its errors aren't caught by `co`
      function exit(err, res) {
        setImmediate(function(){
          done.call(ctx, err, res);
        });
      }
  
      function next(err, res) {
        var ret;
  
        // multiple args
        if (arguments.length > 2) res = slice.call(arguments, 1);
  
        // error
        if (err) {
          try {
            ret = gen.throw(err);
          } catch (e) {
            return exit(e);
          }
        }
  
        // ok
        if (!err) {
          try {
            ret = gen.next(res);
          } catch (e) {
            return exit(e);
          }
        }
  
        // done
        if (ret.done) return exit(null, ret.value);
  
        // normalize
        ret.value = toThunk(ret.value, ctx);
  
        // run
        if ('function' == typeof ret.value) {
          var called = false;
          try {
            ret.value.call(ctx, function(){
              if (called) return;
              called = true;
              next.apply(ctx, arguments);
            });
          } catch (e) {
            setImmediate(function(){
              if (called) return;
              called = true;
              next(e);
            });
          }
          return;
        }
  
        // invalid
        next(new TypeError('You may only yield a function, promise, generator, array, or object, '
          + 'but the following was passed: "' + String(ret.value) + '"'));
      }
    }
  }
  
  /**
   * Convert `obj` into a normalized thunk.
   *
   * @param {Mixed} obj
   * @param {Mixed} ctx
   * @return {Function}
   * @api private
   */
  
  function toThunk(obj, ctx) {
  
    if (isGeneratorFunction(obj)) {
      return co(obj.call(ctx));
    }
  
    if (isGenerator(obj)) {
      return co(obj);
    }
  
    if (isPromise(obj)) {
      return promiseToThunk(obj);
    }
  
    if ('function' == typeof obj) {
      return obj;
    }
  
    if (isObject(obj) || Array.isArray(obj)) {
      return objectToThunk.call(ctx, obj);
    }
  
    return obj;
  }
  
  /**
   * Convert an object of yieldables to a thunk.
   *
   * @param {Object} obj
   * @return {Function}
   * @api private
   */
  
  function objectToThunk(obj){
    var ctx = this;
    var isArray = Array.isArray(obj);
  
    return function(done){
      var keys = Object.keys(obj);
      var pending = keys.length;
      var results = isArray
        ? new Array(pending) // predefine the array length
        : new obj.constructor();
      var finished;
  
      if (!pending) {
        setImmediate(function(){
          done(null, results)
        });
        return;
      }
  
      // prepopulate object keys to preserve key ordering
      if (!isArray) {
        for (var i = 0; i < pending; i++) {
          results[keys[i]] = undefined;
        }
      }
  
      for (var i = 0; i < keys.length; i++) {
        run(obj[keys[i]], keys[i]);
      }
  
      function run(fn, key) {
        if (finished) return;
        try {
          fn = toThunk(fn, ctx);
  
          if ('function' != typeof fn) {
            results[key] = fn;
            return --pending || done(null, results);
          }
  
          fn.call(ctx, function(err, res){
            if (finished) return;
  
            if (err) {
              finished = true;
              return done(err);
            }
  
            results[key] = res;
            --pending || done(null, results);
          });
        } catch (err) {
          finished = true;
          done(err);
        }
      }
    }
  }
  
  /**
   * Convert `promise` to a thunk.
   *
   * @param {Object} promise
   * @return {Function}
   * @api private
   */
  
  function promiseToThunk(promise) {
    return function(fn){
      promise.then(function(res) {
        fn(null, res);
      }, fn);
    }
  }
  
  /**
   * Check if `obj` is a promise.
   *
   * @param {Object} obj
   * @return {Boolean}
   * @api private
   */
  
  function isPromise(obj) {
    return obj && 'function' == typeof obj.then;
  }
  
  /**
   * Check if `obj` is a generator.
   *
   * @param {Mixed} obj
   * @return {Boolean}
   * @api private
   */
  
  function isGenerator(obj) {
    return obj && 'function' == typeof obj.next && 'function' == typeof obj.throw;
  }
  
  /**
   * Check if `obj` is a generator function.
   *
   * @param {Mixed} obj
   * @return {Boolean}
   * @api private
   */
  
  function isGeneratorFunction(obj) {
    return obj && obj.constructor && 'GeneratorFunction' == obj.constructor.name;
  }
  
  /**
   * Check for plain object.
   *
   * @param {Mixed} val
   * @return {Boolean}
   * @api private
   */
  
  function isObject(val) {
    return val && Object == val.constructor;
  }
  
  /**
   * Throw `err` in a new stack.
   *
   * This is used when co() is invoked
   * without supplying a callback, which
   * should only be for demonstrational
   * purposes.
   *
   * @param {Error} err
   * @api private
   */
  
  function error(err) {
    if (!err) return;
    setImmediate(function(){
      throw err;
    });
  }
  
  
  /***/ })
  
  /******/ },
  /******/ function(__webpack_require__) { // webpackRuntimeModules
  /******/ 	"use strict";
  /******/ 
  /******/ 	/* webpack/runtime/node module decorator */
  /******/ 	!function() {
  /******/ 		__webpack_require__.nmd = function(module) {
  /******/ 			module.paths = [];
  /******/ 			if (!module.children) module.children = [];
  /******/ 			Object.defineProperty(module, 'loaded', {
  /******/ 				enumerable: true,
  /******/ 				get: function() { return module.l; }
  /******/ 			});
  /******/ 			Object.defineProperty(module, 'id', {
  /******/ 				enumerable: true,
  /******/ 				get: function() { return module.i; }
  /******/ 			});
  /******/ 			return module;
  /******/ 		};
  /******/ 	}();
  /******/ 	
  /******/ }
  );